From b28fd5e292a4581491b36aadde0dc63c642bc0ff Mon Sep 17 00:00:00 2001 From: Vaibhav Malik <34866732+VaibhavMalik4187@users.noreply.github.com> Date: Tue, 13 Feb 2024 15:31:33 +0530 Subject: [PATCH 01/79] Added tests for the go/trace package (#15052) Signed-off-by: VaibhavMalik4187 --- go/trace/fake_test.go | 33 +++++++++++++ go/trace/logger_test.go | 72 ++++++++++++++++++++++++++++ go/trace/opentracing_test.go | 28 +++++++++++ go/trace/plugin_datadog_test.go | 39 +++++++++++++++ go/trace/plugin_jaeger_test.go | 35 ++++++++++++++ go/trace/trace_test.go | 85 ++++++++++++++++++++++++++++++++- go/trace/utils_test.go | 41 ++++++++++++++++ 7 files changed, 331 insertions(+), 2 deletions(-) create mode 100644 go/trace/fake_test.go create mode 100644 go/trace/logger_test.go create mode 100644 go/trace/plugin_datadog_test.go create mode 100644 go/trace/plugin_jaeger_test.go create mode 100644 go/trace/utils_test.go diff --git a/go/trace/fake_test.go b/go/trace/fake_test.go new file mode 100644 index 00000000000..d7d01333202 --- /dev/null +++ b/go/trace/fake_test.go @@ -0,0 +1,33 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package trace + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestNoopTracingServer(t *testing.T) { + factoryFunc := tracingBackendFactories["noop"] + tracingSvc, closer, err := factoryFunc("value") + require.NoError(t, err) + require.NoError(t, closer.Close()) + span, err := tracingSvc.NewFromString("parent", "label") + require.NoError(t, err) + require.Empty(t, span) +} diff --git a/go/trace/logger_test.go b/go/trace/logger_test.go new file mode 100644 index 00000000000..cb414515fa5 --- /dev/null +++ b/go/trace/logger_test.go @@ -0,0 +1,72 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package trace + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" +) + +// If captureStdout is false, it will capture the outut of +// os.Stderr +func captureOutput(t *testing.T, f func(), captureStdout bool) string { + oldVal := os.Stderr + if captureStdout { + oldVal = os.Stdout + } + t.Cleanup(func() { + // Ensure reset even if deferred function panics + if captureStdout { + os.Stdout = oldVal + } else { + os.Stderr = oldVal + } + }) + + r, w, _ := os.Pipe() + if captureStdout { + os.Stdout = w + } else { + os.Stderr = w + } + + f() + + w.Close() + got, _ := io.ReadAll(r) + + return string(got) +} + +func TestLoggerLogAndError(t *testing.T) { + logger := traceLogger{} + + // Test Error() output + output := captureOutput(t, func() { + logger.Error("This is an error message") + }, false) + assert.Contains(t, output, "This is an error message") + + // Test Log() output + output = captureOutput(t, func() { + logger.Log("This is an log message") + }, false) + assert.Contains(t, output, "This is an log message") +} diff --git a/go/trace/opentracing_test.go b/go/trace/opentracing_test.go index 104545fe657..4a1dad369d9 100644 --- a/go/trace/opentracing_test.go +++ b/go/trace/opentracing_test.go @@ -17,12 +17,14 @@ limitations under the License. package trace import ( + "context" "encoding/base64" "encoding/json" "testing" "github.com/opentracing/opentracing-go" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestExtractMapFromString(t *testing.T) { @@ -47,3 +49,29 @@ func TestErrorConditions(t *testing.T) { _, err = extractMapFromString("this is not base64") // malformed base64 assert.Error(t, err) } + +func TestNewClientSpan(t *testing.T) { + svc := openTracingService{ + Tracer: &fakeTracer{}, + } + clientSpan := svc.NewClientSpan(nil, "test-svc", "test-label") + require.NotEmpty(t, clientSpan) + + clientSpan = svc.New(clientSpan, "client-span") + require.NotEmpty(t, clientSpan) + + spanFromCtx, ok := svc.FromContext(context.Background()) + require.False(t, ok) + require.Nil(t, spanFromCtx) + + ctx := svc.NewContext(context.TODO(), clientSpan) + require.NotNil(t, ctx) + clientSpan.Finish() + + spanFromCtx, ok = svc.FromContext(ctx) + require.True(t, ok) + require.NotEmpty(t, spanFromCtx) + + ctx = svc.NewContext(context.TODO(), &mockSpan{}) + require.Nil(t, ctx) +} diff --git a/go/trace/plugin_datadog_test.go b/go/trace/plugin_datadog_test.go new file mode 100644 index 00000000000..4dc43a80c1e --- /dev/null +++ b/go/trace/plugin_datadog_test.go @@ -0,0 +1,39 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package trace + +import ( + "testing" + + "github.com/opentracing/opentracing-go" + "github.com/stretchr/testify/require" +) + +func TestGetOpenTracingTracer(t *testing.T) { + tracer := datadogTracer{ + actual: opentracing.GlobalTracer(), + } + require.Equal(t, opentracing.GlobalTracer(), tracer.GetOpenTracingTracer()) +} + +func TestNewDataDogTracerHostAndPortNotSet(t *testing.T) { + tracingSvc, closer, err := newDatadogTracer("svc") + expectedErr := "need host and port to datadog agent to use datadog tracing" + require.ErrorContains(t, err, expectedErr) + require.Nil(t, tracingSvc) + require.Nil(t, closer) +} diff --git a/go/trace/plugin_jaeger_test.go b/go/trace/plugin_jaeger_test.go new file mode 100644 index 00000000000..0deab36c7ce --- /dev/null +++ b/go/trace/plugin_jaeger_test.go @@ -0,0 +1,35 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package trace + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestNewJaegerTracerFromEnv(t *testing.T) { + tracingSvc, closer, err := newJagerTracerFromEnv("noop") + require.NoError(t, err) + require.NotEmpty(t, tracingSvc) + require.NotEmpty(t, closer) + + tracingSvc, closer, err = newJagerTracerFromEnv("") + require.ErrorContains(t, err, "no service name provided") + require.Empty(t, tracingSvc) + require.Empty(t, closer) +} diff --git a/go/trace/trace_test.go b/go/trace/trace_test.go index c98a47167a8..6b5bdf491bb 100644 --- a/go/trace/trace_test.go +++ b/go/trace/trace_test.go @@ -22,7 +22,9 @@ import ( "io" "testing" + "github.com/opentracing/opentracing-go" "github.com/spf13/viper" + "github.com/stretchr/testify/require" "google.golang.org/grpc" "vitess.io/vitess/go/viperutil/vipertest" @@ -68,13 +70,80 @@ func TestRegisterService(t *testing.T) { } } +func TestNewFromString(t *testing.T) { + tests := []struct { + parent string + label string + context context.Context + expectedLog string + isPresent bool + expectedErr string + }{ + { + parent: "", + label: "empty parent", + context: context.TODO(), + expectedLog: "", + isPresent: true, + expectedErr: "parent is empty", + }, + { + parent: "parent", + label: "non-empty parent", + expectedLog: "[key: sql-statement-type values:non-empty parent]\n", + context: context.Background(), + isPresent: false, + }, + } + for _, tt := range tests { + tt := tt + t.Run(tt.label, func(t *testing.T) { + span, ctx, err := NewFromString(context.Background(), tt.parent, tt.label) + if tt.expectedErr == "" { + require.NoError(t, err) + require.NotEmpty(t, span) + require.Equal(t, tt.context, ctx) + + got := captureOutput(t, func() { + AnnotateSQL(span, &fakeStringer{tt.label}) + }, true) + + require.Equal(t, tt.expectedLog, got) + } else { + require.ErrorContains(t, err, tt.expectedErr) + require.Nil(t, span) + require.Nil(t, ctx) + } + + copySpan := CopySpan(context.TODO(), tt.context) + if tt.isPresent { + require.Equal(t, tt.context, copySpan) + } else { + require.Equal(t, context.TODO(), copySpan) + } + }) + } +} + +func TestNilCloser(t *testing.T) { + nc := nilCloser{} + require.Nil(t, nc.Close()) +} + type fakeTracer struct { name string log []string } +func (f *fakeTracer) GetOpenTracingTracer() opentracing.Tracer { + return opentracing.GlobalTracer() +} + func (f *fakeTracer) NewFromString(parent, label string) (Span, error) { - panic("implement me") + if parent == "" { + return &mockSpan{tracer: f}, fmt.Errorf("parent is empty") + } + return &mockSpan{tracer: f}, nil } func (f *fakeTracer) New(parent Span, label string) Span { @@ -84,7 +153,10 @@ func (f *fakeTracer) New(parent Span, label string) Span { } func (f *fakeTracer) FromContext(ctx context.Context) (Span, bool) { - return nil, false + if ctx == context.Background() { + return nil, false + } + return &mockSpan{}, true } func (f *fakeTracer) NewContext(parent context.Context, span Span) context.Context { @@ -113,4 +185,13 @@ func (m *mockSpan) Finish() { func (m *mockSpan) Annotate(key string, value any) { m.tracer.log = append(m.tracer.log, fmt.Sprintf("key: %v values:%v", key, value)) + fmt.Println(m.tracer.log) +} + +type fakeStringer struct { + str string +} + +func (fs *fakeStringer) String() string { + return fs.str } diff --git a/go/trace/utils_test.go b/go/trace/utils_test.go new file mode 100644 index 00000000000..63bbcfa1528 --- /dev/null +++ b/go/trace/utils_test.go @@ -0,0 +1,41 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package trace + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestLogErrorsWhenClosing(t *testing.T) { + logFunc := LogErrorsWhenClosing(&fakeCloser{}) + + got := captureOutput(t, func() { + logFunc() + }, false) + + require.Contains(t, string(got), "test error") +} + +type fakeCloser struct { +} + +func (fc *fakeCloser) Close() error { + return fmt.Errorf("test error") +} From 696fe0ebebb6b72ad25b598354ae5473d1126775 Mon Sep 17 00:00:00 2001 From: Vaibhav Malik <34866732+VaibhavMalik4187@users.noreply.github.com> Date: Tue, 13 Feb 2024 15:32:49 +0530 Subject: [PATCH 02/79] Added missing tests for the go/streamlog package (#15064) Signed-off-by: VaibhavMalik4187 --- go/streamlog/streamlog_test.go | 124 +++++++++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) diff --git a/go/streamlog/streamlog_test.go b/go/streamlog/streamlog_test.go index 9c0b0366a1d..e653de74ea8 100644 --- a/go/streamlog/streamlog_test.go +++ b/go/streamlog/streamlog_test.go @@ -18,6 +18,7 @@ package streamlog import ( "bufio" + "bytes" "fmt" "io" "net" @@ -29,6 +30,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "vitess.io/vitess/go/vt/servenv" ) @@ -260,3 +263,124 @@ func TestFile(t *testing.T) { t.Errorf("streamlog file: want %q got %q", want, got) } } + +func TestShouldEmitLog(t *testing.T) { + origQueryLogFilterTag := queryLogFilterTag + origQueryLogRowThreshold := queryLogRowThreshold + defer func() { + SetQueryLogFilterTag(origQueryLogFilterTag) + SetQueryLogRowThreshold(origQueryLogRowThreshold) + }() + + tests := []struct { + sql string + qLogFilterTag string + qLogRowThreshold uint64 + rowsAffected uint64 + rowsReturned uint64 + ok bool + }{ + { + sql: "queryLogThreshold smaller than affected and returned", + qLogFilterTag: "", + qLogRowThreshold: 2, + rowsAffected: 7, + rowsReturned: 7, + ok: true, + }, + { + sql: "queryLogThreshold greater than affected and returned", + qLogFilterTag: "", + qLogRowThreshold: 27, + rowsAffected: 7, + rowsReturned: 17, + ok: false, + }, + { + sql: "this doesn't contains queryFilterTag: TAG", + qLogFilterTag: "special tag", + qLogRowThreshold: 10, + rowsAffected: 7, + rowsReturned: 17, + ok: false, + }, + { + sql: "this contains queryFilterTag: TAG", + qLogFilterTag: "TAG", + qLogRowThreshold: 0, + rowsAffected: 7, + rowsReturned: 17, + ok: true, + }, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.sql, func(t *testing.T) { + SetQueryLogFilterTag(tt.qLogFilterTag) + SetQueryLogRowThreshold(tt.qLogRowThreshold) + + require.Equal(t, tt.ok, ShouldEmitLog(tt.sql, tt.rowsAffected, tt.rowsReturned)) + }) + } +} + +func TestGetFormatter(t *testing.T) { + tests := []struct { + name string + logger *StreamLogger[string] + params url.Values + val any + expectedErr string + expectedOutput string + }{ + { + name: "unexpected value error", + logger: &StreamLogger[string]{ + name: "test-logger", + }, + params: url.Values{ + "keys": []string{"key1", "key2"}, + }, + val: "temp val", + expectedOutput: "Error: unexpected value of type string in test-logger!", + expectedErr: "", + }, + { + name: "mock formatter", + logger: &StreamLogger[string]{ + name: "test-logger", + }, + params: url.Values{ + "keys": []string{"key1", "key2"}, + }, + val: &mockFormatter{err: fmt.Errorf("formatter error")}, + expectedErr: "formatter error", + }, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + var buffer bytes.Buffer + logFormatterFunc := GetFormatter[string](tt.logger) + err := logFormatterFunc(&buffer, tt.params, tt.val) + if tt.expectedErr == "" { + require.NoError(t, err) + require.Equal(t, tt.expectedOutput, buffer.String()) + } else { + require.ErrorContains(t, err, tt.expectedErr) + } + }) + } +} + +type mockFormatter struct { + called bool + err error +} + +func (mf *mockFormatter) Logf(w io.Writer, params url.Values) error { + mf.called = true + return mf.err +} From a404807dd63231f9850cb560ebf0472438d6a294 Mon Sep 17 00:00:00 2001 From: Noble Mittal <62551163+beingnoble03@users.noreply.github.com> Date: Tue, 13 Feb 2024 16:47:12 +0530 Subject: [PATCH 03/79] Add missing tests for `go/vt/vtorc/collection` (#15070) Signed-off-by: Noble Mittal --- go/vt/vtorc/collection/collection.go | 4 +- go/vt/vtorc/collection/collection_test.go | 127 ++++++++++++++++++++++ 2 files changed, 129 insertions(+), 2 deletions(-) diff --git a/go/vt/vtorc/collection/collection.go b/go/vt/vtorc/collection/collection.go index 0ef9a71b9a3..4f679286978 100644 --- a/go/vt/vtorc/collection/collection.go +++ b/go/vt/vtorc/collection/collection.go @@ -260,8 +260,8 @@ func (c *Collection) removeBefore(t time.Time) error { // get the interval we need. if first == len(c.collection) { c.collection = nil // remove all entries - } else if first != -1 { - c.collection = c.collection[first:] + } else { + c.collection = c.collection[first+1:] } return nil // no errors } diff --git a/go/vt/vtorc/collection/collection_test.go b/go/vt/vtorc/collection/collection_test.go index 23679245c26..16ea6943dc7 100644 --- a/go/vt/vtorc/collection/collection_test.go +++ b/go/vt/vtorc/collection/collection_test.go @@ -19,6 +19,8 @@ package collection import ( "testing" "time" + + "github.com/stretchr/testify/assert" ) var randomString = []string{ @@ -28,6 +30,7 @@ var randomString = []string{ // some random base timestamp var ts = time.Date(2016, 12, 27, 13, 36, 40, 0, time.Local) +var ts2 = ts.AddDate(-1, 0, 0) // TestCreateOrReturn tests the creation of a named Collection func TestCreateOrReturnCollection(t *testing.T) { @@ -87,6 +90,13 @@ func (tm *testMetric) When() time.Time { return ts } +type testMetric2 struct { +} + +func (tm *testMetric2) When() time.Time { + return ts2 +} + // check that Append() works as expected func TestAppend(t *testing.T) { c := &Collection{} @@ -101,4 +111,121 @@ func TestAppend(t *testing.T) { t.Errorf("TestExpirePeriod: len(Metrics) = %d, expecting %d", len(c.Metrics()), v) } } + + // Test for nil metric + err := c.Append(nil) + assert.Error(t, err) + assert.Equal(t, err.Error(), "Collection.Append: m == nil") +} + +func TestNilCollection(t *testing.T) { + var c *Collection + + metrics := c.Metrics() + assert.Nil(t, metrics) + + err := c.Append(nil) + assert.Error(t, err) + assert.Equal(t, err.Error(), "Collection.Append: c == nil") + + err = c.removeBefore(ts) + assert.Error(t, err) + assert.Equal(t, err.Error(), "Collection.removeBefore: c == nil") + + // Should not throw any error for nil Collection + c.StartAutoExpiration() + c.StopAutoExpiration() +} + +func TestStopAutoExpiration(t *testing.T) { + oldNamedCollection := namedCollection + defer func() { + namedCollection = oldNamedCollection + }() + // Clear Collection map + namedCollection = make(map[string]*Collection) + + name := randomString[0] + c := CreateOrReturnCollection(name) + + c.StopAutoExpiration() + assert.False(t, c.monitoring) + + // Test when c.monitoring == true before calling StartAutoExpiration + c.monitoring = true + c.StartAutoExpiration() + assert.True(t, c.monitoring) +} + +func TestSince(t *testing.T) { + oldNamedCollection := namedCollection + defer func() { + namedCollection = oldNamedCollection + }() + // Clear Collection map + namedCollection = make(map[string]*Collection) + + name := randomString[0] + + var c *Collection + metrics, err := c.Since(ts) + + assert.Nil(t, metrics) + assert.Error(t, err) + assert.Equal(t, err.Error(), "Collection.Since: c == nil") + + c = CreateOrReturnCollection(name) + metrics, err = c.Since(ts) + assert.Nil(t, metrics) + assert.Nil(t, err) + + tm := &testMetric{} + tm2 := &testMetric2{} + _ = c.Append(tm2) + _ = c.Append(tm) + + metrics, err = c.Since(ts2) + assert.Equal(t, []Metric{tm2, tm}, metrics) + assert.Nil(t, err) + + metrics, err = c.Since(ts) + assert.Equal(t, []Metric{tm}, metrics) + assert.Nil(t, err) +} + +func TestRemoveBefore(t *testing.T) { + oldNamedCollection := namedCollection + defer func() { + namedCollection = oldNamedCollection + }() + // Clear Collection map + namedCollection = make(map[string]*Collection) + + name := randomString[0] + c := CreateOrReturnCollection(name) + + tm := &testMetric{} + tm2 := &testMetric2{} + + err := c.Append(tm2) + assert.Nil(t, err) + + err = c.Append(tm) + assert.Nil(t, err) + + err = c.removeBefore(ts) + assert.NoError(t, err) + assert.Equal(t, []Metric{tm}, c.collection) + + ts3 := ts.AddDate(1, 0, 0) + err = c.removeBefore(ts3) + assert.NoError(t, err) + assert.Nil(t, c.collection) + + name = randomString[1] + c = CreateOrReturnCollection(name) + + err = c.removeBefore(ts) + assert.NoError(t, err) + assert.Equal(t, []Metric(nil), c.collection) } From fc5b6d0c72c1b6b3f43f47e3d870fce0c9612d47 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Tue, 13 Feb 2024 17:02:14 -0500 Subject: [PATCH 04/79] CI: Use FOSSA push-only token for license scans on PRs (#15222) Signed-off-by: Matt Lord --- .github/workflows/static_checks_etc.yml | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/.github/workflows/static_checks_etc.yml b/.github/workflows/static_checks_etc.yml index 06f86cb9c70..a9b9ca039c9 100644 --- a/.github/workflows/static_checks_etc.yml +++ b/.github/workflows/static_checks_etc.yml @@ -34,17 +34,11 @@ jobs: uses: actions/checkout@v3 - name: Run FOSSA scan and upload build data - # Fails on pull requests when using the API key secret. - # In order to run it on pull requests we would need to - # generate a push only token and specify that as plain - # text here: - # https://github.com/fossa-contrib/fossa-action#push-only-api-token - # BUT, it also requires that the fork have its own - # independent integration setup with fossa.com. - if: github.ref == 'refs/heads/main' uses: fossa-contrib/fossa-action@v3 with: - fossa-api-key: ${{ secrets.FOSSA_API_KEY }} + # This is a push-only API token: https://github.com/fossa-contrib/fossa-action#push-only-api-token + fossa-api-key: f62c11ef0c249fef239947f01279aa0f + github-token: ${{ github.token }} - name: Check for changes in Go files if: steps.skip-workflow.outputs.skip-workflow == 'false' From a0ce8bc6a0b50a51d12b6b9cd4e58bb46f1393ea Mon Sep 17 00:00:00 2001 From: Harshit Gangal Date: Wed, 14 Feb 2024 11:24:35 +0530 Subject: [PATCH 05/79] Add support for Update Multi Table (#15211) Signed-off-by: Harshit Gangal Signed-off-by: Andres Taylor Co-authored-by: Andres Taylor --- changelog/20.0/20.0.0/summary.md | 23 ++- go/vt/sqlparser/ast.go | 18 +- go/vt/sqlparser/ast_funcs.go | 81 +++++++++ go/vt/vterrors/code.go | 2 + .../planbuilder/operators/SQL_builder.go | 154 ++++++++-------- go/vt/vtgate/planbuilder/operators/delete.go | 4 +- .../planbuilder/operators/dml_planning.go | 7 +- go/vt/vtgate/planbuilder/operators/phases.go | 2 +- go/vt/vtgate/planbuilder/operators/update.go | 50 ++++-- .../planbuilder/testdata/dml_cases.json | 168 ++++++++++++++++++ .../testdata/unsupported_cases.json | 20 +-- go/vt/vtgate/semantics/analyzer.go | 4 +- go/vt/vtgate/semantics/analyzer_test.go | 25 --- go/vt/vtgate/semantics/check_invalid.go | 17 -- go/vt/vtgate/semantics/semantic_state.go | 2 +- 15 files changed, 412 insertions(+), 165 deletions(-) diff --git a/changelog/20.0/20.0.0/summary.md b/changelog/20.0/20.0.0/summary.md index c947ea2a0aa..f1280ba7e76 100644 --- a/changelog/20.0/20.0.0/summary.md +++ b/changelog/20.0/20.0.0/summary.md @@ -3,15 +3,17 @@ ### Table of Contents - **[Major Changes](#major-changes)** - - **[Query Serving](#query-serving)** + - **[Query Compatibility](#query-compatibility)** - [Vindex Hints](#vindex-hints) + - [Update with Limit Support](#update-limit) + - [Update with Multi Table Support](#multi-table-update) - **[Minor Changes](#minor-changes)** ## Major Changes -### Query Serving +### Query Compatibility #### Vindex Hints @@ -25,5 +27,22 @@ Example: For more information about Vindex hints and its usage, please consult the documentation. +#### Update with Limit Support + +Support is added for sharded update with limit. + +Example: `update t1 set t1.foo = 'abc', t1.bar = 23 where t1.baz > 5 limit 1` + +More details about how it works is available in [MySQL Docs](https://dev.mysql.com/doc/refman/8.0/en/update.html) + +#### Update with Multi Table Support + +Support is added for sharded multi-table update with column update on single target table using multiple table join. + +Example: `update t1 join t2 on t1.id = t2.id join t3 on t1.col = t3.col set t1.baz = 'abc', t1.apa = 23 where t3.foo = 5 and t2.bar = 7` + +More details about how it works is available in [MySQL Docs](https://dev.mysql.com/doc/refman/8.0/en/update.html) + + ## Minor Changes diff --git a/go/vt/sqlparser/ast.go b/go/vt/sqlparser/ast.go index 3dd376ff228..0e50d71b77c 100644 --- a/go/vt/sqlparser/ast.go +++ b/go/vt/sqlparser/ast.go @@ -53,16 +53,17 @@ type ( Commented } + OrderAndLimit interface { + AddOrder(*Order) + SetLimit(*Limit) + } + // SelectStatement any SELECT statement. SelectStatement interface { Statement InsertRows + OrderAndLimit iSelectStatement() - AddOrder(*Order) - SetOrderBy(OrderBy) - GetOrderBy() OrderBy - GetLimit() *Limit - SetLimit(*Limit) GetLock() Lock SetLock(lock Lock) SetInto(into *SelectInto) @@ -72,6 +73,9 @@ type ( GetColumns() SelectExprs Commented IsDistinct() bool + GetOrderBy() OrderBy + SetOrderBy(OrderBy) + GetLimit() *Limit } // DDLStatement represents any DDL Statement @@ -712,6 +716,10 @@ type ( IndexType int8 ) +var _ OrderAndLimit = (*Select)(nil) +var _ OrderAndLimit = (*Update)(nil) +var _ OrderAndLimit = (*Delete)(nil) + func (*Union) iStatement() {} func (*Select) iStatement() {} func (*Stream) iStatement() {} diff --git a/go/vt/sqlparser/ast_funcs.go b/go/vt/sqlparser/ast_funcs.go index ecbfef2ff66..a8d231d6aa1 100644 --- a/go/vt/sqlparser/ast_funcs.go +++ b/go/vt/sqlparser/ast_funcs.go @@ -2605,3 +2605,84 @@ func MultiTable(node []TableExpr) bool { _, singleTbl := node[0].(*AliasedTableExpr) return !singleTbl } + +func (node *Update) AddOrder(order *Order) { + node.OrderBy = append(node.OrderBy, order) +} + +func (node *Update) SetLimit(limit *Limit) { + node.Limit = limit +} + +func (node *Delete) AddOrder(order *Order) { + node.OrderBy = append(node.OrderBy, order) +} + +func (node *Delete) SetLimit(limit *Limit) { + node.Limit = limit +} + +func (node *Select) GetFrom() []TableExpr { + return node.From +} + +func (node *Select) SetFrom(exprs []TableExpr) { + node.From = exprs +} + +func (node *Select) GetWherePredicate() Expr { + if node.Where == nil { + return nil + } + return node.Where.Expr +} + +func (node *Select) SetWherePredicate(expr Expr) { + node.Where = &Where{ + Type: WhereClause, + Expr: expr, + } +} +func (node *Delete) GetFrom() []TableExpr { + return node.TableExprs +} + +func (node *Delete) SetFrom(exprs []TableExpr) { + node.TableExprs = exprs +} + +func (node *Delete) GetWherePredicate() Expr { + if node.Where == nil { + return nil + } + return node.Where.Expr +} + +func (node *Delete) SetWherePredicate(expr Expr) { + node.Where = &Where{ + Type: WhereClause, + Expr: expr, + } +} + +func (node *Update) GetFrom() []TableExpr { + return node.TableExprs +} + +func (node *Update) SetFrom(exprs []TableExpr) { + node.TableExprs = exprs +} + +func (node *Update) GetWherePredicate() Expr { + if node.Where == nil { + return nil + } + return node.Where.Expr +} + +func (node *Update) SetWherePredicate(expr Expr) { + node.Where = &Where{ + Type: WhereClause, + Expr: expr, + } +} diff --git a/go/vt/vterrors/code.go b/go/vt/vterrors/code.go index eb2b1c4be6d..574ac7c2cdf 100644 --- a/go/vt/vterrors/code.go +++ b/go/vt/vterrors/code.go @@ -57,6 +57,7 @@ var ( VT03029 = errorWithState("VT03029", vtrpcpb.Code_INVALID_ARGUMENT, WrongValueCountOnRow, "column count does not match value count with the row for vindex '%s'", "The number of columns you want to insert do not match the number of columns of your SELECT query.") VT03030 = errorWithState("VT03030", vtrpcpb.Code_INVALID_ARGUMENT, WrongValueCountOnRow, "lookup column count does not match value count with the row (columns, count): (%v, %d)", "The number of columns you want to insert do not match the number of columns of your SELECT query.") VT03031 = errorWithoutState("VT03031", vtrpcpb.Code_INVALID_ARGUMENT, "EXPLAIN is only supported for single keyspace", "EXPLAIN has to be sent down as a single query to the underlying MySQL, and this is not possible if it uses tables from multiple keyspaces") + VT03032 = errorWithState("VT03031", vtrpcpb.Code_INVALID_ARGUMENT, NonUpdateableTable, "the target table %s of the UPDATE is not updatable", "You cannot update a table that is not a real MySQL table.") VT05001 = errorWithState("VT05001", vtrpcpb.Code_NOT_FOUND, DbDropExists, "cannot drop database '%s'; database does not exists", "The given database does not exist; Vitess cannot drop it.") VT05002 = errorWithState("VT05002", vtrpcpb.Code_NOT_FOUND, BadDb, "cannot alter database '%s'; unknown database", "The given database does not exist; Vitess cannot alter it.") @@ -141,6 +142,7 @@ var ( VT03029, VT03030, VT03031, + VT03032, VT05001, VT05002, VT05003, diff --git a/go/vt/vtgate/planbuilder/operators/SQL_builder.go b/go/vt/vtgate/planbuilder/operators/SQL_builder.go index aeb60cc8d01..88f9d985d81 100644 --- a/go/vt/vtgate/planbuilder/operators/SQL_builder.go +++ b/go/vt/vtgate/planbuilder/operators/SQL_builder.go @@ -40,6 +40,9 @@ type ( func (qb *queryBuilder) asSelectStatement() sqlparser.SelectStatement { return qb.stmt.(sqlparser.SelectStatement) } +func (qb *queryBuilder) asOrderAndLimit() sqlparser.OrderAndLimit { + return qb.stmt.(sqlparser.OrderAndLimit) +} func ToSQL(ctx *plancontext.PlanningContext, op Operator) (_ sqlparser.Statement, _ Operator, err error) { defer PanicHandler(&err) @@ -70,17 +73,15 @@ func (qb *queryBuilder) addTableExpr( if qb.stmt == nil { qb.stmt = &sqlparser.Select{} } - sel := qb.stmt.(*sqlparser.Select) - elems := &sqlparser.AliasedTableExpr{ + tbl := &sqlparser.AliasedTableExpr{ Expr: tblExpr, Partitions: nil, As: sqlparser.NewIdentifierCS(alias), Hints: hints, Columns: columnAliases, } - qb.ctx.SemTable.ReplaceTableSetFor(tableID, elems) - sel.From = append(sel.From, elems) - qb.stmt = sel + qb.ctx.SemTable.ReplaceTableSetFor(tableID, tbl) + qb.stmt.(FromStatement).SetFrom(append(qb.stmt.(FromStatement).GetFrom(), tbl)) qb.tableNames = append(qb.tableNames, tableName) } @@ -201,62 +202,81 @@ func (qb *queryBuilder) unionWith(other *queryBuilder, distinct bool) { } } +type FromStatement interface { + GetFrom() []sqlparser.TableExpr + SetFrom([]sqlparser.TableExpr) + GetWherePredicate() sqlparser.Expr + SetWherePredicate(sqlparser.Expr) +} + +var _ FromStatement = (*sqlparser.Select)(nil) +var _ FromStatement = (*sqlparser.Update)(nil) +var _ FromStatement = (*sqlparser.Delete)(nil) + func (qb *queryBuilder) joinInnerWith(other *queryBuilder, onCondition sqlparser.Expr) { - sel := qb.stmt.(*sqlparser.Select) - otherSel := other.stmt.(*sqlparser.Select) - sel.From = append(sel.From, otherSel.From...) - sel.SelectExprs = append(sel.SelectExprs, otherSel.SelectExprs...) + stmt := qb.stmt.(FromStatement) + otherStmt := other.stmt.(FromStatement) + + if sel, isSel := stmt.(*sqlparser.Select); isSel { + otherSel := otherStmt.(*sqlparser.Select) + sel.SelectExprs = append(sel.SelectExprs, otherSel.SelectExprs...) + } + + newFromClause := append(stmt.GetFrom(), otherStmt.GetFrom()...) + stmt.SetFrom(newFromClause) + qb.mergeWhereClauses(stmt, otherStmt) + qb.addPredicate(onCondition) +} + +func (qb *queryBuilder) joinOuterWith(other *queryBuilder, onCondition sqlparser.Expr) { + stmt := qb.stmt.(FromStatement) + otherStmt := other.stmt.(FromStatement) - var predicate sqlparser.Expr - if sel.Where != nil { - predicate = sel.Where.Expr + if sel, isSel := stmt.(*sqlparser.Select); isSel { + otherSel := otherStmt.(*sqlparser.Select) + sel.SelectExprs = append(sel.SelectExprs, otherSel.SelectExprs...) } - if otherSel.Where != nil { + + newFromClause := []sqlparser.TableExpr{buildOuterJoin(stmt, otherStmt, onCondition)} + stmt.SetFrom(newFromClause) + qb.mergeWhereClauses(stmt, otherStmt) +} + +func (qb *queryBuilder) mergeWhereClauses(stmt, otherStmt FromStatement) { + predicate := stmt.GetWherePredicate() + if otherPredicate := otherStmt.GetWherePredicate(); otherPredicate != nil { predExprs := sqlparser.SplitAndExpression(nil, predicate) - otherExprs := sqlparser.SplitAndExpression(nil, otherSel.Where.Expr) + otherExprs := sqlparser.SplitAndExpression(nil, otherPredicate) predicate = qb.ctx.SemTable.AndExpressions(append(predExprs, otherExprs...)...) } if predicate != nil { - sel.Where = &sqlparser.Where{Type: sqlparser.WhereClause, Expr: predicate} + stmt.SetWherePredicate(predicate) } - - qb.addPredicate(onCondition) } -func (qb *queryBuilder) joinOuterWith(other *queryBuilder, onCondition sqlparser.Expr) { - sel := qb.stmt.(*sqlparser.Select) - otherSel := other.stmt.(*sqlparser.Select) +func buildOuterJoin(stmt FromStatement, otherStmt FromStatement, onCondition sqlparser.Expr) *sqlparser.JoinTableExpr { var lhs sqlparser.TableExpr - if len(sel.From) == 1 { - lhs = sel.From[0] + fromClause := stmt.GetFrom() + if len(fromClause) == 1 { + lhs = fromClause[0] } else { - lhs = &sqlparser.ParenTableExpr{Exprs: sel.From} + lhs = &sqlparser.ParenTableExpr{Exprs: fromClause} } var rhs sqlparser.TableExpr - if len(otherSel.From) == 1 { - rhs = otherSel.From[0] + otherFromClause := otherStmt.GetFrom() + if len(otherFromClause) == 1 { + rhs = otherFromClause[0] } else { - rhs = &sqlparser.ParenTableExpr{Exprs: otherSel.From} + rhs = &sqlparser.ParenTableExpr{Exprs: otherFromClause} } - sel.From = []sqlparser.TableExpr{&sqlparser.JoinTableExpr{ + + return &sqlparser.JoinTableExpr{ LeftExpr: lhs, RightExpr: rhs, Join: sqlparser.LeftJoinType, Condition: &sqlparser.JoinCondition{ On: onCondition, }, - }} - - sel.SelectExprs = append(sel.SelectExprs, otherSel.SelectExprs...) - var predicate sqlparser.Expr - if sel.Where != nil { - predicate = sel.Where.Expr - } - if otherSel.Where != nil { - predicate = qb.ctx.SemTable.AndExpressions(predicate, otherSel.Where.Expr) - } - if predicate != nil { - sel.Where = &sqlparser.Where{Type: sqlparser.WhereClause, Expr: predicate} } } @@ -386,28 +406,27 @@ func buildQuery(op Operator, qb *queryBuilder) { } func buildDelete(op *Delete, qb *queryBuilder) { - buildQuery(op.Source, qb) - // currently the qb builds a select query underneath. - // Will take the `From` and `Where` from this select - // and create a delete statement. - // TODO: change it to directly produce `delete` statement. - sel, ok := qb.stmt.(*sqlparser.Select) - if !ok { - panic(vterrors.VT13001("expected a select here")) + qb.stmt = &sqlparser.Delete{ + Ignore: op.Ignore, + Targets: sqlparser.TableNames{op.Target.Name}, } + buildQuery(op.Source, qb) qb.dmlOperator = op - qb.stmt = &sqlparser.Delete{ - Ignore: op.Ignore, - Targets: sqlparser.TableNames{op.Target.Name}, - TableExprs: sel.From, - Where: sel.Where, - Limit: sel.Limit, - OrderBy: sel.OrderBy, - } } func buildUpdate(op *Update, qb *queryBuilder) { + updExprs := getUpdateExprs(op) + upd := &sqlparser.Update{ + Ignore: op.Ignore, + Exprs: updExprs, + } + qb.stmt = upd + qb.dmlOperator = op + buildQuery(op.Source, qb) +} + +func getUpdateExprs(op *Update) sqlparser.UpdateExprs { updExprs := make(sqlparser.UpdateExprs, 0, len(op.Assignments)) for _, se := range op.Assignments { updExprs = append(updExprs, &sqlparser.UpdateExpr{ @@ -415,26 +434,7 @@ func buildUpdate(op *Update, qb *queryBuilder) { Expr: se.Expr.EvalExpr, }) } - - buildQuery(op.Source, qb) - // currently the qb builds a select query underneath. - // Will take the `From` and `Where` from this select - // and create a update statement. - // TODO: change it to directly produce `update` statement. - sel, ok := qb.stmt.(*sqlparser.Select) - if !ok { - panic(vterrors.VT13001("expected a select here")) - } - - qb.dmlOperator = op - qb.stmt = &sqlparser.Update{ - Ignore: op.Ignore, - TableExprs: sel.From, - Exprs: updExprs, - Where: sel.Where, - Limit: sel.Limit, - OrderBy: sel.OrderBy, - } + return updExprs } type OpWithAST interface { @@ -470,13 +470,13 @@ func buildOrdering(op *Ordering, qb *queryBuilder) { buildQuery(op.Source, qb) for _, order := range op.Order { - qb.asSelectStatement().AddOrder(order.Inner) + qb.asOrderAndLimit().AddOrder(order.Inner) } } func buildLimit(op *Limit, qb *queryBuilder) { buildQuery(op.Source, qb) - qb.asSelectStatement().SetLimit(op.AST) + qb.asOrderAndLimit().SetLimit(op.AST) } func buildTable(op *Table, qb *queryBuilder) { diff --git a/go/vt/vtgate/planbuilder/operators/delete.go b/go/vt/vtgate/planbuilder/operators/delete.go index 22b8f1e4281..4bc2f48f4d8 100644 --- a/go/vt/vtgate/planbuilder/operators/delete.go +++ b/go/vt/vtgate/planbuilder/operators/delete.go @@ -220,12 +220,12 @@ func generateOwnedVindexQuery(tblExpr sqlparser.TableExpr, del *sqlparser.Delete var selExprs sqlparser.SelectExprs for _, col := range ksidCols { colName := makeColName(col, table, sqlparser.MultiTable(del.TableExprs)) - selExprs = append(selExprs, sqlparser.NewAliasedExpr(colName, "")) + selExprs = append(selExprs, aeWrap(colName)) } for _, cv := range table.VTable.Owned { for _, col := range cv.Columns { colName := makeColName(col, table, sqlparser.MultiTable(del.TableExprs)) - selExprs = append(selExprs, sqlparser.NewAliasedExpr(colName, "")) + selExprs = append(selExprs, aeWrap(colName)) } } sqlparser.RemoveKeyspaceInTables(tblExpr) diff --git a/go/vt/vtgate/planbuilder/operators/dml_planning.go b/go/vt/vtgate/planbuilder/operators/dml_planning.go index 6dbe7a74ff3..ed777428381 100644 --- a/go/vt/vtgate/planbuilder/operators/dml_planning.go +++ b/go/vt/vtgate/planbuilder/operators/dml_planning.go @@ -109,6 +109,7 @@ func buildChangedVindexesValues( ctx *plancontext.PlanningContext, update *sqlparser.Update, table *vindexes.Table, + ate *sqlparser.AliasedTableExpr, ksidCols []sqlparser.IdentifierCI, assignments []SetExpr, ) (vv map[string]*engine.VindexValues, ownedVindexQuery *sqlparser.Select, subQueriesArgOnChangedVindex []string) { @@ -144,11 +145,7 @@ func buildChangedVindexesValues( return nil, nil, nil } // generate rest of the owned vindex query. - aTblExpr, ok := update.TableExprs[0].(*sqlparser.AliasedTableExpr) - if !ok { - panic(vterrors.VT12001("UPDATE on complex table expression")) - } - tblExpr := &sqlparser.AliasedTableExpr{Expr: sqlparser.TableName{Name: table.Name}, As: aTblExpr.As} + tblExpr := sqlparser.NewAliasedTableExpr(sqlparser.TableName{Name: table.Name}, ate.As.String()) ovq := &sqlparser.Select{ From: []sqlparser.TableExpr{tblExpr}, SelectExprs: selExprs, diff --git a/go/vt/vtgate/planbuilder/operators/phases.go b/go/vt/vtgate/planbuilder/operators/phases.go index b45fbd5c9ad..3937105c494 100644 --- a/go/vt/vtgate/planbuilder/operators/phases.go +++ b/go/vt/vtgate/planbuilder/operators/phases.go @@ -79,7 +79,7 @@ func (p Phase) shouldRun(s semantics.QuerySignature) bool { case subquerySettling: return s.SubQueries case dmlWithInput: - return s.Dml + return s.DML default: return true } diff --git a/go/vt/vtgate/planbuilder/operators/update.go b/go/vt/vtgate/planbuilder/operators/update.go index a4aafa222fa..5fc7dc0d4a7 100644 --- a/go/vt/vtgate/planbuilder/operators/update.go +++ b/go/vt/vtgate/planbuilder/operators/update.go @@ -103,6 +103,8 @@ func (u *Update) ShortDescription() string { } func createOperatorFromUpdate(ctx *plancontext.PlanningContext, updStmt *sqlparser.Update) (op Operator) { + errIfUpdateNotSupported(ctx, updStmt) + var updClone *sqlparser.Update var vTbl *vindexes.Table @@ -134,6 +136,31 @@ func createOperatorFromUpdate(ctx *plancontext.PlanningContext, updStmt *sqlpars return buildFkOperator(ctx, op, updClone, parentFks, childFks, vTbl) } +func errIfUpdateNotSupported(ctx *plancontext.PlanningContext, stmt *sqlparser.Update) { + var vTbl *vindexes.Table + for _, ue := range stmt.Exprs { + tblInfo, err := ctx.SemTable.TableInfoForExpr(ue.Name) + if err != nil { + panic(err) + } + if _, isATable := tblInfo.(*semantics.RealTable); !isATable { + var tblName string + ate := tblInfo.GetAliasedTableExpr() + if ate != nil { + tblName = sqlparser.String(ate) + } + panic(vterrors.VT03032(tblName)) + } + + if vTbl == nil { + vTbl = tblInfo.GetVindexTable() + } + if vTbl != tblInfo.GetVindexTable() { + panic(vterrors.VT12001("multi-table UPDATE statement with multi-target column update")) + } + } +} + func createUpdateOperator(ctx *plancontext.PlanningContext, updStmt *sqlparser.Update) (Operator, *vindexes.Table, *sqlparser.Update) { op := crossJoin(ctx, updStmt.TableExprs) @@ -148,6 +175,8 @@ func createUpdateOperator(ctx *plancontext.PlanningContext, updStmt *sqlparser.U // If we encounter subqueries, we want to fix the updClone to use the replaced expression, so that the pulled out subquery's // result is used everywhere instead of running the subquery multiple times, which is wasteful. updClone := sqlparser.CloneRefOfUpdate(updStmt) + var tblInfo semantics.TableInfo + var err error for idx, updExpr := range updStmt.Exprs { expr, subqs := sqc.pullOutValueSubqueries(ctx, updExpr.Expr, outerID, true) if len(subqs) == 0 { @@ -164,19 +193,13 @@ func createUpdateOperator(ctx *plancontext.PlanningContext, updStmt *sqlparser.U Name: updExpr.Name, Expr: proj, } + tblInfo, err = ctx.SemTable.TableInfoForExpr(updExpr.Name) + if err != nil { + panic(err) + } } - target := updStmt.TableExprs[0] - atbl, ok := target.(*sqlparser.AliasedTableExpr) - if !ok { - panic(vterrors.VT12001("multi table update")) - } - tblID := ctx.SemTable.TableSetFor(atbl) - tblInfo, err := ctx.SemTable.TableInfoFor(tblID) - if err != nil { - panic(err) - } - + tblID := ctx.SemTable.TableSetFor(tblInfo.GetAliasedTableExpr()) vTbl := tblInfo.GetVindexTable() // Reference table should update the source table. if vTbl.Type == vindexes.TypeReference && vTbl.Source != nil { @@ -194,7 +217,7 @@ func createUpdateOperator(ctx *plancontext.PlanningContext, updStmt *sqlparser.U Name: name, } - _, cvv, ovq, subQueriesArgOnChangedVindex := getUpdateVindexInformation(ctx, updStmt, targetTbl, assignments) + _, cvv, ovq, subQueriesArgOnChangedVindex := getUpdateVindexInformation(ctx, updStmt, targetTbl, tblInfo.GetAliasedTableExpr(), assignments) updOp := &Update{ DMLCommon: &DMLCommon{ @@ -226,6 +249,7 @@ func getUpdateVindexInformation( ctx *plancontext.PlanningContext, updStmt *sqlparser.Update, table TargetTable, + ate *sqlparser.AliasedTableExpr, assignments []SetExpr, ) ([]*VindexPlusPredicates, map[string]*engine.VindexValues, *sqlparser.Select, []string) { if !table.VTable.Keyspace.Sharded { @@ -233,7 +257,7 @@ func getUpdateVindexInformation( } primaryVindex, vindexAndPredicates := getVindexInformation(table.ID, table.VTable) - changedVindexValues, ownedVindexQuery, subQueriesArgOnChangedVindex := buildChangedVindexesValues(ctx, updStmt, table.VTable, primaryVindex.Columns, assignments) + changedVindexValues, ownedVindexQuery, subQueriesArgOnChangedVindex := buildChangedVindexesValues(ctx, updStmt, table.VTable, ate, primaryVindex.Columns, assignments) return vindexAndPredicates, changedVindexValues, ownedVindexQuery, subQueriesArgOnChangedVindex } diff --git a/go/vt/vtgate/planbuilder/testdata/dml_cases.json b/go/vt/vtgate/planbuilder/testdata/dml_cases.json index 5e4987be8c3..995795fc209 100644 --- a/go/vt/vtgate/planbuilder/testdata/dml_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/dml_cases.json @@ -5660,5 +5660,173 @@ "user.user" ] } + }, + { + "comment": "update with multi table join with single target", + "query": "update user as u, user_extra as ue set u.name = 'foo' where u.id = ue.id", + "plan": { + "QueryType": "UPDATE", + "Original": "update user as u, user_extra as ue set u.name = 'foo' where u.id = ue.id", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + 0 + ], + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "R:0", + "JoinVars": { + "ue_id": 0 + }, + "TableName": "user_extra_`user`", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select ue.id from user_extra as ue where 1 != 1", + "Query": "select ue.id from user_extra as ue lock in share mode", + "Table": "user_extra" + }, + { + "OperatorType": "Route", + "Variant": "EqualUnique", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select u.id from `user` as u where 1 != 1", + "Query": "select u.id from `user` as u where u.id = :ue_id lock in share mode", + "Table": "`user`", + "Values": [ + ":ue_id" + ], + "Vindex": "user_index" + } + ] + }, + { + "OperatorType": "Update", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "ChangedVindexValues": [ + "name_user_map:3" + ], + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly, u.`name` = 'foo' from `user` as u where u.id in ::dml_vals for update", + "Query": "update `user` as u set u.`name` = 'foo' where u.id in ::dml_vals", + "Table": "user", + "Values": [ + "::dml_vals" + ], + "Vindex": "user_index" + } + ] + }, + "TablesUsed": [ + "user.user", + "user.user_extra" + ] + } + }, + { + "comment": "update with multi table join with single target modifying lookup vindex", + "query": "update user join user_extra on user.id = user_extra.id set user.name = 'foo'", + "plan": { + "QueryType": "UPDATE", + "Original": "update user join user_extra on user.id = user_extra.id set user.name = 'foo'", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + 0 + ], + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "R:0", + "JoinVars": { + "user_extra_id": 0 + }, + "TableName": "user_extra_`user`", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select user_extra.id from user_extra where 1 != 1", + "Query": "select user_extra.id from user_extra lock in share mode", + "Table": "user_extra" + }, + { + "OperatorType": "Route", + "Variant": "EqualUnique", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select `user`.id from `user` where 1 != 1", + "Query": "select `user`.id from `user` where `user`.id = :user_extra_id lock in share mode", + "Table": "`user`", + "Values": [ + ":user_extra_id" + ], + "Vindex": "user_index" + } + ] + }, + { + "OperatorType": "Update", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "ChangedVindexValues": [ + "name_user_map:3" + ], + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly, `user`.`name` = 'foo' from `user` where `user`.id in ::dml_vals for update", + "Query": "update `user` set `user`.`name` = 'foo' where `user`.id in ::dml_vals", + "Table": "user", + "Values": [ + "::dml_vals" + ], + "Vindex": "user_index" + } + ] + }, + "TablesUsed": [ + "user.user", + "user.user_extra" + ] + } + }, + { + "comment": "update with multi table reference with multi target update on a derived table", + "query": "update ignore (select foo, col, bar from user) u, music m set u.foo = 21, u.bar = 'abc' where u.col = m.col", + "plan": "VT03031: the target table (select foo, col, bar from `user`) as u of the UPDATE is not updatable" + }, + { + "comment": "update with derived table", + "query": "update (select id from user) as u set id = 4", + "plan": "VT03031: the target table (select id from `user`) as u of the UPDATE is not updatable" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json index 59071c7e810..4214a396499 100644 --- a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json @@ -64,21 +64,6 @@ "query": "update user_metadata set email = 'juan@vitess.io' where user_id = 1 limit 10", "plan": "VT12001: unsupported: Vindex update should have ORDER BY clause when using LIMIT" }, - { - "comment": "update with derived table", - "query": "update (select id from user) as u set id = 4", - "plan": "The target table u of the UPDATE is not updatable" - }, - { - "comment": "join in update tables", - "query": "update user join user_extra on user.id = user_extra.id set user.name = 'foo'", - "plan": "VT12001: unsupported: unaliased multiple tables in update" - }, - { - "comment": "multiple tables in update", - "query": "update user as u, user_extra as ue set u.name = 'foo' where u.id = ue.id", - "plan": "VT12001: unsupported: multiple (2) tables in update" - }, { "comment": "unsharded insert, col list does not match values", "query": "insert into unsharded_auto(id, val) values(1)", @@ -408,5 +393,10 @@ "comment": "count and sum distinct on different columns", "query": "SELECT COUNT(DISTINCT col), SUM(DISTINCT id) FROM user", "plan": "VT12001: unsupported: only one DISTINCT aggregation is allowed in a SELECT: sum(distinct id)" + }, + { + "comment": "update with multi table reference with multi target update", + "query": "update ignore user u, music m set u.foo = 21, m.bar = 'abc' where u.col = m.col", + "plan": "VT12001: unsupported: multi-table UPDATE statement with multi-target column update" } ] diff --git a/go/vt/vtgate/semantics/analyzer.go b/go/vt/vtgate/semantics/analyzer.go index 95d645d7d9d..f52bd983104 100644 --- a/go/vt/vtgate/semantics/analyzer.go +++ b/go/vt/vtgate/semantics/analyzer.go @@ -328,8 +328,8 @@ func (a *analyzer) noteQuerySignature(node sqlparser.SQLNode) { } case sqlparser.AggrFunc: a.sig.Aggregation = true - case *sqlparser.Delete, *sqlparser.Update: - a.sig.Dml = true + case *sqlparser.Delete, *sqlparser.Update, *sqlparser.Insert: + a.sig.DML = true } } diff --git a/go/vt/vtgate/semantics/analyzer_test.go b/go/vt/vtgate/semantics/analyzer_test.go index 10f85326751..dd8db6f5cd1 100644 --- a/go/vt/vtgate/semantics/analyzer_test.go +++ b/go/vt/vtgate/semantics/analyzer_test.go @@ -1589,31 +1589,6 @@ func TestNextErrors(t *testing.T) { } } -func TestUpdateErrors(t *testing.T) { - tests := []struct { - query, expectedError string - }{ - { - query: "update t1, t2 set id = 12", - expectedError: "VT12001: unsupported: multiple (2) tables in update", - }, { - query: "update (select 1 from dual) dt set id = 1", - expectedError: "The target table dt of the UPDATE is not updatable", - }, - } - - for _, test := range tests { - t.Run(test.query, func(t *testing.T) { - parse, err := sqlparser.NewTestParser().Parse(test.query) - require.NoError(t, err) - - _, err = AnalyzeStrict(parse, "d", fakeSchemaInfo()) - - assert.EqualError(t, err, test.expectedError) - }) - } -} - // TestScopingSubQueryJoinClause tests the scoping behavior of a subquery containing a join clause. // The test ensures that the scoping analysis correctly identifies and handles the relationships // between the tables involved in the join operation with the outer query. diff --git a/go/vt/vtgate/semantics/check_invalid.go b/go/vt/vtgate/semantics/check_invalid.go index 38dacefa1f0..45c160e93a2 100644 --- a/go/vt/vtgate/semantics/check_invalid.go +++ b/go/vt/vtgate/semantics/check_invalid.go @@ -24,8 +24,6 @@ import ( func (a *analyzer) checkForInvalidConstructs(cursor *sqlparser.Cursor) error { switch node := cursor.Node().(type) { - case *sqlparser.Update: - return checkUpdate(node) case *sqlparser.Select: return a.checkSelect(cursor, node) case *sqlparser.Nextval: @@ -179,21 +177,6 @@ func (a *analyzer) checkSelect(cursor *sqlparser.Cursor, node *sqlparser.Select) return nil } -func checkUpdate(node *sqlparser.Update) error { - if len(node.TableExprs) != 1 { - return ShardedError{Inner: &UnsupportedMultiTablesInUpdateError{ExprCount: len(node.TableExprs)}} - } - alias, isAlias := node.TableExprs[0].(*sqlparser.AliasedTableExpr) - if !isAlias { - return ShardedError{Inner: &UnsupportedMultiTablesInUpdateError{NotAlias: true}} - } - _, isDerived := alias.Expr.(*sqlparser.DerivedTable) - if isDerived { - return &TableNotUpdatableError{Table: alias.As.String()} - } - return nil -} - // checkAliasedTableExpr checks the validity of AliasedTableExpr. func checkAliasedTableExpr(node *sqlparser.AliasedTableExpr) error { if len(node.Hints) == 0 { diff --git a/go/vt/vtgate/semantics/semantic_state.go b/go/vt/vtgate/semantics/semantic_state.go index 949a1b72017..74bd9dd1d69 100644 --- a/go/vt/vtgate/semantics/semantic_state.go +++ b/go/vt/vtgate/semantics/semantic_state.go @@ -78,7 +78,7 @@ type ( // QuerySignature is used to identify shortcuts in the planning process QuerySignature struct { Aggregation bool - Dml bool + DML bool Distinct bool HashJoin bool SubQueries bool From 8960bc38e6e0e180c7f56f3ba9232258d8a6f24a Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Wed, 14 Feb 2024 11:44:59 +0200 Subject: [PATCH 06/79] `ExecuteFetch`: error on multiple result sets (#14949) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Signed-off-by: Dirkjan Bussink Signed-off-by: Manan Gupta Signed-off-by: Harshit Gangal Signed-off-by: Vicent Marti Co-authored-by: Dirkjan Bussink Co-authored-by: Manan Gupta Co-authored-by: Harshit Gangal Co-authored-by: Vicent Marti --- go/mysql/endtoend/client_test.go | 13 +++++- go/mysql/query.go | 44 ++++++++++++++++++- go/test/endtoend/cluster/vttablet_process.go | 30 +++++++++++++ .../endtoend/mysqlserver/mysql_server_test.go | 10 ++--- .../reparent/newfeaturetest/reparent_test.go | 4 +- .../reparent/plannedreparent/reparent_test.go | 6 +-- go/test/endtoend/reparent/utils/utils.go | 12 +++-- .../buffer/buffer_test_helpers.go | 10 ++--- .../buffer/reparent/failover_buffer_test.go | 25 +++++++---- .../tabletmanager/tablegc/tablegc_test.go | 9 ++-- go/test/endtoend/tabletmanager/tablet_test.go | 2 +- go/test/endtoend/utils/mysql.go | 12 ++++- go/test/endtoend/utils/utils.go | 9 ++++ .../endtoend/vreplication/time_zone_test.go | 2 +- go/test/endtoend/vreplication/vstream_test.go | 2 +- .../vtgate/errors_as_warnings/main_test.go | 2 +- .../endtoend/vtgate/queries/kill/main_test.go | 3 +- .../endtoend/vtgate/unsharded/main_test.go | 30 ++++++------- .../primaryfailure/primary_failure_test.go | 26 +++++------ go/test/endtoend/vtorc/utils/utils.go | 31 ++++++------- go/vt/mysqlctl/mysqld.go | 2 +- go/vt/vttablet/endtoend/call_test.go | 5 ++- go/vt/vttablet/tabletmanager/tm_init_test.go | 8 ++-- .../vreplication/vplayer_flaky_test.go | 2 +- go/vt/vttablet/tabletserver/query_executor.go | 5 +++ .../vstreamer/uvstreamer_flaky_test.go | 22 +++++----- 26 files changed, 225 insertions(+), 101 deletions(-) diff --git a/go/mysql/endtoend/client_test.go b/go/mysql/endtoend/client_test.go index 6591c454e8a..ce01c57369d 100644 --- a/go/mysql/endtoend/client_test.go +++ b/go/mysql/endtoend/client_test.go @@ -210,7 +210,11 @@ func doTestMultiResult(t *testing.T, disableClientDeprecateEOF bool) { assert.EqualValues(t, 1, result.RowsAffected, "insert into returned RowsAffected") } - qr, more, err = conn.ExecuteFetchMulti("update a set name = concat(name, ' updated'); select * from a; select count(*) from a", 300, true) + // Verify that a ExecuteFetchMultiDrain leaves the connection/packet in valid state. + err = conn.ExecuteFetchMultiDrain("update a set name = concat(name, ', multi drain 1'); select * from a; select count(*) from a") + expectNoError(t, err) + // If the previous command leaves packet in invalid state, this will fail. + qr, more, err = conn.ExecuteFetchMulti("update a set name = concat(name, ', fetch multi'); select * from a; select count(*) from a", 300, true) expectNoError(t, err) expectFlag(t, "ExecuteMultiFetch(multi result)", more, true) assert.EqualValues(t, 255, qr.RowsAffected) @@ -225,6 +229,13 @@ func doTestMultiResult(t *testing.T, disableClientDeprecateEOF bool) { expectFlag(t, "ReadQueryResult(2)", more, false) assert.EqualValues(t, 1, len(qr.Rows), "ReadQueryResult(1)") + // Verify that a ExecuteFetchMultiDrain is happy to operate again after all the above. + err = conn.ExecuteFetchMultiDrain("update a set name = concat(name, ', multi drain 2'); select * from a; select count(*) from a") + expectNoError(t, err) + + err = conn.ExecuteFetchMultiDrain("update b set name = concat(name, ' nonexistent table'); select * from a; select count(*) from a") + require.Error(t, err) + _, err = conn.ExecuteFetch("drop table a", 10, true) require.NoError(t, err) } diff --git a/go/mysql/query.go b/go/mysql/query.go index 7aab6ee13f0..22299e5cc80 100644 --- a/go/mysql/query.go +++ b/go/mysql/query.go @@ -17,6 +17,7 @@ limitations under the License. package mysql import ( + "errors" "fmt" "math" "strconv" @@ -34,6 +35,17 @@ import ( // This file contains the methods related to queries. +var ( + ErrExecuteFetchMultipleResults = vterrors.Errorf(vtrpc.Code_INTERNAL, "unexpected multiple results. Use ExecuteFetchMulti instead.") +) + +const ( + // Use as `maxrows` in `ExecuteFetch` and related functions, to indicate no rows should be fetched. + // This is different than specifying `0`, because `0` means "expect zero results", while this means + // "do not attempt to read any results into memory". + FETCH_NO_ROWS = math.MinInt +) + // // Client side methods. // @@ -303,10 +315,35 @@ func (c *Conn) parseRow(data []byte, fields []*querypb.Field, reader func([]byte // 2. if the server closes the connection when a command is in flight, // readComQueryResponse will fail, and we'll return CRServerLost(2013). func (c *Conn) ExecuteFetch(query string, maxrows int, wantfields bool) (result *sqltypes.Result, err error) { - result, _, err = c.ExecuteFetchMulti(query, maxrows, wantfields) + result, more, err := c.ExecuteFetchMulti(query, maxrows, wantfields) + if more { + // Multiple results are unexpected. Prioritize this "unexpected" error over whatever error we got from the first result. + err = errors.Join(ErrExecuteFetchMultipleResults, err) + } + // draining to make the connection clean. + err = c.drainMoreResults(more, err) return result, err } +// ExecuteFetchMultiDrain is for executing multiple statements in one call, but without +// caring for any results. The function returns an error if any of the statements fail. +// The function drains the query results of all statements, even if there's an error. +func (c *Conn) ExecuteFetchMultiDrain(query string) (err error) { + _, more, err := c.ExecuteFetchMulti(query, FETCH_NO_ROWS, false) + return c.drainMoreResults(more, err) +} + +// drainMoreResults ensures to drain all query results, even if there's an error. +// We collect all errors until we consume all results. +func (c *Conn) drainMoreResults(more bool, err error) error { + for more { + var moreErr error + _, more, _, moreErr = c.ReadQueryResult(FETCH_NO_ROWS, false) + err = errors.Join(err, moreErr) + } + return err +} + // ExecuteFetchMulti is for fetching multiple results from a multi-statement result. // It returns an additional 'more' flag. If it is set, you must fetch the additional // results using ReadQueryResult. @@ -460,6 +497,11 @@ func (c *Conn) ReadQueryResult(maxrows int, wantfields bool) (*sqltypes.Result, return nil, false, 0, ParseErrorPacket(data) } + if maxrows == FETCH_NO_ROWS { + c.recycleReadPacket() + continue + } + // Check we're not over the limit before we add more. if len(result.Rows) == maxrows { c.recycleReadPacket() diff --git a/go/test/endtoend/cluster/vttablet_process.go b/go/test/endtoend/cluster/vttablet_process.go index f92382d5f2d..c98ed37afc0 100644 --- a/go/test/endtoend/cluster/vttablet_process.go +++ b/go/test/endtoend/cluster/vttablet_process.go @@ -512,6 +512,16 @@ func (vttablet *VttabletProcess) QueryTabletWithDB(query string, dbname string) return executeQuery(conn, query) } +// MultiQueryTabletWithDB lets you execute multiple queries on a specific DB in this tablet. +func (vttablet *VttabletProcess) MultiQueryTabletWithDB(query string, dbname string) error { + conn, err := vttablet.defaultConn(dbname) + if err != nil { + return err + } + defer conn.Close() + return executeMultiQuery(conn, query) +} + // executeQuery will retry the query up to 10 times with a small sleep in between each try. // This allows the tests to be more robust in the face of transient failures. func executeQuery(dbConn *mysql.Conn, query string) (*sqltypes.Result, error) { @@ -536,6 +546,26 @@ func executeQuery(dbConn *mysql.Conn, query string) (*sqltypes.Result, error) { return result, err } +// executeMultiQuery will retry the given multi query up to 10 times with a small sleep in between each try. +// This allows the tests to be more robust in the face of transient failures. +func executeMultiQuery(dbConn *mysql.Conn, query string) (err error) { + retries := 10 + retryDelay := 1 * time.Second + for i := 0; i < retries; i++ { + if i > 0 { + // We only audit from 2nd attempt and onwards, otherwise this is just too verbose. + log.Infof("Executing query %s (attempt %d of %d)", query, (i + 1), retries) + } + err = dbConn.ExecuteFetchMultiDrain(query) + if err == nil { + break + } + time.Sleep(retryDelay) + } + + return err +} + // GetDBVar returns first matching database variable's value func (vttablet *VttabletProcess) GetDBVar(varName string, ksName string) (string, error) { return vttablet.getDBSystemValues("variables", varName, ksName) diff --git a/go/test/endtoend/mysqlserver/mysql_server_test.go b/go/test/endtoend/mysqlserver/mysql_server_test.go index caed342688d..6b691582c66 100644 --- a/go/test/endtoend/mysqlserver/mysql_server_test.go +++ b/go/test/endtoend/mysqlserver/mysql_server_test.go @@ -116,7 +116,7 @@ func TestTimeout(t *testing.T) { require.Nilf(t, err, "unable to connect mysql: %v", err) defer conn.Close() - _, err = conn.ExecuteFetch("SELECT SLEEP(5);", 1, false) + _, err = conn.ExecuteFetch("SELECT SLEEP(5)", 1, false) require.NotNilf(t, err, "quiry timeout error expected") mysqlErr, ok := err.(*sqlerror.SQLError) require.Truef(t, ok, "invalid error type") @@ -132,7 +132,7 @@ func TestInvalidField(t *testing.T) { require.Nilf(t, err, "unable to connect mysql: %v", err) defer conn.Close() - _, err = conn.ExecuteFetch("SELECT invalid_field from vt_insert_test;", 1, false) + _, err = conn.ExecuteFetch("SELECT invalid_field from vt_insert_test", 1, false) require.NotNil(t, err, "invalid field error expected") mysqlErr, ok := err.(*sqlerror.SQLError) require.Truef(t, ok, "invalid error type") @@ -153,7 +153,7 @@ func TestWarnings(t *testing.T) { require.NoError(t, err) assert.Empty(t, qr.Rows, "number of rows") - qr, err = conn.ExecuteFetch("SHOW WARNINGS;", 1, false) + qr, err = conn.ExecuteFetch("SHOW WARNINGS", 1, false) require.NoError(t, err, "SHOW WARNINGS") assert.EqualValues(t, 1, len(qr.Rows), "number of rows") assert.Contains(t, qr.Rows[0][0].String(), "VARCHAR(\"Warning\")", qr.Rows) @@ -164,7 +164,7 @@ func TestWarnings(t *testing.T) { _, err = conn.ExecuteFetch("SELECT 1 from vt_insert_test limit 1", 1, false) require.NoError(t, err) - qr, err = conn.ExecuteFetch("SHOW WARNINGS;", 1, false) + qr, err = conn.ExecuteFetch("SHOW WARNINGS", 1, false) require.NoError(t, err) assert.Empty(t, qr.Rows) @@ -175,7 +175,7 @@ func TestWarnings(t *testing.T) { _, err = conn.ExecuteFetch("SELECT 1 from vt_insert_test limit 1", 1, false) require.NoError(t, err) - qr, err = conn.ExecuteFetch("SHOW WARNINGS;", 1, false) + qr, err = conn.ExecuteFetch("SHOW WARNINGS", 1, false) require.NoError(t, err) assert.Empty(t, qr.Rows) } diff --git a/go/test/endtoend/reparent/newfeaturetest/reparent_test.go b/go/test/endtoend/reparent/newfeaturetest/reparent_test.go index d5f37dc8604..b570509f1a7 100644 --- a/go/test/endtoend/reparent/newfeaturetest/reparent_test.go +++ b/go/test/endtoend/reparent/newfeaturetest/reparent_test.go @@ -131,8 +131,8 @@ func TestChangeTypeWithoutSemiSync(t *testing.T) { utils.RunSQL(ctx, t, "set global super_read_only = 0", tablet) } - utils.RunSQL(ctx, t, "UNINSTALL PLUGIN rpl_semi_sync_slave;", tablet) - utils.RunSQL(ctx, t, "UNINSTALL PLUGIN rpl_semi_sync_master;", tablet) + utils.RunSQL(ctx, t, "UNINSTALL PLUGIN rpl_semi_sync_slave", tablet) + utils.RunSQL(ctx, t, "UNINSTALL PLUGIN rpl_semi_sync_master", tablet) } utils.ValidateTopology(t, clusterInstance, true) diff --git a/go/test/endtoend/reparent/plannedreparent/reparent_test.go b/go/test/endtoend/reparent/plannedreparent/reparent_test.go index 014570d8439..6aa5972b928 100644 --- a/go/test/endtoend/reparent/plannedreparent/reparent_test.go +++ b/go/test/endtoend/reparent/plannedreparent/reparent_test.go @@ -104,7 +104,7 @@ func TestPRSWithDrainedLaggingTablet(t *testing.T) { utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{tablets[2], tablets[3]}) // assert that there is indeed only 1 row in tablets[1 - res := utils.RunSQL(context.Background(), t, `select msg from vt_insert_test;`, tablets[1]) + res := utils.RunSQL(context.Background(), t, `select msg from vt_insert_test`, tablets[1]) assert.Equal(t, 1, len(res.Rows)) // Perform a graceful reparent operation @@ -217,8 +217,8 @@ func reparentFromOutside(t *testing.T, clusterInstance *cluster.LocalProcessClus if !downPrimary { // commands to stop the current primary - demoteCommands := "SET GLOBAL read_only = ON; FLUSH TABLES WITH READ LOCK; UNLOCK TABLES" - utils.RunSQL(ctx, t, demoteCommands, tablets[0]) + demoteCommands := []string{"SET GLOBAL read_only = ON", "FLUSH TABLES WITH READ LOCK", "UNLOCK TABLES"} + utils.RunSQLs(ctx, t, demoteCommands, tablets[0]) //Get the position of the old primary and wait for the new one to catch up. err := utils.WaitForReplicationPosition(t, tablets[0], tablets[1]) diff --git a/go/test/endtoend/reparent/utils/utils.go b/go/test/endtoend/reparent/utils/utils.go index 0f48f2b3fa8..675648dcf37 100644 --- a/go/test/endtoend/reparent/utils/utils.go +++ b/go/test/endtoend/reparent/utils/utils.go @@ -258,10 +258,16 @@ func getMysqlConnParam(tablet *cluster.Vttablet) mysql.ConnParams { return connParams } -// RunSQLs is used to run SQL commands directly on the MySQL instance of a vttablet +// RunSQLs is used to run SQL commands directly on the MySQL instance of a vttablet. All commands are +// run in a single connection. func RunSQLs(ctx context.Context, t *testing.T, sqls []string, tablet *cluster.Vttablet) (results []*sqltypes.Result) { + tabletParams := getMysqlConnParam(tablet) + conn, err := mysql.Connect(ctx, &tabletParams) + require.Nil(t, err) + defer conn.Close() + for _, sql := range sqls { - result := RunSQL(ctx, t, sql, tablet) + result := execute(t, conn, sql) results = append(results, result) } return results @@ -704,7 +710,7 @@ func SetReplicationSourceFailed(tablet *cluster.Vttablet, prsOut string) bool { // CheckReplicationStatus checks that the replication for sql and io threads is setup as expected func CheckReplicationStatus(ctx context.Context, t *testing.T, tablet *cluster.Vttablet, sqlThreadRunning bool, ioThreadRunning bool) { - res := RunSQL(ctx, t, "show slave status;", tablet) + res := RunSQL(ctx, t, "show slave status", tablet) if ioThreadRunning { require.Equal(t, "Yes", res.Rows[0][10].ToString()) } else { diff --git a/go/test/endtoend/tabletgateway/buffer/buffer_test_helpers.go b/go/test/endtoend/tabletgateway/buffer/buffer_test_helpers.go index 979f33a11be..96cbab6fcd8 100644 --- a/go/test/endtoend/tabletgateway/buffer/buffer_test_helpers.go +++ b/go/test/endtoend/tabletgateway/buffer/buffer_test_helpers.go @@ -71,7 +71,7 @@ const ( type threadParams struct { quit bool rpcs int // Number of queries successfully executed. - errors int // Number of failed queries. + errors []error // Errors returned by the queries. waitForNotification chan bool // Channel used to notify the main thread that this thread executed notifyLock sync.Mutex // notifyLock guards the two fields notifyAfterNSuccessfulRpcs/rpcsSoFar. notifyAfterNSuccessfulRpcs int // If 0, notifications are disabled @@ -96,14 +96,14 @@ func (c *threadParams) threadRun(wg *sync.WaitGroup, vtParams *mysql.ConnParams) if c.reservedConn { _, err = conn.ExecuteFetch("set default_week_format = 1", 1000, true) if err != nil { - c.errors++ + c.errors = append(c.errors, err) log.Errorf("error setting default_week_format: %v", err) } } for !c.quit { err = c.executeFunction(c, conn) if err != nil { - c.errors++ + c.errors = append(c.errors, err) log.Errorf("error executing function %s: %v", c.typ, err) } c.rpcs++ @@ -343,8 +343,8 @@ func (bt *BufferingTest) Test(t *testing.T) { updateThreadInstance.stop() // Both threads must not see any error - assert.Zero(t, readThreadInstance.errors, "found errors in read queries") - assert.Zero(t, updateThreadInstance.errors, "found errors in tx queries") + assert.Empty(t, readThreadInstance.errors, "found errors in read queries") + assert.Empty(t, updateThreadInstance.errors, "found errors in tx queries") //At least one thread should have been buffered. //This may fail if a failover is too fast. Add retries then. diff --git a/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go b/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go index d3828eb8166..2be57120050 100644 --- a/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go +++ b/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go @@ -29,9 +29,9 @@ import ( "vitess.io/vitess/go/vt/log" ) -const ( - demoteQuery = "SET GLOBAL read_only = ON;FLUSH TABLES WITH READ LOCK;UNLOCK TABLES;" - promoteQuery = "STOP SLAVE;RESET SLAVE ALL;SET GLOBAL read_only = OFF;" +var ( + demoteQueries = []string{"SET GLOBAL read_only = ON", "FLUSH TABLES WITH READ LOCK", "UNLOCK TABLES"} + promoteQueries = []string{"STOP SLAVE", "RESET SLAVE ALL", "SET GLOBAL read_only = OFF"} hostname = "localhost" ) @@ -48,7 +48,8 @@ func failoverExternalReparenting(t *testing.T, clusterInstance *cluster.LocalPro replica := clusterInstance.Keyspaces[0].Shards[0].Vttablets[1] oldPrimary := primary newPrimary := replica - primary.VttabletProcess.QueryTablet(demoteQuery, keyspaceUnshardedName, true) + err := primary.VttabletProcess.QueryTabletMultiple(demoteQueries, keyspaceUnshardedName, true) + require.NoError(t, err) // Wait for replica to catch up to primary. cluster.WaitForReplicationPos(t, primary, replica, false, time.Minute) @@ -62,7 +63,8 @@ func failoverExternalReparenting(t *testing.T, clusterInstance *cluster.LocalPro } // Promote replica to new primary. - replica.VttabletProcess.QueryTablet(promoteQuery, keyspaceUnshardedName, true) + err = replica.VttabletProcess.QueryTabletMultiple(promoteQueries, keyspaceUnshardedName, true) + require.NoError(t, err) // Configure old primary to replicate from new primary. @@ -70,11 +72,18 @@ func failoverExternalReparenting(t *testing.T, clusterInstance *cluster.LocalPro // Use 'localhost' as hostname because Travis CI worker hostnames // are too long for MySQL replication. - changeSourceCommands := fmt.Sprintf("RESET SLAVE;SET GLOBAL gtid_slave_pos = '%s';CHANGE MASTER TO MASTER_HOST='%s', MASTER_PORT=%d ,MASTER_USER='vt_repl', MASTER_USE_GTID = slave_pos;START SLAVE;", gtID, "localhost", newPrimary.MySQLPort) - oldPrimary.VttabletProcess.QueryTablet(changeSourceCommands, keyspaceUnshardedName, true) + changeSourceCommands := []string{ + "STOP SLAVE", + "RESET MASTER", + fmt.Sprintf("SET GLOBAL gtid_purged = '%s'", gtID), + fmt.Sprintf("CHANGE MASTER TO MASTER_HOST='%s', MASTER_PORT=%d, MASTER_USER='vt_repl', MASTER_AUTO_POSITION = 1", "localhost", newPrimary.MySQLPort), + "START SLAVE", + } + err = oldPrimary.VttabletProcess.QueryTabletMultiple(changeSourceCommands, keyspaceUnshardedName, true) + require.NoError(t, err) // Notify the new vttablet primary about the reparent. - err := clusterInstance.VtctlclientProcess.ExecuteCommand("TabletExternallyReparented", newPrimary.Alias) + err = clusterInstance.VtctlclientProcess.ExecuteCommand("TabletExternallyReparented", newPrimary.Alias) require.NoError(t, err) } diff --git a/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go b/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go index cfe961c4558..028d9788e5e 100644 --- a/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go +++ b/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go @@ -52,9 +52,9 @@ var ( ) Engine=InnoDB; ` sqlCreateView = ` - create or replace view v1 as select * from t1; + create or replace view v1 as select * from t1 ` - sqlSchema = sqlCreateTable + sqlCreateView + sqlSchema = []string{sqlCreateTable, sqlCreateView} vSchema = ` { @@ -110,7 +110,7 @@ func TestMain(m *testing.M) { // Start keyspace keyspace := &cluster.Keyspace{ Name: keyspaceName, - SchemaSQL: sqlSchema, + SchemaSQL: strings.Join(sqlSchema, ";"), VSchema: vSchema, } @@ -147,8 +147,9 @@ func checkTableRows(t *testing.T, tableName string, expect int64) { } func populateTable(t *testing.T) { - _, err := primaryTablet.VttabletProcess.QueryTablet(sqlSchema, keyspaceName, true) + err := primaryTablet.VttabletProcess.QueryTabletMultiple(sqlSchema, keyspaceName, true) require.NoError(t, err) + _, err = primaryTablet.VttabletProcess.QueryTablet("delete from t1", keyspaceName, true) require.NoError(t, err) _, err = primaryTablet.VttabletProcess.QueryTablet("insert into t1 (id, value) values (null, md5(rand()))", keyspaceName, true) diff --git a/go/test/endtoend/tabletmanager/tablet_test.go b/go/test/endtoend/tabletmanager/tablet_test.go index 4fe5a70d125..6212b4a418b 100644 --- a/go/test/endtoend/tabletmanager/tablet_test.go +++ b/go/test/endtoend/tabletmanager/tablet_test.go @@ -82,7 +82,7 @@ func TestResetReplicationParameters(t *testing.T) { require.NoError(t, err) // Set a replication source on the tablet and start replication - _, err = tablet.VttabletProcess.QueryTablet("stop slave;change master to master_host = 'localhost', master_port = 123;start slave;", keyspaceName, false) + err = tablet.VttabletProcess.QueryTabletMultiple([]string{"stop slave", "change master to master_host = 'localhost', master_port = 123", "start slave"}, keyspaceName, false) require.NoError(t, err) // Check the replica status. diff --git a/go/test/endtoend/utils/mysql.go b/go/test/endtoend/utils/mysql.go index 1e770b87516..41a70e2dfa4 100644 --- a/go/test/endtoend/utils/mysql.go +++ b/go/test/endtoend/utils/mysql.go @@ -45,7 +45,17 @@ const mysqlShutdownTimeout = 1 * time.Minute // The mysql.ConnParams to connect to the new database is returned, along with a function to // teardown the database. func NewMySQL(cluster *cluster.LocalProcessCluster, dbName string, schemaSQL ...string) (mysql.ConnParams, func(), error) { - mysqlParam, _, closer, error := NewMySQLWithMysqld(cluster.GetAndReservePort(), cluster.Hostname, dbName, schemaSQL...) + // Even though we receive schemaSQL as a variadic argument, we ensure to further split it into singular statements. + parser := sqlparser.NewTestParser() + var sqls []string + for _, sql := range schemaSQL { + split, err := parser.SplitStatementToPieces(sql) + if err != nil { + return mysql.ConnParams{}, nil, err + } + sqls = append(sqls, split...) + } + mysqlParam, _, closer, error := NewMySQLWithMysqld(cluster.GetAndReservePort(), cluster.Hostname, dbName, sqls...) return mysqlParam, closer, error } diff --git a/go/test/endtoend/utils/utils.go b/go/test/endtoend/utils/utils.go index b6bf207decb..d9e94911e30 100644 --- a/go/test/endtoend/utils/utils.go +++ b/go/test/endtoend/utils/utils.go @@ -154,6 +154,15 @@ func Exec(t testing.TB, conn *mysql.Conn, query string) *sqltypes.Result { return qr } +// ExecMulti executes the given (potential multi) queries using the given connection. +// The test fails if any of the queries produces an error +func ExecMulti(t testing.TB, conn *mysql.Conn, query string) error { + t.Helper() + err := conn.ExecuteFetchMultiDrain(query) + require.NoError(t, err, "for query: "+query) + return err +} + // ExecCompareMySQL executes the given query against both Vitess and MySQL and compares // the two result set. If there is a mismatch, the difference will be printed and the // test will fail. If the query produces an error in either Vitess or MySQL, the test diff --git a/go/test/endtoend/vreplication/time_zone_test.go b/go/test/endtoend/vreplication/time_zone_test.go index ff334c593fe..2c0a9a4f5a5 100644 --- a/go/test/endtoend/vreplication/time_zone_test.go +++ b/go/test/endtoend/vreplication/time_zone_test.go @@ -56,7 +56,7 @@ func TestMoveTablesTZ(t *testing.T) { // it seems to take some time for the mysql server to load time zone info after the tables in mysql db have been populated loadTimeZoneInfo := func(tab *cluster.VttabletProcess, sql, timezone string) { - _, err := tab.QueryTabletWithDB(timeZoneSQL, "mysql") + err := tab.MultiQueryTabletWithDB(timeZoneSQL, "mysql") require.NoError(t, err) timer := time.NewTimer(1 * time.Minute) for { diff --git a/go/test/endtoend/vreplication/vstream_test.go b/go/test/endtoend/vreplication/vstream_test.go index 8b21cf6fb60..dee8243d5e9 100644 --- a/go/test/endtoend/vreplication/vstream_test.go +++ b/go/test/endtoend/vreplication/vstream_test.go @@ -219,7 +219,7 @@ func insertRow(keyspace, table string, id int) { if vtgateConn == nil { return } - vtgateConn.ExecuteFetch(fmt.Sprintf("use %s;", keyspace), 1000, false) + vtgateConn.ExecuteFetch(fmt.Sprintf("use %s", keyspace), 1000, false) vtgateConn.ExecuteFetch("begin", 1000, false) _, err := vtgateConn.ExecuteFetch(fmt.Sprintf("insert into %s (name) values ('%s%d')", table, table, id), 1000, false) if err != nil { diff --git a/go/test/endtoend/vtgate/errors_as_warnings/main_test.go b/go/test/endtoend/vtgate/errors_as_warnings/main_test.go index 24cade5b550..71f4a2353f7 100644 --- a/go/test/endtoend/vtgate/errors_as_warnings/main_test.go +++ b/go/test/endtoend/vtgate/errors_as_warnings/main_test.go @@ -153,7 +153,7 @@ func TestScatterErrsAsWarns(t *testing.T) { assertContainsOneOf(t, mode.conn, showQ, expectedWarnings...) // invalid_field should throw error and not warning - _, err = mode.conn.ExecuteFetch("SELECT /*vt+ PLANNER=Gen4 SCATTER_ERRORS_AS_WARNINGS */ invalid_field from t1;", 1, false) + _, err = mode.conn.ExecuteFetch("SELECT /*vt+ PLANNER=Gen4 SCATTER_ERRORS_AS_WARNINGS */ invalid_field from t1", 1, false) require.Error(t, err) serr := sqlerror.NewSQLErrorFromError(err).(*sqlerror.SQLError) require.Equal(t, sqlerror.ERBadFieldError, serr.Number(), serr.Error()) diff --git a/go/test/endtoend/vtgate/queries/kill/main_test.go b/go/test/endtoend/vtgate/queries/kill/main_test.go index 836603c91ee..cc74be24336 100644 --- a/go/test/endtoend/vtgate/queries/kill/main_test.go +++ b/go/test/endtoend/vtgate/queries/kill/main_test.go @@ -134,7 +134,8 @@ func dropData(t *testing.T) { defer conn.Close() utils.Exec(t, conn, "drop table if exists test") - utils.Exec(t, conn, schema) + utils.Exec(t, conn, "drop table if exists test_idx") + utils.ExecMulti(t, conn, schema) } func getRandomString(size int) string { diff --git a/go/test/endtoend/vtgate/unsharded/main_test.go b/go/test/endtoend/vtgate/unsharded/main_test.go index 7405a7dd87f..461a3c73b35 100644 --- a/go/test/endtoend/vtgate/unsharded/main_test.go +++ b/go/test/endtoend/vtgate/unsharded/main_test.go @@ -97,53 +97,53 @@ CREATE TABLE allDefaults ( } ` - createProcSQL = `use vt_customer; + createProcSQL = []string{` CREATE PROCEDURE sp_insert() BEGIN insert into allDefaults () values (); END; - +`, ` CREATE PROCEDURE sp_delete() BEGIN delete from allDefaults; END; - +`, ` CREATE PROCEDURE sp_multi_dml() BEGIN insert into allDefaults () values (); delete from allDefaults; END; - +`, ` CREATE PROCEDURE sp_variable() BEGIN insert into allDefaults () values (); SELECT min(id) INTO @myvar FROM allDefaults; DELETE FROM allDefaults WHERE id = @myvar; END; - +`, ` CREATE PROCEDURE sp_select() BEGIN SELECT * FROM allDefaults; END; - +`, ` CREATE PROCEDURE sp_all() BEGIN insert into allDefaults () values (); select * from allDefaults; delete from allDefaults; END; - +`, ` CREATE PROCEDURE in_parameter(IN val int) BEGIN insert into allDefaults(id) values(val); END; - +`, ` CREATE PROCEDURE out_parameter(OUT val int) BEGIN insert into allDefaults(id) values (128); select 128 into val from dual; END; -` +`} ) var enableSettingsPool bool @@ -196,7 +196,7 @@ func runAllTests(m *testing.M) int { } primaryTablet := clusterInstance.Keyspaces[0].Shards[0].PrimaryTablet().VttabletProcess - if _, err := primaryTablet.QueryTablet(createProcSQL, KeyspaceName, false); err != nil { + if err := primaryTablet.QueryTabletMultiple(createProcSQL, KeyspaceName, true); err != nil { log.Fatal(err.Error()) return 1 } @@ -332,13 +332,11 @@ func TestCallProcedure(t *testing.T) { utils.AssertMatches(t, conn, "show warnings", `[[VARCHAR("Warning") UINT16(1235) VARCHAR("'CALL' not supported in sharded mode")]]`) - _, err = conn.ExecuteFetch(`CALL sp_select()`, 1000, true) - require.Error(t, err) - require.Contains(t, err.Error(), "Multi-Resultset not supported in stored procedure") + err = conn.ExecuteFetchMultiDrain(`CALL sp_select()`) + require.ErrorContains(t, err, "Multi-Resultset not supported in stored procedure") - _, err = conn.ExecuteFetch(`CALL sp_all()`, 1000, true) - require.Error(t, err) - require.Contains(t, err.Error(), "Multi-Resultset not supported in stored procedure") + err = conn.ExecuteFetchMultiDrain(`CALL sp_all()`) + require.ErrorContains(t, err, "Multi-Resultset not supported in stored procedure") qr = utils.Exec(t, conn, `CALL sp_delete()`) require.GreaterOrEqual(t, 1, int(qr.RowsAffected)) diff --git a/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go b/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go index 180f367d7fb..e226e8d13ae 100644 --- a/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go +++ b/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go @@ -438,9 +438,8 @@ func TestLostRdonlyOnPrimaryFailure(t *testing.T) { // check that replication is setup correctly utils.CheckReplication(t, clusterInfo, curPrimary, []*cluster.Vttablet{rdonly, aheadRdonly, replica}, 15*time.Second) - // revoke super privileges from vtorc on replica and rdonly so that it is unable to repair the replication - utils.ChangePrivileges(t, `REVOKE SUPER ON *.* FROM 'orc_client_user'@'%'`, replica, "orc_client_user") - utils.ChangePrivileges(t, `REVOKE SUPER ON *.* FROM 'orc_client_user'@'%'`, rdonly, "orc_client_user") + // disable recoveries on vtorc so that it is unable to repair the replication + utils.DisableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // stop replication on the replica and rdonly. err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", replica.Alias) @@ -467,9 +466,8 @@ func TestLostRdonlyOnPrimaryFailure(t *testing.T) { utils.PermanentlyRemoveVttablet(clusterInfo, curPrimary) }() - // grant super privileges back to vtorc on replica and rdonly so that it can repair - utils.ChangePrivileges(t, `GRANT SUPER ON *.* TO 'orc_client_user'@'%'`, replica, "orc_client_user") - utils.ChangePrivileges(t, `GRANT SUPER ON *.* TO 'orc_client_user'@'%'`, rdonly, "orc_client_user") + // enable recoveries back on vtorc so that it can repair + utils.EnableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // vtorc must promote the lagging replica and not the rdonly, since it has a MustNotPromoteRule promotion rule utils.CheckPrimaryTablet(t, clusterInfo, replica, true) @@ -667,8 +665,8 @@ func TestDownPrimaryPromotionRuleWithLag(t *testing.T) { // newly started tablet does not replicate from anyone yet, we will allow vtorc to fix this too utils.CheckReplication(t, clusterInfo, curPrimary, []*cluster.Vttablet{crossCellReplica, replica, rdonly}, 25*time.Second) - // revoke super privileges from vtorc on crossCellReplica so that it is unable to repair the replication - utils.ChangePrivileges(t, `REVOKE SUPER ON *.* FROM 'orc_client_user'@'%'`, crossCellReplica, "orc_client_user") + // disable recoveries for vtorc so that it is unable to repair the replication. + utils.DisableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // stop replication on the crossCellReplica. err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", crossCellReplica.Alias) @@ -684,8 +682,8 @@ func TestDownPrimaryPromotionRuleWithLag(t *testing.T) { err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", crossCellReplica.Alias) require.NoError(t, err) - // grant super privileges back to vtorc on crossCellReplica so that it can repair - utils.ChangePrivileges(t, `GRANT SUPER ON *.* TO 'orc_client_user'@'%'`, crossCellReplica, "orc_client_user") + // enable recoveries back on vtorc so that it can repair + utils.EnableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // assert that the crossCellReplica is indeed lagging and does not have the new insertion by checking the count of rows in the table out, err := utils.RunSQL(t, "SELECT * FROM vt_insert_test", crossCellReplica, "vt_ks") @@ -748,8 +746,8 @@ func TestDownPrimaryPromotionRuleWithLagCrossCenter(t *testing.T) { // newly started tablet does not replicate from anyone yet, we will allow vtorc to fix this too utils.CheckReplication(t, clusterInfo, curPrimary, []*cluster.Vttablet{crossCellReplica, replica, rdonly}, 25*time.Second) - // revoke super privileges from vtorc on replica so that it is unable to repair the replication - utils.ChangePrivileges(t, `REVOKE SUPER ON *.* FROM 'orc_client_user'@'%'`, replica, "orc_client_user") + // disable recoveries from vtorc so that it is unable to repair the replication + utils.DisableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // stop replication on the replica. err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", replica.Alias) @@ -765,8 +763,8 @@ func TestDownPrimaryPromotionRuleWithLagCrossCenter(t *testing.T) { err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", replica.Alias) require.NoError(t, err) - // grant super privileges back to vtorc on replica so that it can repair - utils.ChangePrivileges(t, `GRANT SUPER ON *.* TO 'orc_client_user'@'%'`, replica, "orc_client_user") + // enable recoveries back on vtorc so that it can repair + utils.EnableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // assert that the replica is indeed lagging and does not have the new insertion by checking the count of rows in the table out, err := utils.RunSQL(t, "SELECT * FROM vt_insert_test", replica, "vt_ks") diff --git a/go/test/endtoend/vtorc/utils/utils.go b/go/test/endtoend/vtorc/utils/utils.go index 07b5b016fcc..11294319658 100644 --- a/go/test/endtoend/vtorc/utils/utils.go +++ b/go/test/endtoend/vtorc/utils/utils.go @@ -683,21 +683,6 @@ func PermanentlyRemoveVttablet(clusterInfo *VTOrcClusterInfo, tablet *cluster.Vt } } -// ChangePrivileges is used to change the privileges of the given user. These commands are executed such that they are not replicated -func ChangePrivileges(t *testing.T, sql string, tablet *cluster.Vttablet, user string) { - _, err := RunSQL(t, "SET sql_log_bin = OFF;"+sql+";SET sql_log_bin = ON;", tablet, "") - require.NoError(t, err) - - res, err := RunSQL(t, fmt.Sprintf("SELECT id FROM INFORMATION_SCHEMA.PROCESSLIST WHERE user = '%s'", user), tablet, "") - require.NoError(t, err) - for _, row := range res.Rows { - id, err := row[0].ToInt64() - require.NoError(t, err) - _, err = RunSQL(t, fmt.Sprintf("kill %d", id), tablet, "") - require.NoError(t, err) - } -} - // ResetPrimaryLogs is used reset the binary logs func ResetPrimaryLogs(t *testing.T, curPrimary *cluster.Vttablet) { _, err := RunSQL(t, "FLUSH BINARY LOGS", curPrimary, "") @@ -1121,3 +1106,19 @@ func PrintVTOrcLogsOnFailure(t *testing.T, clusterInstance *cluster.LocalProcess log.Errorf("%s", string(content)) } } + +// EnableGlobalRecoveries enables global recoveries for the given VTOrc. +func EnableGlobalRecoveries(t *testing.T, vtorc *cluster.VTOrcProcess) { + status, resp, err := MakeAPICall(t, vtorc, "/api/enable-global-recoveries") + require.NoError(t, err) + assert.Equal(t, 200, status) + assert.Equal(t, "Global recoveries enabled\n", resp) +} + +// DisableGlobalRecoveries disables global recoveries for the given VTOrc. +func DisableGlobalRecoveries(t *testing.T, vtorc *cluster.VTOrcProcess) { + status, resp, err := MakeAPICall(t, vtorc, "/api/disable-global-recoveries") + require.NoError(t, err) + assert.Equal(t, 200, status) + assert.Equal(t, "Global recoveries disabled\n", resp) +} diff --git a/go/vt/mysqlctl/mysqld.go b/go/vt/mysqlctl/mysqld.go index 6de6425925e..5c11c6055e8 100644 --- a/go/vt/mysqlctl/mysqld.go +++ b/go/vt/mysqlctl/mysqld.go @@ -412,7 +412,7 @@ func (mysqld *Mysqld) startNoWait(cnf *Mycnf, mysqldArgs ...string) error { }() err = cmd.Start() if err != nil { - return err + return vterrors.Wrapf(err, "failed to start mysqld") } mysqld.mutex.Lock() diff --git a/go/vt/vttablet/endtoend/call_test.go b/go/vt/vttablet/endtoend/call_test.go index 477a099aa76..a1a2eae792a 100644 --- a/go/vt/vttablet/endtoend/call_test.go +++ b/go/vt/vttablet/endtoend/call_test.go @@ -75,12 +75,16 @@ func TestCallProcedure(t *testing.T) { wantErr bool } tcases := []testcases{{ + query: "call proc_dml()", + }, { query: "call proc_select1()", wantErr: true, }, { query: "call proc_select4()", wantErr: true, }, { + // Again, make sure the connection isn't dirty and does not contain leftover + // result sets from previous tests. query: "call proc_dml()", }} @@ -92,7 +96,6 @@ func TestCallProcedure(t *testing.T) { return } require.NoError(t, err) - }) } } diff --git a/go/vt/vttablet/tabletmanager/tm_init_test.go b/go/vt/vttablet/tabletmanager/tm_init_test.go index 0636e7db633..c44bb846eb3 100644 --- a/go/vt/vttablet/tabletmanager/tm_init_test.go +++ b/go/vt/vttablet/tabletmanager/tm_init_test.go @@ -907,7 +907,7 @@ func startMySQLAndCreateUser(t *testing.T, testUser string) (vttest.LocalCluster connParams := cluster.MySQLConnParams() conn, err := mysql.Connect(context.Background(), &connParams) require.NoError(t, err) - _, err = conn.ExecuteFetch(fmt.Sprintf(`CREATE USER '%v'@'localhost';`, testUser), 1000, false) + _, err = conn.ExecuteFetch(fmt.Sprintf(`CREATE USER '%v'@'localhost'`, testUser), 1000, false) conn.Close() return cluster, err @@ -917,11 +917,11 @@ func startMySQLAndCreateUser(t *testing.T, testUser string) (vttest.LocalCluster func grantAllPrivilegesToUser(t *testing.T, connParams mysql.ConnParams, testUser string) { conn, err := mysql.Connect(context.Background(), &connParams) require.NoError(t, err) - _, err = conn.ExecuteFetch(fmt.Sprintf(`GRANT ALL ON *.* TO '%v'@'localhost';`, testUser), 1000, false) + _, err = conn.ExecuteFetch(fmt.Sprintf(`GRANT ALL ON *.* TO '%v'@'localhost'`, testUser), 1000, false) require.NoError(t, err) - _, err = conn.ExecuteFetch(fmt.Sprintf(`GRANT GRANT OPTION ON *.* TO '%v'@'localhost';`, testUser), 1000, false) + _, err = conn.ExecuteFetch(fmt.Sprintf(`GRANT GRANT OPTION ON *.* TO '%v'@'localhost'`, testUser), 1000, false) require.NoError(t, err) - _, err = conn.ExecuteFetch("FLUSH PRIVILEGES;", 1000, false) + _, err = conn.ExecuteFetch("FLUSH PRIVILEGES", 1000, false) require.NoError(t, err) conn.Close() } diff --git a/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go b/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go index 04738ee7857..dd51fb6c042 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go @@ -2901,7 +2901,7 @@ func TestPlayerInvalidDates(t *testing.T) { fmt.Sprintf("drop table %s.dst1", vrepldb), }) pos := primaryPosition(t) - execStatements(t, []string{"set sql_mode='';insert into src1 values(1, '0000-00-00');set sql_mode='STRICT_TRANS_TABLES';"}) + execStatements(t, []string{"set sql_mode=''", "insert into src1 values(1, '0000-00-00')", "set sql_mode='STRICT_TRANS_TABLES'"}) env.SchemaEngine.Reload(context.Background()) // default mysql flavor allows invalid dates: so disallow explicitly for this test diff --git a/go/vt/vttablet/tabletserver/query_executor.go b/go/vt/vttablet/tabletserver/query_executor.go index 844ce753152..5690c209ebb 100644 --- a/go/vt/vttablet/tabletserver/query_executor.go +++ b/go/vt/vttablet/tabletserver/query_executor.go @@ -18,12 +18,14 @@ package tabletserver import ( "context" + "errors" "fmt" "io" "strings" "sync" "time" + "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/mysql/sqlerror" "vitess.io/vitess/go/pools/smartconnpool" @@ -881,6 +883,9 @@ func (qre *QueryExecutor) execCallProc() (*sqltypes.Result, error) { } qr, err := qre.execDBConn(conn.Conn, sql, true) + if errors.Is(err, mysql.ErrExecuteFetchMultipleResults) { + return nil, vterrors.New(vtrpcpb.Code_UNIMPLEMENTED, "Multi-Resultset not supported in stored procedure") + } if err != nil { return nil, rewriteOUTParamError(err) } diff --git a/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go b/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go index 203052e981e..ea6e0fb76aa 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go @@ -240,17 +240,17 @@ func TestVStreamCopyCompleteFlow(t *testing.T) { insertRow(t, "t1", 1, numInitialRows+4) insertRow(t, "t2", 2, numInitialRows+3) // savepoints should not be sent in the event stream - execStatement(t, ` -begin; -insert into t3 (id31, id32) values (12, 360); -savepoint a; -insert into t3 (id31, id32) values (13, 390); -rollback work to savepoint a; -savepoint b; -insert into t3 (id31, id32) values (13, 390); -release savepoint b; -commit;" -`) + execStatements(t, []string{ + "begin", + "insert into t3 (id31, id32) values (12, 360)", + "savepoint a", + "insert into t3 (id31, id32) values (13, 390)", + "rollback work to savepoint a", + "savepoint b", + "insert into t3 (id31, id32) values (13, 390)", + "release savepoint b", + "commit", + }) } numCopyEvents := 3 /*t1,t2,t3*/ * (numInitialRows + 1 /*FieldEvent*/ + 1 /*LastPKEvent*/ + 1 /*TestEvent: Copy Start*/ + 2 /*begin,commit*/ + 3 /* LastPK Completed*/) From c4d2a5a3fd226cbe8672ec52b3774959df405994 Mon Sep 17 00:00:00 2001 From: Florent Poinsard <35779988+frouioui@users.noreply.github.com> Date: Wed, 14 Feb 2024 08:45:33 -0600 Subject: [PATCH 07/79] Avoid rewriting unsharded queries and split semantic analysis in two (#15217) Signed-off-by: Andres Taylor Co-authored-by: Andres Taylor --- go/vt/sqlparser/impossible_query.go | 3 + .../planbuilder/operators/aggregator.go | 5 +- .../planbuilder/operators/apply_join.go | 2 +- go/vt/vtgate/planbuilder/operators/filter.go | 8 +- .../vtgate/planbuilder/operators/hash_join.go | 2 +- go/vt/vtgate/planbuilder/operators/horizon.go | 7 +- go/vt/vtgate/planbuilder/operators/join.go | 2 +- .../planbuilder/operators/route_planning.go | 2 +- .../vtgate/planbuilder/operators/subquery.go | 5 +- .../operators/subquery_planning.go | 14 +- go/vt/vtgate/planbuilder/operators/union.go | 5 +- .../planbuilder/testdata/cte_cases.json | 31 +- .../planbuilder/testdata/ddl_cases.json | 2 +- .../planbuilder/testdata/filter_cases.json | 2 +- .../testdata/foreignkey_cases.json | 24 +- .../testdata/foreignkey_checks_on_cases.json | 12 +- .../planbuilder/testdata/from_cases.json | 8 +- .../planbuilder/testdata/select_cases.json | 6 +- .../planbuilder/testdata/union_cases.json | 2 +- go/vt/vtgate/semantics/analyzer.go | 145 ++++++-- go/vt/vtgate/semantics/analyzer_fk_test.go | 98 +++--- go/vt/vtgate/semantics/analyzer_test.go | 314 ++---------------- go/vt/vtgate/semantics/derived_test.go | 265 +++++++++++++++ go/vt/vtgate/semantics/early_rewriter_test.go | 16 +- go/vt/vtgate/semantics/semantic_state.go | 8 +- go/vt/vtgate/semantics/semantic_state_test.go | 2 +- go/vt/vtgate/semantics/table_collector.go | 104 +++++- 27 files changed, 648 insertions(+), 446 deletions(-) create mode 100644 go/vt/vtgate/semantics/derived_test.go diff --git a/go/vt/sqlparser/impossible_query.go b/go/vt/sqlparser/impossible_query.go index 512931f1db7..a6bf1ea8736 100644 --- a/go/vt/sqlparser/impossible_query.go +++ b/go/vt/sqlparser/impossible_query.go @@ -27,6 +27,9 @@ package sqlparser func FormatImpossibleQuery(buf *TrackedBuffer, node SQLNode) { switch node := node.(type) { case *Select: + if node.With != nil { + node.With.Format(buf) + } buf.Myprintf("select %v from ", node.SelectExprs) var prefix string for _, n := range node.From { diff --git a/go/vt/vtgate/planbuilder/operators/aggregator.go b/go/vt/vtgate/planbuilder/operators/aggregator.go index 6c2171cf689..256372c172f 100644 --- a/go/vt/vtgate/planbuilder/operators/aggregator.go +++ b/go/vt/vtgate/planbuilder/operators/aggregator.go @@ -80,10 +80,7 @@ func (a *Aggregator) SetInputs(operators []Operator) { } func (a *Aggregator) AddPredicate(_ *plancontext.PlanningContext, expr sqlparser.Expr) Operator { - return &Filter{ - Source: a, - Predicates: []sqlparser.Expr{expr}, - } + return newFilter(a, expr) } func (a *Aggregator) addColumnWithoutPushing(_ *plancontext.PlanningContext, expr *sqlparser.AliasedExpr, addToGroupBy bool) int { diff --git a/go/vt/vtgate/planbuilder/operators/apply_join.go b/go/vt/vtgate/planbuilder/operators/apply_join.go index 9294311c00f..c182bb2fb83 100644 --- a/go/vt/vtgate/planbuilder/operators/apply_join.go +++ b/go/vt/vtgate/planbuilder/operators/apply_join.go @@ -109,7 +109,7 @@ func (aj *ApplyJoin) Clone(inputs []Operator) Operator { } func (aj *ApplyJoin) AddPredicate(ctx *plancontext.PlanningContext, expr sqlparser.Expr) Operator { - return AddPredicate(ctx, aj, expr, false, newFilter) + return AddPredicate(ctx, aj, expr, false, newFilterSinglePredicate) } // Inputs implements the Operator interface diff --git a/go/vt/vtgate/planbuilder/operators/filter.go b/go/vt/vtgate/planbuilder/operators/filter.go index 17e5ac64b71..c2432a40da9 100644 --- a/go/vt/vtgate/planbuilder/operators/filter.go +++ b/go/vt/vtgate/planbuilder/operators/filter.go @@ -39,9 +39,13 @@ type Filter struct { Truncate int } -func newFilter(op Operator, expr sqlparser.Expr) Operator { +func newFilterSinglePredicate(op Operator, expr sqlparser.Expr) Operator { + return newFilter(op, expr) +} + +func newFilter(op Operator, expr ...sqlparser.Expr) Operator { return &Filter{ - Source: op, Predicates: []sqlparser.Expr{expr}, + Source: op, Predicates: expr, } } diff --git a/go/vt/vtgate/planbuilder/operators/hash_join.go b/go/vt/vtgate/planbuilder/operators/hash_join.go index e5a87cf4ef8..0ad46bcbc82 100644 --- a/go/vt/vtgate/planbuilder/operators/hash_join.go +++ b/go/vt/vtgate/planbuilder/operators/hash_join.go @@ -106,7 +106,7 @@ func (hj *HashJoin) SetInputs(operators []Operator) { } func (hj *HashJoin) AddPredicate(ctx *plancontext.PlanningContext, expr sqlparser.Expr) Operator { - return AddPredicate(ctx, hj, expr, false, newFilter) + return AddPredicate(ctx, hj, expr, false, newFilterSinglePredicate) } func (hj *HashJoin) AddColumn(ctx *plancontext.PlanningContext, reuseExisting bool, addToGroupBy bool, expr *sqlparser.AliasedExpr) int { diff --git a/go/vt/vtgate/planbuilder/operators/horizon.go b/go/vt/vtgate/planbuilder/operators/horizon.go index f05abb0311b..34f6dc79217 100644 --- a/go/vt/vtgate/planbuilder/operators/horizon.go +++ b/go/vt/vtgate/planbuilder/operators/horizon.go @@ -94,17 +94,14 @@ func (h *Horizon) AddPredicate(ctx *plancontext.PlanningContext, expr sqlparser. tableInfo, err := ctx.SemTable.TableInfoForExpr(expr) if err != nil { if errors.Is(err, semantics.ErrNotSingleTable) { - return &Filter{ - Source: h, - Predicates: []sqlparser.Expr{expr}, - } + return newFilter(h, expr) } panic(err) } newExpr := semantics.RewriteDerivedTableExpression(expr, tableInfo) if sqlparser.ContainsAggregation(newExpr) { - return &Filter{Source: h, Predicates: []sqlparser.Expr{expr}} + return newFilter(h, expr) } h.Source = h.Source.AddPredicate(ctx, newExpr) return h diff --git a/go/vt/vtgate/planbuilder/operators/join.go b/go/vt/vtgate/planbuilder/operators/join.go index 0796d237b88..787d7fedfcc 100644 --- a/go/vt/vtgate/planbuilder/operators/join.go +++ b/go/vt/vtgate/planbuilder/operators/join.go @@ -128,7 +128,7 @@ func createInnerJoin(ctx *plancontext.PlanningContext, tableExpr *sqlparser.Join } func (j *Join) AddPredicate(ctx *plancontext.PlanningContext, expr sqlparser.Expr) Operator { - return AddPredicate(ctx, j, expr, false, newFilter) + return AddPredicate(ctx, j, expr, false, newFilterSinglePredicate) } var _ JoinOp = (*Join)(nil) diff --git a/go/vt/vtgate/planbuilder/operators/route_planning.go b/go/vt/vtgate/planbuilder/operators/route_planning.go index ddb2f0d1210..f7276ea48c7 100644 --- a/go/vt/vtgate/planbuilder/operators/route_planning.go +++ b/go/vt/vtgate/planbuilder/operators/route_planning.go @@ -533,7 +533,7 @@ func pushJoinPredicates(ctx *plancontext.PlanningContext, exprs []sqlparser.Expr } for _, expr := range exprs { - AddPredicate(ctx, op, expr, true, newFilter) + AddPredicate(ctx, op, expr, true, newFilterSinglePredicate) } return op diff --git a/go/vt/vtgate/planbuilder/operators/subquery.go b/go/vt/vtgate/planbuilder/operators/subquery.go index 24417cfab21..537737363c8 100644 --- a/go/vt/vtgate/planbuilder/operators/subquery.go +++ b/go/vt/vtgate/planbuilder/operators/subquery.go @@ -269,10 +269,7 @@ func (sq *SubQuery) settleFilter(ctx *plancontext.PlanningContext, outer Operato predicates = append(predicates, rhsPred) sq.SubqueryValueName = sq.ArgName } - return &Filter{ - Source: outer, - Predicates: predicates, - } + return newFilter(outer, predicates...) } func dontEnterSubqueries(node, _ sqlparser.SQLNode) bool { diff --git a/go/vt/vtgate/planbuilder/operators/subquery_planning.go b/go/vt/vtgate/planbuilder/operators/subquery_planning.go index 1727f7bedcb..960cde99acc 100644 --- a/go/vt/vtgate/planbuilder/operators/subquery_planning.go +++ b/go/vt/vtgate/planbuilder/operators/subquery_planning.go @@ -458,7 +458,7 @@ func tryMergeSubqueriesRecursively( finalResult = finalResult.Merge(res) } - op.Source = &Filter{Source: outer.Source, Predicates: []sqlparser.Expr{subQuery.Original}} + op.Source = newFilter(outer.Source, subQuery.Original) return op, finalResult.Merge(Rewrote("merge outer of two subqueries")) } @@ -477,7 +477,7 @@ func tryMergeSubqueryWithOuter(ctx *plancontext.PlanningContext, subQuery *SubQu return outer, NoRewrite } if !subQuery.IsProjection { - op.Source = &Filter{Source: outer.Source, Predicates: []sqlparser.Expr{subQuery.Original}} + op.Source = newFilter(outer.Source, subQuery.Original) } ctx.MergedSubqueries = append(ctx.MergedSubqueries, subQuery.originalSubquery) return op, Rewrote("merged subquery with outer") @@ -582,10 +582,7 @@ func (s *subqueryRouteMerger) merge(ctx *plancontext.PlanningContext, inner, out if isSharded { src = s.outer.Source if !s.subq.IsProjection { - src = &Filter{ - Source: s.outer.Source, - Predicates: []sqlparser.Expr{s.original}, - } + src = newFilter(s.outer.Source, s.original) } } else { src = s.rewriteASTExpression(ctx, inner) @@ -655,10 +652,7 @@ func (s *subqueryRouteMerger) rewriteASTExpression(ctx *plancontext.PlanningCont cursor.Replace(subq) } }, ctx.SemTable.CopySemanticInfo).(sqlparser.Expr) - src = &Filter{ - Source: s.outer.Source, - Predicates: []sqlparser.Expr{sQuery}, - } + src = newFilter(s.outer.Source, sQuery) } return src } diff --git a/go/vt/vtgate/planbuilder/operators/union.go b/go/vt/vtgate/planbuilder/operators/union.go index 6ce5fe9a9f8..1d739c9f01c 100644 --- a/go/vt/vtgate/planbuilder/operators/union.go +++ b/go/vt/vtgate/planbuilder/operators/union.go @@ -105,10 +105,7 @@ func (u *Union) AddPredicate(ctx *plancontext.PlanningContext, expr sqlparser.Ex needsFilter, exprPerSource := u.predicatePerSource(expr, offsets) if needsFilter { - return &Filter{ - Source: u, - Predicates: []sqlparser.Expr{expr}, - } + return newFilter(u, expr) } for i, src := range u.Sources { diff --git a/go/vt/vtgate/planbuilder/testdata/cte_cases.json b/go/vt/vtgate/planbuilder/testdata/cte_cases.json index c51a6f9144d..e43b6320340 100644 --- a/go/vt/vtgate/planbuilder/testdata/cte_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/cte_cases.json @@ -1369,8 +1369,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select u.* from (select * from unsharded where 1 != 1) as u where 1 != 1", - "Query": "select u.* from (select * from unsharded) as u", + "FieldQuery": "with u as (select * from unsharded where 1 != 1) select u.* from u where 1 != 1", + "Query": "with u as (select * from unsharded) select u.* from u", "Table": "unsharded" }, "TablesUsed": [ @@ -1709,8 +1709,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select col from (select col from unsharded join unsharded_b where 1 != 1) as u join unsharded_a as ua where 1 != 1", - "Query": "select col from (select col from unsharded join unsharded_b) as u join unsharded_a as ua limit 1", + "FieldQuery": "with u as (select col from unsharded join unsharded_b where 1 != 1) select col from u join unsharded_a as ua where 1 != 1", + "Query": "with u as (select col from unsharded join unsharded_b) select col from u join unsharded_a as ua limit 1", "Table": "unsharded, unsharded_a, unsharded_b" }, "TablesUsed": [ @@ -1840,5 +1840,28 @@ "user.user" ] } + }, + { + "comment": "recursive WITH against an unsharded database", + "query": "WITH RECURSIVE cte (n) AS ( SELECT 1 UNION ALL SELECT n + 1 FROM cte WHERE n < 5 ) SELECT cte.n FROM unsharded join cte on unsharded.id = cte.n ", + "plan": { + "QueryType": "SELECT", + "Original": "WITH RECURSIVE cte (n) AS ( SELECT 1 UNION ALL SELECT n + 1 FROM cte WHERE n < 5 ) SELECT cte.n FROM unsharded join cte on unsharded.id = cte.n ", + "Instructions": { + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "FieldQuery": "with recursive cte(n) as (select 1 from dual where 1 != 1 union all select n + 1 from cte where 1 != 1) select cte.n from unsharded join cte on unsharded.id = cte.n where 1 != 1", + "Query": "with recursive cte(n) as (select 1 from dual union all select n + 1 from cte where n < 5) select cte.n from unsharded join cte on unsharded.id = cte.n", + "Table": "dual, unsharded" + }, + "TablesUsed": [ + "main.dual", + "main.unsharded" + ] + } } ] diff --git a/go/vt/vtgate/planbuilder/testdata/ddl_cases.json b/go/vt/vtgate/planbuilder/testdata/ddl_cases.json index e31cc3e29e1..41aded18c5d 100644 --- a/go/vt/vtgate/planbuilder/testdata/ddl_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/ddl_cases.json @@ -260,7 +260,7 @@ "Name": "main", "Sharded": false }, - "Query": "create view view_a as select col1, col2 from (select col1, col2 from unsharded where id = 1 union select col1, col2 from unsharded where id = 3) as a" + "Query": "create view view_a as select * from (select col1, col2 from unsharded where id = 1 union select col1, col2 from unsharded where id = 3) as a" }, "TablesUsed": [ "main.view_a" diff --git a/go/vt/vtgate/planbuilder/testdata/filter_cases.json b/go/vt/vtgate/planbuilder/testdata/filter_cases.json index b4bca3f8830..4353f31fd48 100644 --- a/go/vt/vtgate/planbuilder/testdata/filter_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/filter_cases.json @@ -4086,7 +4086,7 @@ "Sharded": false }, "FieldQuery": "select col + 2 as a from unsharded where 1 != 1", - "Query": "select col + 2 as a from unsharded having col + 2 = 42", + "Query": "select col + 2 as a from unsharded having a = 42", "Table": "unsharded" }, "TablesUsed": [ diff --git a/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json b/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json index b304f9323e4..1c1bcc9144a 100644 --- a/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json @@ -816,7 +816,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl2 left join u_tbl1 on u_tbl1.col1 = cast(u_tbl2.col1 + 'bar' as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl2 left join u_tbl1 on u_tbl1.col1 = cast(u_tbl2.col1 + 'bar' as CHAR) where cast(u_tbl2.col1 + 'bar' as CHAR) is not null and not (u_tbl2.col2) <=> (cast(u_tbl2.col1 + 'bar' as CHAR)) and u_tbl2.id = 1 and u_tbl1.col1 is null limit 1 for share", + "Query": "select 1 from u_tbl2 left join u_tbl1 on u_tbl1.col1 = cast(u_tbl2.col1 + 'bar' as CHAR) where u_tbl1.col1 is null and cast(u_tbl2.col1 + 'bar' as CHAR) is not null and not (u_tbl2.col2) <=> (cast(u_tbl2.col1 + 'bar' as CHAR)) and u_tbl2.id = 1 limit 1 for share", "Table": "u_tbl1, u_tbl2" }, { @@ -1523,7 +1523,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl8 left join u_tbl9 on u_tbl9.col9 = cast('foo' as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl8 left join u_tbl9 on u_tbl9.col9 = cast('foo' as CHAR) where not (u_tbl8.col8) <=> (cast('foo' as CHAR)) and (u_tbl8.col8) in ::fkc_vals and u_tbl9.col9 is null limit 1 for share nowait", + "Query": "select 1 from u_tbl8 left join u_tbl9 on u_tbl9.col9 = cast('foo' as CHAR) where u_tbl9.col9 is null and cast('foo' as CHAR) is not null and not (u_tbl8.col8) <=> (cast('foo' as CHAR)) and (u_tbl8.col8) in ::fkc_vals limit 1 for share nowait", "Table": "u_tbl8, u_tbl9" }, { @@ -1599,7 +1599,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast('foo' as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast('foo' as CHAR) where not (u_tbl4.col4) <=> (cast('foo' as CHAR)) and (u_tbl4.col4) in ::fkc_vals and u_tbl3.col3 is null limit 1 for share", + "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast('foo' as CHAR) where u_tbl3.col3 is null and cast('foo' as CHAR) is not null and not (u_tbl4.col4) <=> (cast('foo' as CHAR)) and (u_tbl4.col4) in ::fkc_vals limit 1 for share", "Table": "u_tbl3, u_tbl4" }, { @@ -1611,7 +1611,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4, u_tbl9 where 1 != 1", - "Query": "select 1 from u_tbl4, u_tbl9 where (u_tbl4.col4) in ::fkc_vals and (u_tbl9.col9) not in ((cast('foo' as CHAR))) and u_tbl4.col4 = u_tbl9.col9 limit 1 for share", + "Query": "select 1 from u_tbl4, u_tbl9 where u_tbl4.col4 = u_tbl9.col9 and (u_tbl4.col4) in ::fkc_vals and (cast('foo' as CHAR) is null or (u_tbl9.col9) not in ((cast('foo' as CHAR)))) limit 1 for share", "Table": "u_tbl4, u_tbl9" }, { @@ -1688,7 +1688,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:v1 as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:v1 as CHAR) where not (u_tbl4.col4) <=> (cast(:v1 as CHAR)) and (u_tbl4.col4) in ::fkc_vals and cast(:v1 as CHAR) is not null and u_tbl3.col3 is null limit 1 for share", + "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:v1 as CHAR) where u_tbl3.col3 is null and cast(:v1 as CHAR) is not null and not (u_tbl4.col4) <=> (cast(:v1 as CHAR)) and (u_tbl4.col4) in ::fkc_vals limit 1 for share", "Table": "u_tbl3, u_tbl4" }, { @@ -1700,7 +1700,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4, u_tbl9 where 1 != 1", - "Query": "select 1 from u_tbl4, u_tbl9 where (u_tbl4.col4) in ::fkc_vals and (cast(:v1 as CHAR) is null or (u_tbl9.col9) not in ((cast(:v1 as CHAR)))) and u_tbl4.col4 = u_tbl9.col9 limit 1 for share", + "Query": "select 1 from u_tbl4, u_tbl9 where u_tbl4.col4 = u_tbl9.col9 and (u_tbl4.col4) in ::fkc_vals and (cast(:v1 as CHAR) is null or (u_tbl9.col9) not in ((cast(:v1 as CHAR)))) limit 1 for share", "Table": "u_tbl4, u_tbl9" }, { @@ -2362,7 +2362,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:fkc_upd as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:fkc_upd as CHAR) where not (u_tbl4.col4) <=> (cast(:fkc_upd as CHAR)) and (u_tbl4.col4) in ::fkc_vals and cast(:fkc_upd as CHAR) is not null and u_tbl3.col3 is null limit 1 for share", + "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:fkc_upd as CHAR) where u_tbl3.col3 is null and cast(:fkc_upd as CHAR) is not null and not (u_tbl4.col4) <=> (cast(:fkc_upd as CHAR)) and (u_tbl4.col4) in ::fkc_vals limit 1 for share", "Table": "u_tbl3, u_tbl4" }, { @@ -2374,7 +2374,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4, u_tbl9 where 1 != 1", - "Query": "select 1 from u_tbl4, u_tbl9 where (u_tbl4.col4) in ::fkc_vals and (cast(:fkc_upd as CHAR) is null or (u_tbl9.col9) not in ((cast(:fkc_upd as CHAR)))) and u_tbl4.col4 = u_tbl9.col9 limit 1 for share", + "Query": "select 1 from u_tbl4, u_tbl9 where u_tbl4.col4 = u_tbl9.col9 and (u_tbl4.col4) in ::fkc_vals and (cast(:fkc_upd as CHAR) is null or (u_tbl9.col9) not in ((cast(:fkc_upd as CHAR)))) limit 1 for share", "Table": "u_tbl4, u_tbl9" }, { @@ -2537,7 +2537,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_multicol_tbl2 left join u_multicol_tbl1 on u_multicol_tbl1.cola = 2 and u_multicol_tbl1.colb = u_multicol_tbl2.colc - 2 where 1 != 1", - "Query": "select 1 from u_multicol_tbl2 left join u_multicol_tbl1 on u_multicol_tbl1.cola = 2 and u_multicol_tbl1.colb = u_multicol_tbl2.colc - 2 where u_multicol_tbl2.colc - 2 is not null and not (u_multicol_tbl2.cola, u_multicol_tbl2.colb) <=> (2, u_multicol_tbl2.colc - 2) and u_multicol_tbl2.id = 7 and u_multicol_tbl1.cola is null and u_multicol_tbl1.colb is null limit 1 for share", + "Query": "select 1 from u_multicol_tbl2 left join u_multicol_tbl1 on u_multicol_tbl1.cola = 2 and u_multicol_tbl1.colb = u_multicol_tbl2.colc - 2 where u_multicol_tbl1.cola is null and 2 is not null and u_multicol_tbl1.colb is null and u_multicol_tbl2.colc - 2 is not null and not (u_multicol_tbl2.cola, u_multicol_tbl2.colb) <=> (2, u_multicol_tbl2.colc - 2) and u_multicol_tbl2.id = 7 limit 1 for share", "Table": "u_multicol_tbl1, u_multicol_tbl2" }, { @@ -3139,7 +3139,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl6.col6 from u_tbl6 as u, u_tbl5 as m where 1 != 1", - "Query": "select u_tbl6.col6 from u_tbl6 as u, u_tbl5 as m where u.col2 = 4 and m.col3 = 6 and u.col = m.col for update", + "Query": "select u_tbl6.col6 from u_tbl6 as u, u_tbl5 as m where u.col = m.col and u.col2 = 4 and m.col3 = 6 for update", "Table": "u_tbl5, u_tbl6" }, { @@ -3197,7 +3197,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl10.col from u_tbl10, u_tbl11 where 1 != 1", - "Query": "select u_tbl10.col from u_tbl10, u_tbl11 where u_tbl10.id = 5 and u_tbl10.id = u_tbl11.id for update", + "Query": "select u_tbl10.col from u_tbl10, u_tbl11 where u_tbl10.id = u_tbl11.id and u_tbl10.id = 5 for update", "Table": "u_tbl10, u_tbl11" }, { @@ -3479,7 +3479,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4 left join u_tbl1 on u_tbl1.col14 = cast(:__sq1 as SIGNED) where 1 != 1", - "Query": "select /*+ SET_VAR(foreign_key_checks=OFF) */ 1 from u_tbl4 left join u_tbl1 on u_tbl1.col14 = cast(:__sq1 as SIGNED) where not (u_tbl4.col41) <=> (cast(:__sq1 as SIGNED)) and u_tbl4.col4 = 3 and cast(:__sq1 as SIGNED) is not null and u_tbl1.col14 is null limit 1 lock in share mode", + "Query": "select /*+ SET_VAR(foreign_key_checks=OFF) */ 1 from u_tbl4 left join u_tbl1 on u_tbl1.col14 = cast(:__sq1 as SIGNED) where u_tbl1.col14 is null and cast(:__sq1 as SIGNED) is not null and not (u_tbl4.col41) <=> (cast(:__sq1 as SIGNED)) and u_tbl4.col4 = 3 limit 1 lock in share mode", "Table": "u_tbl1, u_tbl4" }, { diff --git a/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json b/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json index 413f3246e38..5404be4e1dc 100644 --- a/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json @@ -816,7 +816,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl2 left join u_tbl1 on u_tbl1.col1 = cast(u_tbl2.col1 + 'bar' as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl2 left join u_tbl1 on u_tbl1.col1 = cast(u_tbl2.col1 + 'bar' as CHAR) where cast(u_tbl2.col1 + 'bar' as CHAR) is not null and not (u_tbl2.col2) <=> (cast(u_tbl2.col1 + 'bar' as CHAR)) and u_tbl2.id = 1 and u_tbl1.col1 is null limit 1 for share", + "Query": "select 1 from u_tbl2 left join u_tbl1 on u_tbl1.col1 = cast(u_tbl2.col1 + 'bar' as CHAR) where u_tbl1.col1 is null and cast(u_tbl2.col1 + 'bar' as CHAR) is not null and not (u_tbl2.col2) <=> (cast(u_tbl2.col1 + 'bar' as CHAR)) and u_tbl2.id = 1 limit 1 for share", "Table": "u_tbl1, u_tbl2" }, { @@ -1523,7 +1523,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl8 left join u_tbl9 on u_tbl9.col9 = cast('foo' as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl8 left join u_tbl9 on u_tbl9.col9 = cast('foo' as CHAR) where not (u_tbl8.col8) <=> (cast('foo' as CHAR)) and (u_tbl8.col8) in ::fkc_vals and u_tbl9.col9 is null limit 1 for share nowait", + "Query": "select 1 from u_tbl8 left join u_tbl9 on u_tbl9.col9 = cast('foo' as CHAR) where u_tbl9.col9 is null and cast('foo' as CHAR) is not null and not (u_tbl8.col8) <=> (cast('foo' as CHAR)) and (u_tbl8.col8) in ::fkc_vals limit 1 for share nowait", "Table": "u_tbl8, u_tbl9" }, { @@ -1599,7 +1599,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast('foo' as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast('foo' as CHAR) where not (u_tbl4.col4) <=> (cast('foo' as CHAR)) and (u_tbl4.col4) in ::fkc_vals and u_tbl3.col3 is null limit 1 for share", + "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast('foo' as CHAR) where u_tbl3.col3 is null and cast('foo' as CHAR) is not null and not (u_tbl4.col4) <=> (cast('foo' as CHAR)) and (u_tbl4.col4) in ::fkc_vals limit 1 for share", "Table": "u_tbl3, u_tbl4" }, { @@ -1611,7 +1611,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4, u_tbl9 where 1 != 1", - "Query": "select 1 from u_tbl4, u_tbl9 where (u_tbl4.col4) in ::fkc_vals and (u_tbl9.col9) not in ((cast('foo' as CHAR))) and u_tbl4.col4 = u_tbl9.col9 limit 1 for share", + "Query": "select 1 from u_tbl4, u_tbl9 where u_tbl4.col4 = u_tbl9.col9 and (u_tbl4.col4) in ::fkc_vals and (cast('foo' as CHAR) is null or (u_tbl9.col9) not in ((cast('foo' as CHAR)))) limit 1 for share", "Table": "u_tbl4, u_tbl9" }, { @@ -1688,7 +1688,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:v1 as CHAR) where 1 != 1", - "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:v1 as CHAR) where not (u_tbl4.col4) <=> (cast(:v1 as CHAR)) and (u_tbl4.col4) in ::fkc_vals and cast(:v1 as CHAR) is not null and u_tbl3.col3 is null limit 1 for share", + "Query": "select 1 from u_tbl4 left join u_tbl3 on u_tbl3.col3 = cast(:v1 as CHAR) where u_tbl3.col3 is null and cast(:v1 as CHAR) is not null and not (u_tbl4.col4) <=> (cast(:v1 as CHAR)) and (u_tbl4.col4) in ::fkc_vals limit 1 for share", "Table": "u_tbl3, u_tbl4" }, { @@ -1700,7 +1700,7 @@ "Sharded": false }, "FieldQuery": "select 1 from u_tbl4, u_tbl9 where 1 != 1", - "Query": "select 1 from u_tbl4, u_tbl9 where (u_tbl4.col4) in ::fkc_vals and (cast(:v1 as CHAR) is null or (u_tbl9.col9) not in ((cast(:v1 as CHAR)))) and u_tbl4.col4 = u_tbl9.col9 limit 1 for share", + "Query": "select 1 from u_tbl4, u_tbl9 where u_tbl4.col4 = u_tbl9.col9 and (u_tbl4.col4) in ::fkc_vals and (cast(:v1 as CHAR) is null or (u_tbl9.col9) not in ((cast(:v1 as CHAR)))) limit 1 for share", "Table": "u_tbl4, u_tbl9" }, { diff --git a/go/vt/vtgate/planbuilder/testdata/from_cases.json b/go/vt/vtgate/planbuilder/testdata/from_cases.json index 6ec0d1ab135..044036a4590 100644 --- a/go/vt/vtgate/planbuilder/testdata/from_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/from_cases.json @@ -711,8 +711,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select m1.col from unsharded as m1 join unsharded as m2 where 1 != 1", - "Query": "select m1.col from unsharded as m1 join unsharded as m2", + "FieldQuery": "select m1.col from unsharded as m1 straight_join unsharded as m2 where 1 != 1", + "Query": "select m1.col from unsharded as m1 straight_join unsharded as m2", "Table": "unsharded" }, "TablesUsed": [ @@ -3989,8 +3989,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select A.col1 as col1, A.col2 as col2, B.col2 as col2 from unsharded_authoritative as A left join unsharded_authoritative as B on A.col1 = B.col1 where 1 != 1", - "Query": "select A.col1 as col1, A.col2 as col2, B.col2 as col2 from unsharded_authoritative as A left join unsharded_authoritative as B on A.col1 = B.col1", + "FieldQuery": "select * from unsharded_authoritative as A left join unsharded_authoritative as B using (col1) where 1 != 1", + "Query": "select * from unsharded_authoritative as A left join unsharded_authoritative as B using (col1)", "Table": "unsharded_authoritative" }, "TablesUsed": [ diff --git a/go/vt/vtgate/planbuilder/testdata/select_cases.json b/go/vt/vtgate/planbuilder/testdata/select_cases.json index 1466135dd6c..9e75a2a2f32 100644 --- a/go/vt/vtgate/planbuilder/testdata/select_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/select_cases.json @@ -1506,8 +1506,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select col1, col2 from (select col1, col2 from unsharded where 1 != 1 union select col1, col2 from unsharded where 1 != 1) as a where 1 != 1", - "Query": "select col1, col2 from (select col1, col2 from unsharded where id = 1 union select col1, col2 from unsharded where id = 3) as a", + "FieldQuery": "select * from (select col1, col2 from unsharded where 1 != 1 union select col1, col2 from unsharded where 1 != 1) as a where 1 != 1", + "Query": "select * from (select col1, col2 from unsharded where id = 1 union select col1, col2 from unsharded where id = 3) as a", "Table": "unsharded" }, "TablesUsed": [ @@ -2693,7 +2693,7 @@ "Sharded": false }, "FieldQuery": "select 1 from (select col, count(*) as a from unsharded where 1 != 1 group by col) as f left join unsharded as u on f.col = u.id where 1 != 1", - "Query": "select 1 from (select col, count(*) as a from unsharded group by col having count(*) > 0 limit 0, 12) as f left join unsharded as u on f.col = u.id", + "Query": "select 1 from (select col, count(*) as a from unsharded group by col having a > 0 limit 0, 12) as f left join unsharded as u on f.col = u.id", "Table": "unsharded" }, "TablesUsed": [ diff --git a/go/vt/vtgate/planbuilder/testdata/union_cases.json b/go/vt/vtgate/planbuilder/testdata/union_cases.json index 12a709d023f..9ac8db73be7 100644 --- a/go/vt/vtgate/planbuilder/testdata/union_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/union_cases.json @@ -874,7 +874,7 @@ "Sharded": false }, "FieldQuery": "(select 1 from unsharded where 1 != 1 union select 1 from unsharded where 1 != 1 union all select 1 from unsharded where 1 != 1) union select 1 from unsharded where 1 != 1 union all select 1 from unsharded where 1 != 1", - "Query": "(select 1 from unsharded union select 1 from unsharded union all select 1 from unsharded order by `1` asc) union select 1 from unsharded union all select 1 from unsharded order by `1` asc", + "Query": "(select 1 from unsharded union select 1 from unsharded union all select 1 from unsharded order by 1 asc) union select 1 from unsharded union all select 1 from unsharded order by 1 asc", "Table": "unsharded" }, "TablesUsed": [ diff --git a/go/vt/vtgate/semantics/analyzer.go b/go/vt/vtgate/semantics/analyzer.go index f52bd983104..cf2b3300208 100644 --- a/go/vt/vtgate/semantics/analyzer.go +++ b/go/vt/vtgate/semantics/analyzer.go @@ -28,48 +28,61 @@ import ( // analyzer controls the flow of the analysis. // It starts the tree walking and controls which part of the analysis sees which parts of the tree type analyzer struct { - scoper *scoper - tables *tableCollector - binder *binder - typer *typer - rewriter *earlyRewriter - sig QuerySignature + scoper *scoper + earlyTables *earlyTableCollector + tables *tableCollector + binder *binder + typer *typer + rewriter *earlyRewriter + sig QuerySignature + si SchemaInformation + currentDb string err error inProjection int - projErr error - unshardedErr error - warning string + projErr error + unshardedErr error + warning string + singleUnshardedKeyspace bool + fullAnalysis bool } // newAnalyzer create the semantic analyzer -func newAnalyzer(dbName string, si SchemaInformation) *analyzer { +func newAnalyzer(dbName string, si SchemaInformation, fullAnalysis bool) *analyzer { // TODO dependencies between these components are a little tangled. We should try to clean up s := newScoper() a := &analyzer{ - scoper: s, - tables: newTableCollector(s, si, dbName), - typer: newTyper(si.Environment().CollationEnv()), + scoper: s, + earlyTables: newEarlyTableCollector(si, dbName), + typer: newTyper(si.Environment().CollationEnv()), + si: si, + currentDb: dbName, + fullAnalysis: fullAnalysis, } s.org = a - a.tables.org = a + return a +} - b := newBinder(s, a, a.tables, a.typer) - a.binder = b +func (a *analyzer) lateInit() { + a.tables = a.earlyTables.newTableCollector(a.scoper, a) + a.binder = newBinder(a.scoper, a, a.tables, a.typer) + a.scoper.binder = a.binder a.rewriter = &earlyRewriter{ - env: si.Environment(), - scoper: s, - binder: b, + env: a.si.Environment(), + scoper: a.scoper, + binder: a.binder, expandedColumns: map[sqlparser.TableName][]*sqlparser.ColName{}, } - s.binder = b - return a } // Analyze analyzes the parsed query. func Analyze(statement sqlparser.Statement, currentDb string, si SchemaInformation) (*SemTable, error) { - analyzer := newAnalyzer(currentDb, newSchemaInfo(si)) + return analyseAndGetSemTable(statement, currentDb, si, false) +} + +func analyseAndGetSemTable(statement sqlparser.Statement, currentDb string, si SchemaInformation, fullAnalysis bool) (*SemTable, error) { + analyzer := newAnalyzer(currentDb, newSchemaInfo(si), fullAnalysis) // Analysis for initial scope err := analyzer.analyze(statement) @@ -83,7 +96,7 @@ func Analyze(statement sqlparser.Statement, currentDb string, si SchemaInformati // AnalyzeStrict analyzes the parsed query, and fails the analysis for any possible errors func AnalyzeStrict(statement sqlparser.Statement, currentDb string, si SchemaInformation) (*SemTable, error) { - st, err := Analyze(statement, currentDb, si) + st, err := analyseAndGetSemTable(statement, currentDb, si, true) if err != nil { return nil, err } @@ -109,6 +122,32 @@ func (a *analyzer) newSemTable( if isCommented { comments = commentedStmt.GetParsedComments() } + + if a.singleUnshardedKeyspace { + return &SemTable{ + Tables: a.earlyTables.Tables, + Comments: comments, + Warning: a.warning, + Collation: coll, + ExprTypes: map[sqlparser.Expr]evalengine.Type{}, + NotSingleRouteErr: a.projErr, + NotUnshardedErr: a.unshardedErr, + Recursive: ExprDependencies{}, + Direct: ExprDependencies{}, + Targets: map[sqlparser.IdentifierCS]TableSet{}, + ColumnEqualities: map[columnName][]sqlparser.Expr{}, + ExpandedColumns: map[sqlparser.TableName][]*sqlparser.ColName{}, + columns: map[*sqlparser.Union]sqlparser.SelectExprs{}, + comparator: nil, + StatementIDs: a.scoper.statementIDs, + QuerySignature: QuerySignature{}, + childForeignKeysInvolved: map[TableSet][]vindexes.ChildFKInfo{}, + parentForeignKeysInvolved: map[TableSet][]vindexes.ParentFKInfo{}, + childFkToUpdExprs: map[string]sqlparser.UpdateExprs{}, + collEnv: env, + }, nil + } + columns := map[*sqlparser.Union]sqlparser.SelectExprs{} for union, info := range a.tables.unionInfo { columns[union] = info.exprs @@ -298,10 +337,66 @@ func (a *analyzer) depsForExpr(expr sqlparser.Expr) (direct, recursive TableSet, } func (a *analyzer) analyze(statement sqlparser.Statement) error { + _ = sqlparser.Rewrite(statement, nil, a.earlyUp) + if a.err != nil { + return a.err + } + + if a.canShortCut(statement) { + return nil + } + + a.lateInit() + _ = sqlparser.Rewrite(statement, a.analyzeDown, a.analyzeUp) return a.err } +// canShortCut checks if we are dealing with a single unsharded keyspace and no tables that have managed foreign keys +// if so, we can stop the analyzer early +func (a *analyzer) canShortCut(statement sqlparser.Statement) (canShortCut bool) { + if a.fullAnalysis { + return false + } + ks, _ := singleUnshardedKeyspace(a.earlyTables.Tables) + if ks == nil { + return false + } + + defer func() { + a.singleUnshardedKeyspace = canShortCut + }() + + if !sqlparser.IsDMLStatement(statement) { + return true + } + + fkMode, err := a.si.ForeignKeyMode(ks.Name) + if err != nil { + a.err = err + return false + } + if fkMode != vschemapb.Keyspace_managed { + return true + } + + for _, table := range a.earlyTables.Tables { + vtbl := table.GetVindexTable() + if len(vtbl.ChildForeignKeys) > 0 || len(vtbl.ParentForeignKeys) > 0 { + return false + } + } + + return true +} + +// earlyUp collects tables in the query, so we can check +// if this a single unsharded query we are dealing with +func (a *analyzer) earlyUp(cursor *sqlparser.Cursor) bool { + a.earlyTables.up(cursor) + return true +} + func (a *analyzer) shouldContinue() bool { return a.err == nil } @@ -500,7 +595,7 @@ func (a *analyzer) getAllManagedForeignKeys() (map[TableSet][]vindexes.ChildFKIn continue } // Check whether Vitess needs to manage the foreign keys in this keyspace or not. - fkMode, err := a.tables.si.ForeignKeyMode(vi.Keyspace.Name) + fkMode, err := a.si.ForeignKeyMode(vi.Keyspace.Name) if err != nil { return nil, nil, err } @@ -508,7 +603,7 @@ func (a *analyzer) getAllManagedForeignKeys() (map[TableSet][]vindexes.ChildFKIn continue } // Cyclic foreign key constraints error is stored in the keyspace. - ksErr := a.tables.si.KeyspaceError(vi.Keyspace.Name) + ksErr := a.si.KeyspaceError(vi.Keyspace.Name) if ksErr != nil { return nil, nil, ksErr } diff --git a/go/vt/vtgate/semantics/analyzer_fk_test.go b/go/vt/vtgate/semantics/analyzer_fk_test.go index 17d1674fff8..05a5991b49f 100644 --- a/go/vt/vtgate/semantics/analyzer_fk_test.go +++ b/go/vt/vtgate/semantics/analyzer_fk_test.go @@ -147,11 +147,11 @@ func TestGetAllManagedForeignKeys(t *testing.T) { tbl["t1"], &DerivedTable{}, }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - "ks_unmanaged": vschemapb.Keyspace_unmanaged, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, + "ks_unmanaged": vschemapb.Keyspace_unmanaged, }, }, }, @@ -176,10 +176,10 @@ func TestGetAllManagedForeignKeys(t *testing.T) { tbl["t2"], tbl["t3"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, }, }, }, @@ -193,14 +193,14 @@ func TestGetAllManagedForeignKeys(t *testing.T) { tbl["t0"], tbl["t1"], &DerivedTable{}, }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - "ks_unmanaged": vschemapb.Keyspace_unmanaged, - }, - KsError: map[string]error{ - "ks": fmt.Errorf("VT09019: keyspace 'ks' has cyclic foreign keys"), - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, + "ks_unmanaged": vschemapb.Keyspace_unmanaged, + }, + KsError: map[string]error{ + "ks": fmt.Errorf("VT09019: keyspace 'ks' has cyclic foreign keys"), }, }, }, @@ -355,11 +355,11 @@ func TestGetInvolvedForeignKeys(t *testing.T) { tbl["t0"], tbl["t1"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - "ks_unmanaged": vschemapb.Keyspace_unmanaged, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, + "ks_unmanaged": vschemapb.Keyspace_unmanaged, }, }, }, @@ -394,10 +394,10 @@ func TestGetInvolvedForeignKeys(t *testing.T) { tbl["t4"], tbl["t5"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, }, }, }, @@ -438,11 +438,11 @@ func TestGetInvolvedForeignKeys(t *testing.T) { tbl["t0"], tbl["t1"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - "ks_unmanaged": vschemapb.Keyspace_unmanaged, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, + "ks_unmanaged": vschemapb.Keyspace_unmanaged, }, }, }, @@ -470,11 +470,11 @@ func TestGetInvolvedForeignKeys(t *testing.T) { tbl["t0"], tbl["t1"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - "ks_unmanaged": vschemapb.Keyspace_unmanaged, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, + "ks_unmanaged": vschemapb.Keyspace_unmanaged, }, }, }, @@ -507,11 +507,11 @@ func TestGetInvolvedForeignKeys(t *testing.T) { tbl["t6"], tbl["t1"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - "ks_unmanaged": vschemapb.Keyspace_unmanaged, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, + "ks_unmanaged": vschemapb.Keyspace_unmanaged, }, }, }, @@ -541,10 +541,10 @@ func TestGetInvolvedForeignKeys(t *testing.T) { tbl["t2"], tbl["t3"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, }, }, }, @@ -559,10 +559,10 @@ func TestGetInvolvedForeignKeys(t *testing.T) { tbl["t2"], tbl["t3"], }, - si: &FakeSI{ - KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ - "ks": vschemapb.Keyspace_managed, - }, + }, + si: &FakeSI{ + KsForeignKeyMode: map[string]vschemapb.Keyspace_ForeignKeyMode{ + "ks": vschemapb.Keyspace_managed, }, }, }, diff --git a/go/vt/vtgate/semantics/analyzer_test.go b/go/vt/vtgate/semantics/analyzer_test.go index dd8db6f5cd1..a7c173ccc96 100644 --- a/go/vt/vtgate/semantics/analyzer_test.go +++ b/go/vt/vtgate/semantics/analyzer_test.go @@ -28,7 +28,7 @@ import ( "vitess.io/vitess/go/vt/vtgate/vindexes" ) -var T0 TableSet +var NoTables TableSet var ( // Just here to make outputs more readable @@ -598,7 +598,7 @@ func TestOrderByBindingTable(t *testing.T) { TS0, }, { "select 1 as c from tabl order by c", - T0, + NoTables, }, { "select name, name from t1, t2 order by name", TS1, @@ -652,15 +652,15 @@ func TestVindexHints(t *testing.T) { sql string expectedErr string }{{ - sql: "select col from t use vindex (does_not_exist)", - expectedErr: "Vindex 'does_not_exist' does not exist in table 'ks1.t'", + sql: "select col from t1 use vindex (does_not_exist)", + expectedErr: "Vindex 'does_not_exist' does not exist in table 'ks2.t1'", }, { - sql: "select col from t ignore vindex (does_not_exist)", - expectedErr: "Vindex 'does_not_exist' does not exist in table 'ks1.t'", + sql: "select col from t1 ignore vindex (does_not_exist)", + expectedErr: "Vindex 'does_not_exist' does not exist in table 'ks2.t1'", }, { - sql: "select col from t use vindex (id_vindex)", + sql: "select id from t1 use vindex (id_vindex)", }, { - sql: "select col from t ignore vindex (id_vindex)", + sql: "select id from t1 ignore vindex (id_vindex)", }} for _, tc := range tcases { t.Run(tc.sql, func(t *testing.T) { @@ -710,7 +710,7 @@ func TestGroupByBinding(t *testing.T) { TS0, }, { "select 1 as c from tabl group by c", - T0, + NoTables, }, { "select t1.id from t1, t2 group by id", TS0, @@ -759,13 +759,13 @@ func TestHavingBinding(t *testing.T) { TS0, }, { "select col from tabl having 1 = 1", - T0, + NoTables, }, { "select col as c from tabl having c = 1", TS0, }, { "select 1 as c from tabl having c = 1", - T0, + NoTables, }, { "select t1.id from t1, t2 having id = 1", TS0, @@ -932,109 +932,6 @@ func TestUnionWithOrderBy(t *testing.T) { assert.Equal(t, TS1, d2) } -func TestScopingWDerivedTables(t *testing.T) { - queries := []struct { - query string - errorMessage string - recursiveExpectation TableSet - expectation TableSet - }{ - { - query: "select id from (select x as id from user) as t", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select id from (select foo as id from user) as t", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select id from (select foo as id from (select x as foo from user) as c) as t", - recursiveExpectation: TS0, - expectation: TS2, - }, { - query: "select t.id from (select foo as id from user) as t", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select t.id2 from (select foo as id from user) as t", - errorMessage: "column 't.id2' not found", - }, { - query: "select id from (select 42 as id) as t", - recursiveExpectation: T0, - expectation: TS1, - }, { - query: "select t.id from (select 42 as id) as t", - recursiveExpectation: T0, - expectation: TS1, - }, { - query: "select ks.t.id from (select 42 as id) as t", - errorMessage: "column 'ks.t.id' not found", - }, { - query: "select * from (select id, id from user) as t", - errorMessage: "Duplicate column name 'id'", - }, { - query: "select t.baz = 1 from (select id as baz from user) as t", - expectation: TS1, - recursiveExpectation: TS0, - }, { - query: "select t.id from (select * from user, music) as t", - expectation: TS2, - recursiveExpectation: MergeTableSets(TS0, TS1), - }, { - query: "select t.id from (select * from user, music) as t order by t.id", - expectation: TS2, - recursiveExpectation: MergeTableSets(TS0, TS1), - }, { - query: "select t.id from (select * from user) as t join user as u on t.id = u.id", - expectation: TS1, - recursiveExpectation: TS0, - }, { - query: "select t.col1 from t3 ua join (select t1.id, t1.col1 from t1 join t2) as t", - expectation: TS3, - recursiveExpectation: TS1, - }, { - query: "select uu.test from (select id from t1) uu", - errorMessage: "column 'uu.test' not found", - }, { - query: "select uu.id from (select id as col from t1) uu", - errorMessage: "column 'uu.id' not found", - }, { - query: "select uu.id from (select id as col from t1) uu", - errorMessage: "column 'uu.id' not found", - }, { - query: "select uu.id from (select id from t1) as uu where exists (select * from t2 as uu where uu.id = uu.uid)", - expectation: TS1, - recursiveExpectation: TS0, - }, { - query: "select 1 from user uu where exists (select 1 from user where exists (select 1 from (select 1 from t1) uu where uu.user_id = uu.id))", - expectation: T0, - recursiveExpectation: T0, - }} - for _, query := range queries { - t.Run(query.query, func(t *testing.T) { - parse, err := sqlparser.NewTestParser().Parse(query.query) - require.NoError(t, err) - st, err := Analyze(parse, "user", &FakeSI{ - Tables: map[string]*vindexes.Table{ - "t": {Name: sqlparser.NewIdentifierCS("t")}, - }, - }) - - switch { - case query.errorMessage != "" && err != nil: - require.EqualError(t, err, query.errorMessage) - case query.errorMessage != "": - require.EqualError(t, st.NotUnshardedErr, query.errorMessage) - default: - require.NoError(t, err) - sel := parse.(*sqlparser.Select) - assert.Equal(t, query.recursiveExpectation, st.RecursiveDeps(extract(sel, 0)), "RecursiveDeps") - assert.Equal(t, query.expectation, st.DirectDeps(extract(sel, 0)), "DirectDeps") - } - }) - } -} - func TestScopingWithWITH(t *testing.T) { queries := []struct { query string @@ -1052,7 +949,7 @@ func TestScopingWithWITH(t *testing.T) { }, { query: "with c as (select x as foo from user), t as (select foo as id from c) select id from t", recursive: TS0, - direct: TS2, + direct: TS3, }, { query: "with t as (select foo as id from user) select t.id from t", recursive: TS0, @@ -1062,11 +959,11 @@ func TestScopingWithWITH(t *testing.T) { errorMessage: "column 't.id2' not found", }, { query: "with t as (select 42 as id) select id from t", - recursive: T0, + recursive: NoTables, direct: TS1, }, { query: "with t as (select 42 as id) select t.id from t", - recursive: T0, + recursive: NoTables, direct: TS1, }, { query: "with t as (select 42 as id) select ks.t.id from t", @@ -1088,12 +985,12 @@ func TestScopingWithWITH(t *testing.T) { recursive: MergeTableSets(TS0, TS1), }, { query: "with t as (select * from user) select t.id from t join user as u on t.id = u.id", - direct: TS1, + direct: TS2, recursive: TS0, }, { query: "with t as (select t1.id, t1.col1 from t1 join t2) select t.col1 from t3 ua join t", direct: TS3, - recursive: TS1, + recursive: TS0, }, { query: "with uu as (select id from t1) select uu.test from uu", errorMessage: "column 'uu.test' not found", @@ -1105,12 +1002,12 @@ func TestScopingWithWITH(t *testing.T) { errorMessage: "column 'uu.id' not found", }, { query: "select uu.id from (select id from t1) as uu where exists (select * from t2 as uu where uu.id = uu.uid)", - direct: TS1, + direct: TS2, recursive: TS0, }, { query: "select 1 from user uu where exists (select 1 from user where exists (select 1 from (select 1 from t1) uu where uu.user_id = uu.id))", - direct: T0, - recursive: T0, + direct: NoTables, + recursive: NoTables, }} for _, query := range queries { t.Run(query.query, func(t *testing.T) { @@ -1152,15 +1049,15 @@ func TestJoinPredicateDependencies(t *testing.T) { directExpect: MergeTableSets(TS0, TS1), }, { query: "select 1 from (select * from t1) x join t2 on x.id = t2.uid", - recursiveExpect: MergeTableSets(TS0, TS2), + recursiveExpect: MergeTableSets(TS0, TS1), directExpect: MergeTableSets(TS1, TS2), }, { query: "select 1 from (select id from t1) x join t2 on x.id = t2.uid", - recursiveExpect: MergeTableSets(TS0, TS2), + recursiveExpect: MergeTableSets(TS0, TS1), directExpect: MergeTableSets(TS1, TS2), }, { query: "select 1 from (select id from t1 union select id from t) x join t2 on x.id = t2.uid", - recursiveExpect: MergeTableSets(TS0, TS1, TS3), + recursiveExpect: MergeTableSets(TS0, TS1, TS2), directExpect: MergeTableSets(TS2, TS3), }} for _, query := range queries { @@ -1179,107 +1076,6 @@ func TestJoinPredicateDependencies(t *testing.T) { } } -func TestDerivedTablesOrderClause(t *testing.T) { - queries := []struct { - query string - recursiveExpectation TableSet - expectation TableSet - }{{ - query: "select 1 from (select id from user) as t order by id", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select id from (select id from user) as t order by id", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select id from (select id from user) as t order by t.id", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select id as foo from (select id from user) as t order by foo", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select bar from (select id as bar from user) as t order by bar", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select bar as foo from (select id as bar from user) as t order by bar", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select bar as foo from (select id as bar from user) as t order by foo", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select bar as foo from (select id as bar, oo from user) as t order by oo", - recursiveExpectation: TS0, - expectation: TS1, - }, { - query: "select bar as foo from (select id, oo from user) as t(bar,oo) order by bar", - recursiveExpectation: TS0, - expectation: TS1, - }} - si := &FakeSI{Tables: map[string]*vindexes.Table{"t": {Name: sqlparser.NewIdentifierCS("t")}}} - for _, query := range queries { - t.Run(query.query, func(t *testing.T) { - parse, err := sqlparser.NewTestParser().Parse(query.query) - require.NoError(t, err) - - st, err := Analyze(parse, "user", si) - require.NoError(t, err) - - sel := parse.(*sqlparser.Select) - assert.Equal(t, query.recursiveExpectation, st.RecursiveDeps(sel.OrderBy[0].Expr), "RecursiveDeps") - assert.Equal(t, query.expectation, st.DirectDeps(sel.OrderBy[0].Expr), "DirectDeps") - - }) - } -} - -func TestScopingWComplexDerivedTables(t *testing.T) { - queries := []struct { - query string - errorMessage string - rightExpectation TableSet - leftExpectation TableSet - }{ - { - query: "select 1 from user uu where exists (select 1 from user where exists (select 1 from (select 1 from t1) uu where uu.user_id = uu.id))", - rightExpectation: TS0, - leftExpectation: TS0, - }, - { - query: "select 1 from user.user uu where exists (select 1 from user.user as uu where exists (select 1 from (select 1 from user.t1) uu where uu.user_id = uu.id))", - rightExpectation: TS1, - leftExpectation: TS1, - }, - } - for _, query := range queries { - t.Run(query.query, func(t *testing.T) { - parse, err := sqlparser.NewTestParser().Parse(query.query) - require.NoError(t, err) - st, err := Analyze(parse, "user", &FakeSI{ - Tables: map[string]*vindexes.Table{ - "t": {Name: sqlparser.NewIdentifierCS("t")}, - }, - }) - if query.errorMessage != "" { - require.EqualError(t, err, query.errorMessage) - } else { - require.NoError(t, err) - sel := parse.(*sqlparser.Select) - comparisonExpr := sel.Where.Expr.(*sqlparser.ExistsExpr).Subquery.Select.(*sqlparser.Select).Where.Expr.(*sqlparser.ExistsExpr).Subquery.Select.(*sqlparser.Select).Where.Expr.(*sqlparser.ComparisonExpr) - left := comparisonExpr.Left - right := comparisonExpr.Right - assert.Equal(t, query.leftExpectation, st.RecursiveDeps(left), "Left RecursiveDeps") - assert.Equal(t, query.rightExpectation, st.RecursiveDeps(right), "Right RecursiveDeps") - } - }) - } -} - func TestScopingWVindexTables(t *testing.T) { queries := []struct { query string @@ -1399,36 +1195,6 @@ func BenchmarkAnalyzeSubQueries(b *testing.B) { } } -func BenchmarkAnalyzeDerivedTableQueries(b *testing.B) { - queries := []string{ - "select id from (select x as id from user) as t", - "select id from (select foo as id from user) as t", - "select id from (select foo as id from (select x as foo from user) as c) as t", - "select t.id from (select foo as id from user) as t", - "select t.id2 from (select foo as id from user) as t", - "select id from (select 42 as id) as t", - "select t.id from (select 42 as id) as t", - "select ks.t.id from (select 42 as id) as t", - "select * from (select id, id from user) as t", - "select t.baz = 1 from (select id as baz from user) as t", - "select t.id from (select * from user, music) as t", - "select t.id from (select * from user, music) as t order by t.id", - "select t.id from (select * from user) as t join user as u on t.id = u.id", - "select t.col1 from t3 ua join (select t1.id, t1.col1 from t1 join t2) as t", - "select uu.id from (select id from t1) as uu where exists (select * from t2 as uu where uu.id = uu.uid)", - "select 1 from user uu where exists (select 1 from user where exists (select 1 from (select 1 from t1) uu where uu.user_id = uu.id))", - } - - for i := 0; i < b.N; i++ { - for _, query := range queries { - parse, err := sqlparser.NewTestParser().Parse(query) - require.NoError(b, err) - - _, _ = Analyze(parse, "d", fakeSchemaInfo()) - } - } -} - func BenchmarkAnalyzeHavingQueries(b *testing.B) { queries := []string{ "select col from tabl having col = 1", @@ -1521,43 +1287,30 @@ func TestSingleUnshardedKeyspace(t *testing.T) { tests := []struct { query string unsharded *vindexes.Keyspace - tables []*vindexes.Table }{ { query: "select 1 from t, t1", unsharded: nil, // both tables are unsharded, but from different keyspaces - tables: nil, }, { query: "select 1 from t2", unsharded: nil, - tables: nil, }, { query: "select 1 from t, t2", unsharded: nil, - tables: nil, }, { query: "select 1 from t as A, t as B", - unsharded: ks1, - tables: []*vindexes.Table{ - tableT(), - tableT(), - }, + unsharded: unsharded, }, { query: "insert into t select * from t", - unsharded: ks1, - tables: []*vindexes.Table{ - tableT(), - tableT(), - }, + unsharded: unsharded, }, } for _, test := range tests { t.Run(test.query, func(t *testing.T) { _, semTable := parseAndAnalyze(t, test.query, "d") - queryIsUnsharded, tables := semTable.SingleUnshardedKeyspace() + queryIsUnsharded, _ := semTable.SingleUnshardedKeyspace() assert.Equal(t, test.unsharded, queryIsUnsharded) - assert.Equal(t, test.tables, tables) }) } } @@ -1611,13 +1364,13 @@ func TestScopingSubQueryJoinClause(t *testing.T) { } -var ks1 = &vindexes.Keyspace{ - Name: "ks1", +var unsharded = &vindexes.Keyspace{ + Name: "unsharded", Sharded: false, } var ks2 = &vindexes.Keyspace{ Name: "ks2", - Sharded: false, + Sharded: true, } var ks3 = &vindexes.Keyspace{ Name: "ks3", @@ -1628,7 +1381,6 @@ var ks3 = &vindexes.Keyspace{ // create table t1(id bigint) // create table t2(uid bigint, name varchar(255)) func fakeSchemaInfo() *FakeSI { - si := &FakeSI{ Tables: map[string]*vindexes.Table{ "t": tableT(), @@ -1642,10 +1394,7 @@ func fakeSchemaInfo() *FakeSI { func tableT() *vindexes.Table { return &vindexes.Table{ Name: sqlparser.NewIdentifierCS("t"), - Keyspace: ks1, - ColumnVindexes: []*vindexes.ColumnVindex{ - {Name: "id_vindex"}, - }, + Keyspace: unsharded, } } func tableT1() *vindexes.Table { @@ -1656,7 +1405,10 @@ func tableT1() *vindexes.Table { Type: querypb.Type_INT64, }}, ColumnListAuthoritative: true, - Keyspace: ks2, + ColumnVindexes: []*vindexes.ColumnVindex{ + {Name: "id_vindex"}, + }, + Keyspace: ks2, } } func tableT2() *vindexes.Table { diff --git a/go/vt/vtgate/semantics/derived_test.go b/go/vt/vtgate/semantics/derived_test.go new file mode 100644 index 00000000000..8344fd1e261 --- /dev/null +++ b/go/vt/vtgate/semantics/derived_test.go @@ -0,0 +1,265 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package semantics + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "vitess.io/vitess/go/vt/sqlparser" + "vitess.io/vitess/go/vt/vtgate/vindexes" +) + +func TestScopingWDerivedTables(t *testing.T) { + queries := []struct { + query string + errorMessage string + recursiveDeps TableSet + directDeps TableSet + }{ + { + query: "select id from (select x as id from user) as t", + recursiveDeps: TS0, + directDeps: TS1, + }, { + query: "select id from (select foo as id from user) as t", + recursiveDeps: TS0, + directDeps: TS1, + }, { + query: "select id from (select foo as id from (select x as foo from user) as c) as t", + recursiveDeps: TS0, + directDeps: TS2, + }, { + query: "select t.id from (select foo as id from user) as t", + recursiveDeps: TS0, + directDeps: TS1, + }, { + query: "select t.id2 from (select foo as id from user) as t", + errorMessage: "column 't.id2' not found", + }, { + query: "select id from (select 42 as id) as t", + recursiveDeps: NoTables, + directDeps: TS1, + }, { + query: "select t.id from (select 42 as id) as t", + recursiveDeps: NoTables, + directDeps: TS1, + }, { + query: "select ks.t.id from (select 42 as id) as t", + errorMessage: "column 'ks.t.id' not found", + }, { + query: "select * from (select id, id from user) as t", + errorMessage: "Duplicate column name 'id'", + }, { + query: "select t.baz = 1 from (select id as baz from user) as t", + directDeps: TS1, + recursiveDeps: TS0, + }, { + query: "select t.id from (select * from user, music) as t", + directDeps: TS2, + recursiveDeps: MergeTableSets(TS0, TS1), + }, { + query: "select t.id from (select * from user, music) as t order by t.id", + directDeps: TS2, + recursiveDeps: MergeTableSets(TS0, TS1), + }, { + query: "select t.id from (select * from user) as t join user as u on t.id = u.id", + directDeps: TS2, + recursiveDeps: TS0, + }, { + query: "select t.col1 from t3 ua join (select t1.id, t1.col1 from t1 join t2) as t", + directDeps: TS3, + recursiveDeps: TS1, + }, { + query: "select uu.test from (select id from t1) uu", + errorMessage: "column 'uu.test' not found", + }, { + query: "select uu.id from (select id as col from t1) uu", + errorMessage: "column 'uu.id' not found", + }, { + query: "select uu.id from (select id as col from t1) uu", + errorMessage: "column 'uu.id' not found", + }, { + query: "select uu.id from (select id from t1) as uu where exists (select * from t2 as uu where uu.id = uu.uid)", + directDeps: TS2, + recursiveDeps: TS0, + }, { + query: "select 1 from user uu where exists (select 1 from user where exists (select 1 from (select 1 from t1) uu where uu.user_id = uu.id))", + directDeps: NoTables, + recursiveDeps: NoTables, + }, { + query: "select uu.count from (select count(*) as `count` from t1) uu", + directDeps: TS1, + recursiveDeps: TS0, + }} + for _, query := range queries { + t.Run(query.query, func(t *testing.T) { + parse, err := sqlparser.NewTestParser().Parse(query.query) + require.NoError(t, err) + st, err := Analyze(parse, "user", &FakeSI{ + Tables: map[string]*vindexes.Table{ + "t": {Name: sqlparser.NewIdentifierCS("t"), Keyspace: ks2}, + }, + }) + + switch { + case query.errorMessage != "" && err != nil: + require.EqualError(t, err, query.errorMessage) + case query.errorMessage != "": + require.EqualError(t, st.NotUnshardedErr, query.errorMessage) + default: + require.NoError(t, err) + sel := parse.(*sqlparser.Select) + assert.Equal(t, query.recursiveDeps, st.RecursiveDeps(extract(sel, 0)), "RecursiveDeps") + assert.Equal(t, query.directDeps, st.DirectDeps(extract(sel, 0)), "DirectDeps") + } + }) + } +} + +func TestDerivedTablesOrderClause(t *testing.T) { + queries := []struct { + query string + recursiveExpectation TableSet + expectation TableSet + }{{ + query: "select 1 from (select id from user) as t order by id", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select id from (select id from user) as t order by id", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select id from (select id from user) as t order by t.id", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select id as foo from (select id from user) as t order by foo", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select bar from (select id as bar from user) as t order by bar", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select bar as foo from (select id as bar from user) as t order by bar", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select bar as foo from (select id as bar from user) as t order by foo", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select bar as foo from (select id as bar, oo from user) as t order by oo", + recursiveExpectation: TS0, + expectation: TS1, + }, { + query: "select bar as foo from (select id, oo from user) as t(bar,oo) order by bar", + recursiveExpectation: TS0, + expectation: TS1, + }} + si := &FakeSI{Tables: map[string]*vindexes.Table{"t": {Name: sqlparser.NewIdentifierCS("t")}}} + for _, query := range queries { + t.Run(query.query, func(t *testing.T) { + parse, err := sqlparser.NewTestParser().Parse(query.query) + require.NoError(t, err) + + st, err := Analyze(parse, "user", si) + require.NoError(t, err) + + sel := parse.(*sqlparser.Select) + assert.Equal(t, query.recursiveExpectation, st.RecursiveDeps(sel.OrderBy[0].Expr), "RecursiveDeps") + assert.Equal(t, query.expectation, st.DirectDeps(sel.OrderBy[0].Expr), "DirectDeps") + + }) + } +} + +func TestScopingWComplexDerivedTables(t *testing.T) { + queries := []struct { + query string + errorMessage string + rightExpectation TableSet + leftExpectation TableSet + }{ + { + query: "select 1 from user uu where exists (select 1 from user where exists (select 1 from (select 1 from t1) uu where uu.user_id = uu.id))", + rightExpectation: TS0, + leftExpectation: TS0, + }, + { + query: "select 1 from user.user uu where exists (select 1 from user.user as uu where exists (select 1 from (select 1 from user.t1) uu where uu.user_id = uu.id))", + rightExpectation: TS1, + leftExpectation: TS1, + }, + } + for _, query := range queries { + t.Run(query.query, func(t *testing.T) { + parse, err := sqlparser.NewTestParser().Parse(query.query) + require.NoError(t, err) + st, err := Analyze(parse, "user", &FakeSI{ + Tables: map[string]*vindexes.Table{ + "t": {Name: sqlparser.NewIdentifierCS("t")}, + }, + }) + if query.errorMessage != "" { + require.EqualError(t, err, query.errorMessage) + } else { + require.NoError(t, err) + sel := parse.(*sqlparser.Select) + comparisonExpr := sel.Where.Expr.(*sqlparser.ExistsExpr).Subquery.Select.(*sqlparser.Select).Where.Expr.(*sqlparser.ExistsExpr).Subquery.Select.(*sqlparser.Select).Where.Expr.(*sqlparser.ComparisonExpr) + left := comparisonExpr.Left + right := comparisonExpr.Right + assert.Equal(t, query.leftExpectation, st.RecursiveDeps(left), "Left RecursiveDeps") + assert.Equal(t, query.rightExpectation, st.RecursiveDeps(right), "Right RecursiveDeps") + } + }) + } +} + +func BenchmarkAnalyzeDerivedTableQueries(b *testing.B) { + queries := []string{ + "select id from (select x as id from user) as t", + "select id from (select foo as id from user) as t", + "select id from (select foo as id from (select x as foo from user) as c) as t", + "select t.id from (select foo as id from user) as t", + "select t.id2 from (select foo as id from user) as t", + "select id from (select 42 as id) as t", + "select t.id from (select 42 as id) as t", + "select ks.t.id from (select 42 as id) as t", + "select * from (select id, id from user) as t", + "select t.baz = 1 from (select id as baz from user) as t", + "select t.id from (select * from user, music) as t", + "select t.id from (select * from user, music) as t order by t.id", + "select t.id from (select * from user) as t join user as u on t.id = u.id", + "select t.col1 from t3 ua join (select t1.id, t1.col1 from t1 join t2) as t", + "select uu.id from (select id from t1) as uu where exists (select * from t2 as uu where uu.id = uu.uid)", + "select 1 from user uu where exists (select 1 from user where exists (select 1 from (select 1 from t1) uu where uu.user_id = uu.id))", + } + + for i := 0; i < b.N; i++ { + for _, query := range queries { + parse, err := sqlparser.NewTestParser().Parse(query) + require.NoError(b, err) + + _, _ = Analyze(parse, "d", fakeSchemaInfo()) + } + } +} diff --git a/go/vt/vtgate/semantics/early_rewriter_test.go b/go/vt/vtgate/semantics/early_rewriter_test.go index 3b7b30d5f39..e681f722b1d 100644 --- a/go/vt/vtgate/semantics/early_rewriter_test.go +++ b/go/vt/vtgate/semantics/early_rewriter_test.go @@ -32,7 +32,7 @@ import ( func TestExpandStar(t *testing.T) { ks := &vindexes.Keyspace{ Name: "main", - Sharded: false, + Sharded: true, } schemaInfo := &FakeSI{ Tables: map[string]*vindexes.Table{ @@ -483,7 +483,7 @@ func TestSemTableDependenciesAfterExpandStar(t *testing.T) { func TestRewriteNot(t *testing.T) { ks := &vindexes.Keyspace{ Name: "main", - Sharded: false, + Sharded: true, } schemaInfo := &FakeSI{ Tables: map[string]*vindexes.Table{ @@ -535,7 +535,7 @@ func TestRewriteNot(t *testing.T) { func TestConstantFolding(t *testing.T) { ks := &vindexes.Keyspace{ Name: "main", - Sharded: false, + Sharded: true, } schemaInfo := &FakeSI{ Tables: map[string]*vindexes.Table{ @@ -612,13 +612,13 @@ func TestDeleteTargetTableRewrite(t *testing.T) { sql string target string }{{ - sql: "delete from t", - target: "t", - }, { - sql: "delete from t t1", + sql: "delete from t1", target: "t1", }, { - sql: "delete t2 from t t1, t t2", + sql: "delete from t1 XYZ", + target: "XYZ", + }, { + sql: "delete t2 from t1 t1, t t2", target: "t2", }, { sql: "delete t2,t1 from t t1, t t2", diff --git a/go/vt/vtgate/semantics/semantic_state.go b/go/vt/vtgate/semantics/semantic_state.go index 74bd9dd1d69..91c535ffaff 100644 --- a/go/vt/vtgate/semantics/semantic_state.go +++ b/go/vt/vtgate/semantics/semantic_state.go @@ -306,7 +306,7 @@ func (st *SemTable) ErrIfFkDependentColumnUpdated(updateExprs sqlparser.UpdateEx for _, updateExpr := range updateExprs { deps := st.RecursiveDeps(updateExpr.Name) if deps.NumberOfTables() != 1 { - panic("expected to have single table dependency") + return vterrors.VT13001("expected to have single table dependency") } // Get all the child and parent foreign keys for the given table that the update expression belongs to. childFks := st.childForeignKeysInvolved[deps] @@ -730,6 +730,10 @@ func (st *SemTable) ColumnLookup(col *sqlparser.ColName) (int, error) { // SingleUnshardedKeyspace returns the single keyspace if all tables in the query are in the same, unsharded keyspace func (st *SemTable) SingleUnshardedKeyspace() (ks *vindexes.Keyspace, tables []*vindexes.Table) { + return singleUnshardedKeyspace(st.Tables) +} + +func singleUnshardedKeyspace(tableInfos []TableInfo) (ks *vindexes.Keyspace, tables []*vindexes.Table) { validKS := func(this *vindexes.Keyspace) bool { if this == nil || this.Sharded { return false @@ -744,7 +748,7 @@ func (st *SemTable) SingleUnshardedKeyspace() (ks *vindexes.Keyspace, tables []* return true } - for _, table := range st.Tables { + for _, table := range tableInfos { if _, isDT := table.(*DerivedTable); isDT { continue } diff --git a/go/vt/vtgate/semantics/semantic_state_test.go b/go/vt/vtgate/semantics/semantic_state_test.go index 4ae0a5562b5..84f8cec6cf9 100644 --- a/go/vt/vtgate/semantics/semantic_state_test.go +++ b/go/vt/vtgate/semantics/semantic_state_test.go @@ -844,7 +844,7 @@ func TestIsFkDependentColumnUpdated(t *testing.T) { Tables: map[string]*vindexes.Table{ "t1": { Name: sqlparser.NewIdentifierCS("t1"), - Keyspace: &vindexes.Keyspace{Name: keyspaceName}, + Keyspace: &vindexes.Keyspace{Name: keyspaceName, Sharded: true}, }, }, }, diff --git a/go/vt/vtgate/semantics/table_collector.go b/go/vt/vtgate/semantics/table_collector.go index 90f939538a6..5bc160f52a6 100644 --- a/go/vt/vtgate/semantics/table_collector.go +++ b/go/vt/vtgate/semantics/table_collector.go @@ -35,15 +35,73 @@ type tableCollector struct { currentDb string org originable unionInfo map[*sqlparser.Union]unionInfo + done map[*sqlparser.AliasedTableExpr]TableInfo } -func newTableCollector(scoper *scoper, si SchemaInformation, currentDb string) *tableCollector { +type earlyTableCollector struct { + si SchemaInformation + currentDb string + Tables []TableInfo + done map[*sqlparser.AliasedTableExpr]TableInfo + withTables map[sqlparser.IdentifierCS]any +} + +func newEarlyTableCollector(si SchemaInformation, currentDb string) *earlyTableCollector { + return &earlyTableCollector{ + si: si, + currentDb: currentDb, + done: map[*sqlparser.AliasedTableExpr]TableInfo{}, + withTables: map[sqlparser.IdentifierCS]any{}, + } +} + +func (etc *earlyTableCollector) up(cursor *sqlparser.Cursor) { + switch node := cursor.Node().(type) { + case *sqlparser.AliasedTableExpr: + etc.visitAliasedTableExpr(node) + case *sqlparser.With: + for _, cte := range node.CTEs { + etc.withTables[cte.ID] = nil + } + } +} + +func (etc *earlyTableCollector) visitAliasedTableExpr(aet *sqlparser.AliasedTableExpr) { + tbl, ok := aet.Expr.(sqlparser.TableName) + if !ok { + return + } + etc.handleTableName(tbl, aet) +} + +func (etc *earlyTableCollector) newTableCollector(scoper *scoper, org originable) *tableCollector { return &tableCollector{ + Tables: etc.Tables, scoper: scoper, - si: si, - currentDb: currentDb, + si: etc.si, + currentDb: etc.currentDb, unionInfo: map[*sqlparser.Union]unionInfo{}, + done: etc.done, + org: org, + } +} + +func (etc *earlyTableCollector) handleTableName(tbl sqlparser.TableName, aet *sqlparser.AliasedTableExpr) { + if tbl.Qualifier.IsEmpty() { + _, isCTE := etc.withTables[tbl.Name] + if isCTE { + // no need to handle these tables here, we wait for the late phase instead + return + } + } + tableInfo, err := getTableInfo(aet, tbl, etc.si, etc.currentDb) + if err != nil { + // this could just be a CTE that we haven't processed, so we'll give it the benefit of the doubt for now + return } + + etc.done[aet] = tableInfo + etc.Tables = append(etc.Tables, tableInfo) } func (tc *tableCollector) up(cursor *sqlparser.Cursor) error { @@ -103,28 +161,42 @@ func (tc *tableCollector) visitAliasedTableExpr(node *sqlparser.AliasedTableExpr return nil } -func (tc *tableCollector) handleTableName(node *sqlparser.AliasedTableExpr, t sqlparser.TableName) error { +func (tc *tableCollector) handleTableName(node *sqlparser.AliasedTableExpr, t sqlparser.TableName) (err error) { + var tableInfo TableInfo + var found bool + + tableInfo, found = tc.done[node] + if !found { + tableInfo, err = getTableInfo(node, t, tc.si, tc.currentDb) + if err != nil { + return err + } + tc.Tables = append(tc.Tables, tableInfo) + } + + scope := tc.scoper.currentScope() + return scope.addTable(tableInfo) +} + +func getTableInfo(node *sqlparser.AliasedTableExpr, t sqlparser.TableName, si SchemaInformation, currentDb string) (TableInfo, error) { var tbl *vindexes.Table var vindex vindexes.Vindex isInfSchema := sqlparser.SystemSchema(t.Qualifier.String()) var err error - tbl, vindex, _, _, _, err = tc.si.FindTableOrVindex(t) + tbl, vindex, _, _, _, err = si.FindTableOrVindex(t) if err != nil && !isInfSchema { // if we are dealing with a system table, it might not be available in the vschema, but that is OK - return err + return nil, err } if tbl == nil && vindex != nil { tbl = newVindexTable(t.Name) } - scope := tc.scoper.currentScope() - tableInfo, err := tc.createTable(t, node, tbl, isInfSchema, vindex) + tableInfo, err := createTable(t, node, tbl, isInfSchema, vindex, si, currentDb) if err != nil { - return err + return nil, err } - - tc.Tables = append(tc.Tables, tableInfo) - return scope.addTable(tableInfo) + return tableInfo, nil } func (tc *tableCollector) handleDerivedTable(node *sqlparser.AliasedTableExpr, t *sqlparser.DerivedTable) error { @@ -228,12 +300,14 @@ func (tc *tableCollector) tableInfoFor(id TableSet) (TableInfo, error) { return tc.Tables[offset], nil } -func (tc *tableCollector) createTable( +func createTable( t sqlparser.TableName, alias *sqlparser.AliasedTableExpr, tbl *vindexes.Table, isInfSchema bool, vindex vindexes.Vindex, + si SchemaInformation, + currentDb string, ) (TableInfo, error) { hint := getVindexHint(alias.Hints) @@ -247,13 +321,13 @@ func (tc *tableCollector) createTable( Table: tbl, VindexHint: hint, isInfSchema: isInfSchema, - collationEnv: tc.si.Environment().CollationEnv(), + collationEnv: si.Environment().CollationEnv(), } if alias.As.IsEmpty() { dbName := t.Qualifier.String() if dbName == "" { - dbName = tc.currentDb + dbName = currentDb } table.dbName = dbName From db5aedd1e76d9ecbbdc630017e61ac1e8a5d461c Mon Sep 17 00:00:00 2001 From: Tyler Date: Wed, 14 Feb 2024 08:09:23 -0800 Subject: [PATCH 08/79] VTGate Warnings: Add `WarnUnshardedOnly` to warnings counter (#15033) Signed-off-by: Tyler Coleman --- go/vt/vtgate/executor_test.go | 4 +++- go/vt/vtgate/vcursor_impl.go | 1 + go/vt/vtgate/vtgate.go | 2 +- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/go/vt/vtgate/executor_test.go b/go/vt/vtgate/executor_test.go index 1670d64b6fc..5df4c7887f6 100644 --- a/go/vt/vtgate/executor_test.go +++ b/go/vt/vtgate/executor_test.go @@ -1216,7 +1216,7 @@ func TestExecutorDDL(t *testing.T) { "drop table t2", `create table test_partitioned ( id bigint, - date_create int, + date_create int, primary key(id) ) Engine=InnoDB /*!50100 PARTITION BY RANGE (date_create) (PARTITION p2018_06_14 VALUES LESS THAN (1528959600) ENGINE = InnoDB, @@ -2619,6 +2619,7 @@ func TestExecutorCallProc(t *testing.T) { func TestExecutorTempTable(t *testing.T) { executor, _, _, sbcUnsharded, ctx := createExecutorEnv(t) + initialWarningsCount := warnings.Counts()["WarnUnshardedOnly"] executor.warnShardedOnly = true creatQuery := "create temporary table temp_t(id bigint primary key)" session := NewSafeSession(&vtgatepb.Session{TargetString: KsTestUnsharded}) @@ -2626,6 +2627,7 @@ func TestExecutorTempTable(t *testing.T) { require.NoError(t, err) assert.EqualValues(t, 1, sbcUnsharded.ExecCount.Load()) assert.NotEmpty(t, session.Warnings) + assert.Equal(t, initialWarningsCount+1, warnings.Counts()["WarnUnshardedOnly"], "warnings count") before := executor.plans.Len() diff --git a/go/vt/vtgate/vcursor_impl.go b/go/vt/vtgate/vcursor_impl.go index 67093046ded..18508a2e94c 100644 --- a/go/vt/vtgate/vcursor_impl.go +++ b/go/vt/vtgate/vcursor_impl.go @@ -1040,6 +1040,7 @@ func (vc *vcursorImpl) WarnUnshardedOnly(format string, params ...any) { Code: uint32(sqlerror.ERNotSupportedYet), Message: fmt.Sprintf(format, params...), }) + warnings.Add("WarnUnshardedOnly", 1) } } diff --git a/go/vt/vtgate/vtgate.go b/go/vt/vtgate/vtgate.go index c8c0df217af..477a1e40cae 100644 --- a/go/vt/vtgate/vtgate.go +++ b/go/vt/vtgate/vtgate.go @@ -187,7 +187,7 @@ var ( // Error counters should be global so they can be set from anywhere errorCounts = stats.NewCountersWithMultiLabels("VtgateApiErrorCounts", "Vtgate API error counts per error type", []string{"Operation", "Keyspace", "DbType", "Code"}) - warnings = stats.NewCountersWithSingleLabel("VtGateWarnings", "Vtgate warnings", "type", "IgnoredSet", "ResultsExceeded", "WarnPayloadSizeExceeded", "NonAtomicCommit") + warnings = stats.NewCountersWithSingleLabel("VtGateWarnings", "Vtgate warnings", "type", "IgnoredSet", "NonAtomicCommit", "ResultsExceeded", "WarnPayloadSizeExceeded", "WarnUnshardedOnly") vstreamSkewDelayCount = stats.NewCounter("VStreamEventsDelayedBySkewAlignment", "Number of events that had to wait because the skew across shards was too high") From 1cdb279988e79a852623fae2cc15d4c4a9f603cc Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Wed, 14 Feb 2024 15:05:00 -0500 Subject: [PATCH 09/79] Update FOSSA license scan links (#15233) Signed-off-by: Matt Lord --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 7ccce1b29b0..adc8cd93c19 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ [![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.vitess/vitess-jdbc/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.vitess/vitess-jdbc) [![Coverage Status](https://codecov.io/gh/vitessio/vitess/branch/main/graph/badge.svg)](https://app.codecov.io/gh/vitessio/vitess/tree/main) [![Go Report Card](https://goreportcard.com/badge/vitess.io/vitess)](https://goreportcard.com/report/vitess.io/vitess) -[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fvitessio%2Fvitess.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fvitessio%2Fvitess?ref=badge_shield) +[![FOSSA Status](https://app.fossa.com/api/projects/custom%2B162%2Fvitess.svg?type=shield&issueType=license)](https://app.fossa.com/projects/custom%2B162%2Fvitess?ref=badge_shield&issueType=license) [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/1724/badge)](https://bestpractices.coreinfrastructure.org/projects/1724) # Vitess @@ -46,4 +46,4 @@ A third party security audit was performed by ADA Logics. [Read the full report] Unless otherwise noted, the Vitess source files are distributed under the Apache Version 2.0 license found in the LICENSE file. -[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fvitessio%2Fvitess.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fvitessio%2Fvitess?ref=badge_large) +[![FOSSA Status](https://app.fossa.com/api/projects/custom%2B162%2Fvitess.svg?type=large&issueType=license)](https://app.fossa.com/projects/custom%2B162%2Fvitess?ref=badge_large&issueType=license) From fa59f9d912aebaf845f1a109fc8bf047db17ca34 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Wed, 14 Feb 2024 15:12:37 -0500 Subject: [PATCH 10/79] VDiff: Add some stats (#15175) Signed-off-by: Matt Lord --- codecov.yml | 5 +- go/test/endtoend/vreplication/vdiff2_test.go | 55 ++++++++++- go/vt/vttablet/tabletmanager/vdiff/action.go | 15 ++- .../tabletmanager/vdiff/action_test.go | 11 +++ .../tabletmanager/vdiff/controller.go | 29 ++++-- go/vt/vttablet/tabletmanager/vdiff/engine.go | 27 ++++-- go/vt/vttablet/tabletmanager/vdiff/stats.go | 97 ++++++++++++++++++- .../tabletmanager/vdiff/stats_test.go | 76 +++++++++++++++ .../tabletmanager/vdiff/table_differ.go | 23 +++++ .../tabletmanager/vdiff/workflow_differ.go | 8 +- 10 files changed, 320 insertions(+), 26 deletions(-) create mode 100644 go/vt/vttablet/tabletmanager/vdiff/stats_test.go diff --git a/codecov.yml b/codecov.yml index 61232ae9197..978fc499df1 100644 --- a/codecov.yml +++ b/codecov.yml @@ -44,7 +44,10 @@ comment: # https://docs.codecov.com/docs/pull-request-comments coverage: status: # https://docs.codecov.com/docs/commit-status + patch: + default: + informational: true # Don't ever fail the codecov/patch test project: default: - informational: true # Don't ever fail the codecov/project or codecov/patch tests + informational: true # Don't ever fail the codecov/project test diff --git a/go/test/endtoend/vreplication/vdiff2_test.go b/go/test/endtoend/vreplication/vdiff2_test.go index 7f881c1f21b..08f5bb8926d 100644 --- a/go/test/endtoend/vreplication/vdiff2_test.go +++ b/go/test/endtoend/vreplication/vdiff2_test.go @@ -20,6 +20,7 @@ import ( "fmt" "math" "runtime" + "strconv" "strings" "testing" "time" @@ -31,6 +32,7 @@ import ( "google.golang.org/protobuf/encoding/protojson" "google.golang.org/protobuf/proto" + "vitess.io/vitess/go/test/endtoend/cluster" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/vttablet" @@ -56,6 +58,7 @@ type testCase struct { testCLICreateWait bool // test CLI create and wait until done against this workflow (only needs to be done once) testCLIFlagHandling bool // test vtctldclient flag handling from end-to-end extraVDiffFlags map[string]string + vdiffCount int64 // Keep track of the number of vdiffs created to test the stats } const ( @@ -119,6 +122,14 @@ var testCases = []*testCase{ }, } +func checkVDiffCountStat(t *testing.T, tablet *cluster.VttabletProcess, expectedCount int64) { + countStr, err := getDebugVar(t, tablet.Port, []string{"VDiffCount"}) + require.NoError(t, err, "failed to get VDiffCount stat from %s-%d tablet: %v", tablet.Cell, tablet.TabletUID, err) + count, err := strconv.Atoi(countStr) + require.NoError(t, err, "failed to convert VDiffCount stat string to int: %v", err) + require.Equal(t, expectedCount, int64(count), "expected VDiffCount stat to be %d but got %d", expectedCount, count) +} + func TestVDiff2(t *testing.T) { cellNames := "zone5,zone1,zone2,zone3,zone4" sourceKs := "product" @@ -172,6 +183,21 @@ func TestVDiff2(t *testing.T) { testWorkflow(t, vc, tc, tks, []*Cell{zone3, zone2, zone1}) }) } + + statsTablet := vc.getPrimaryTablet(t, targetKs, targetShards[0]) + + // We diffed X rows so confirm that the global total is > 0. + countStr, err := getDebugVar(t, statsTablet.Port, []string{"VDiffRowsComparedTotal"}) + require.NoError(t, err, "failed to get VDiffRowsComparedTotal stat from %s-%d tablet: %v", statsTablet.Cell, statsTablet.TabletUID, err) + count, err := strconv.Atoi(countStr) + require.NoError(t, err, "failed to convert VDiffRowsComparedTotal stat string to int: %v", err) + require.Greater(t, count, 0, "expected VDiffRowsComparedTotal stat to be greater than 0 but got %d", count) + + // The VDiffs should all be cleaned up so the VDiffRowsCompared value, which + // is produced from controller info, should be empty. + vdrc, err := getDebugVar(t, statsTablet.Port, []string{"VDiffRowsCompared"}) + require.NoError(t, err, "failed to get VDiffRowsCompared stat from %s-%d tablet: %v", statsTablet.Cell, statsTablet.TabletUID, err) + require.Equal(t, "{}", vdrc, "expected VDiffRowsCompared stat to be empty but got %s", vdrc) } func testWorkflow(t *testing.T, vc *VitessCluster, tc *testCase, tks *Keyspace, cells []*Cell) { @@ -183,6 +209,8 @@ func testWorkflow(t *testing.T, vc *VitessCluster, tc *testCase, tks *Keyspace, } ksWorkflow := fmt.Sprintf("%s.%s", tc.targetKs, tc.workflow) + statsShard := arrTargetShards[0] + statsTablet := vc.getPrimaryTablet(t, tc.targetKs, statsShard) var args []string args = append(args, tc.typ, "--") args = append(args, "--source", tc.sourceKs) @@ -251,9 +279,21 @@ func testWorkflow(t *testing.T, vc *VitessCluster, tc *testCase, tks *Keyspace, } // Wait for the workflow to catch up again on the deletes. waitForShardsToCatchup() + tc.vdiffCount++ // We only did vtctldclient vdiff create } else { vdiff(t, tc.targetKs, tc.workflow, allCellNames, true, true, nil) + tc.vdiffCount += 2 // We did vtctlclient AND vtctldclient vdiff create } + checkVDiffCountStat(t, statsTablet, tc.vdiffCount) + + // Confirm that the VDiffRowsCompared stat -- which is a running count of the rows + // compared by vdiff per table at the controller level -- works as expected. + vdrc, err := getDebugVar(t, statsTablet.Port, []string{"VDiffRowsCompared"}) + require.NoError(t, err, "failed to get VDiffRowsCompared stat from %s-%d tablet: %v", statsTablet.Cell, statsTablet.TabletUID, err) + uuid, jsout := performVDiff2Action(t, false, ksWorkflow, allCellNames, "show", "last", false, "--verbose") + expect := gjson.Get(jsout, fmt.Sprintf("Reports.customer.%s", statsShard)).Int() + got := gjson.Get(vdrc, fmt.Sprintf("%s.%s.%s", tc.workflow, uuid, "customer")).Int() + require.Equal(t, expect, got, "expected VDiffRowsCompared stat to be %d, but got %d", expect, got) if tc.autoRetryError { testAutoRetryError(t, tc, allCellNames) @@ -263,26 +303,37 @@ func testWorkflow(t *testing.T, vc *VitessCluster, tc *testCase, tks *Keyspace, testResume(t, tc, allCellNames) } + checkVDiffCountStat(t, statsTablet, tc.vdiffCount) + // These are done here so that we have a valid workflow to test the commands against. if tc.stop { testStop(t, ksWorkflow, allCellNames) + tc.vdiffCount++ // We did either vtctlclient OR vtctldclient vdiff create } if tc.testCLICreateWait { testCLICreateWait(t, ksWorkflow, allCellNames) + tc.vdiffCount++ // We did either vtctlclient OR vtctldclient vdiff create } if tc.testCLIErrors { testCLIErrors(t, ksWorkflow, allCellNames) } if tc.testCLIFlagHandling { testCLIFlagHandling(t, tc.targetKs, tc.workflow, cells[0]) + tc.vdiffCount++ // We did either vtctlclient OR vtctldclient vdiff create } + checkVDiffCountStat(t, statsTablet, tc.vdiffCount) + testDelete(t, ksWorkflow, allCellNames) + tc.vdiffCount = 0 // All vdiffs are deleted, so reset the count and check + checkVDiffCountStat(t, statsTablet, tc.vdiffCount) // Create another VDiff record to confirm it gets deleted when the workflow is completed. ts := time.Now() - uuid, _ := performVDiff2Action(t, false, ksWorkflow, allCellNames, "create", "", false) + uuid, _ = performVDiff2Action(t, false, ksWorkflow, allCellNames, "create", "", false) waitForVDiff2ToComplete(t, false, ksWorkflow, allCellNames, uuid, ts) + tc.vdiffCount++ + checkVDiffCountStat(t, statsTablet, tc.vdiffCount) err = vc.VtctlClient.ExecuteCommand(tc.typ, "--", "SwitchTraffic", ksWorkflow) require.NoError(t, err) @@ -291,6 +342,8 @@ func testWorkflow(t *testing.T, vc *VitessCluster, tc *testCase, tks *Keyspace, // Confirm the VDiff data is deleted for the workflow. testNoOrphanedData(t, tc.targetKs, tc.workflow, arrTargetShards) + tc.vdiffCount = 0 // All vdiffs are deleted, so reset the count and check + checkVDiffCountStat(t, statsTablet, tc.vdiffCount) } func testCLIErrors(t *testing.T, ksWorkflow, cells string) { diff --git a/go/vt/vttablet/tabletmanager/vdiff/action.go b/go/vt/vttablet/tabletmanager/vdiff/action.go index ded232bf3c7..0b9dd6f45ed 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/action.go +++ b/go/vt/vttablet/tabletmanager/vdiff/action.go @@ -63,7 +63,15 @@ var ( } ) -func (vde *Engine) PerformVDiffAction(ctx context.Context, req *tabletmanagerdatapb.VDiffRequest) (*tabletmanagerdatapb.VDiffResponse, error) { +func (vde *Engine) PerformVDiffAction(ctx context.Context, req *tabletmanagerdatapb.VDiffRequest) (resp *tabletmanagerdatapb.VDiffResponse, err error) { + defer func() { + if err != nil { + globalStats.ErrorCount.Add(1) + } + }() + if req == nil { + return nil, vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "nil vdiff request") + } if !vde.isOpen { return nil, vterrors.New(vtrpcpb.Code_UNAVAILABLE, "vdiff engine is closed") } @@ -71,7 +79,7 @@ func (vde *Engine) PerformVDiffAction(ctx context.Context, req *tabletmanagerdat return nil, vterrors.New(vtrpcpb.Code_UNAVAILABLE, "vdiff engine is still trying to open") } - resp := &tabletmanagerdatapb.VDiffResponse{ + resp = &tabletmanagerdatapb.VDiffResponse{ Id: 0, Output: nil, } @@ -368,6 +376,9 @@ func (vde *Engine) handleDeleteAction(ctx context.Context, dbClient binlogplayer } controller.Stop() delete(vde.controllers, controller.id) + globalStats.mu.Lock() + defer globalStats.mu.Unlock() + delete(globalStats.controllers, controller.id) } switch req.ActionArg { diff --git a/go/vt/vttablet/tabletmanager/vdiff/action_test.go b/go/vt/vttablet/tabletmanager/vdiff/action_test.go index 1049bc8607d..4676238cf69 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/action_test.go +++ b/go/vt/vttablet/tabletmanager/vdiff/action_test.go @@ -56,8 +56,13 @@ func TestPerformVDiffAction(t *testing.T) { expectQueries []queryAndResult wantErr error }{ + { + name: "nil request", + wantErr: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "nil vdiff request"), + }, { name: "engine not open", + req: &tabletmanagerdatapb.VDiffRequest{}, vde: &Engine{isOpen: false}, wantErr: vterrors.New(vtrpcpb.Code_UNAVAILABLE, "vdiff engine is closed"), }, @@ -208,6 +213,7 @@ func TestPerformVDiffAction(t *testing.T) { }, }, } + errCount := int64(0) for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if tt.preFunc != nil { @@ -224,6 +230,9 @@ func TestPerformVDiffAction(t *testing.T) { vdiffenv.dbClient.ExpectRequest(queryResult.query, queryResult.result, nil) } got, err := tt.vde.PerformVDiffAction(ctx, tt.req) + if err != nil { + errCount++ + } vdiffenv.dbClient.Wait() if tt.wantErr != nil && !vterrors.Equals(err, tt.wantErr) { t.Errorf("Engine.PerformVDiffAction() error = %v, wantErr %v", err, tt.wantErr) @@ -239,6 +248,8 @@ func TestPerformVDiffAction(t *testing.T) { // No VDiffs should be running anymore. require.Equal(t, 0, len(vdiffenv.vde.controllers), "expected no controllers to be running, but found %d", len(vdiffenv.vde.controllers)) + require.Equal(t, int64(0), globalStats.numControllers(), "expected no controllers, but found %d") }) + require.Equal(t, errCount, globalStats.ErrorCount.Get(), "expected error count %d, got %d", errCount, globalStats.ErrorCount.Get()) } } diff --git a/go/vt/vttablet/tabletmanager/vdiff/controller.go b/go/vt/vttablet/tabletmanager/vdiff/controller.go index 1c50c0597ef..0265e8a0a35 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/controller.go +++ b/go/vt/vttablet/tabletmanager/vdiff/controller.go @@ -27,6 +27,7 @@ import ( "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/sqltypes" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/binlog/binlogplayer" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/proto/tabletmanagerdata" @@ -75,6 +76,11 @@ type controller struct { sourceTimeZone, targetTimeZone string // Named time zones if conversions are necessary for datetime values externalCluster string // For Mount+Migrate + + // Information used in vdiff stats/metrics. + Errors *stats.CountersWithMultiLabels + TableDiffRowCounts *stats.CountersWithMultiLabels + TableDiffPhaseTimings *stats.Timings } func newController(ctx context.Context, row sqltypes.RowNamedValues, dbClientFactory func() binlogplayer.DBClient, @@ -84,16 +90,19 @@ func newController(ctx context.Context, row sqltypes.RowNamedValues, dbClientFac id, _ := row["id"].ToInt64() ct := &controller{ - id: id, - uuid: row["vdiff_uuid"].ToString(), - workflow: row["workflow"].ToString(), - dbClientFactory: dbClientFactory, - ts: ts, - vde: vde, - done: make(chan struct{}), - tmc: vde.tmClientFactory(), - sources: make(map[string]*migrationSource), - options: options, + id: id, + uuid: row["vdiff_uuid"].ToString(), + workflow: row["workflow"].ToString(), + dbClientFactory: dbClientFactory, + ts: ts, + vde: vde, + done: make(chan struct{}), + tmc: vde.tmClientFactory(), + sources: make(map[string]*migrationSource), + options: options, + Errors: stats.NewCountersWithMultiLabels("", "", []string{"Error"}), + TableDiffRowCounts: stats.NewCountersWithMultiLabels("", "", []string{"Rows"}), + TableDiffPhaseTimings: stats.NewTimings("", "", "", "TablePhase"), } ctx, ct.cancel = context.WithCancel(ctx) go ct.run(ctx) diff --git a/go/vt/vttablet/tabletmanager/vdiff/engine.go b/go/vt/vttablet/tabletmanager/vdiff/engine.go index 16e8a89d90e..b2285a070fa 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/engine.go +++ b/go/vt/vttablet/tabletmanager/vdiff/engine.go @@ -26,17 +26,16 @@ import ( "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/mysql/sqlerror" - "vitess.io/vitess/go/vt/proto/tabletmanagerdata" - "vitess.io/vitess/go/vt/proto/topodata" - "vitess.io/vitess/go/vt/sqlparser" - "vitess.io/vitess/go/vt/vttablet/tabletmanager/vreplication" - "vitess.io/vitess/go/vt/vttablet/tmclient" - "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/binlog/binlogplayer" "vitess.io/vitess/go/vt/dbconfigs" "vitess.io/vitess/go/vt/log" + "vitess.io/vitess/go/vt/proto/tabletmanagerdata" + "vitess.io/vitess/go/vt/proto/topodata" + "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/topo" + "vitess.io/vitess/go/vt/vttablet/tabletmanager/vreplication" + "vitess.io/vitess/go/vt/vttablet/tmclient" ) type Engine struct { @@ -159,6 +158,7 @@ func (vde *Engine) openLocked(ctx context.Context) error { if err := vde.initControllers(rows); err != nil { return err } + vde.updateStats() // At this point we've fully and successfully opened so begin // retrying error'd VDiffs until the engine is closed. @@ -218,6 +218,9 @@ func (vde *Engine) addController(row sqltypes.RowNamedValues, options *tabletman row, vde.thisTablet.Alias) } vde.controllers[ct.id] = ct + globalStats.mu.Lock() + defer globalStats.mu.Unlock() + globalStats.controllers[ct.id] = ct return nil } @@ -392,4 +395,16 @@ func (vde *Engine) resetControllers() { ct.Stop() } vde.controllers = make(map[int64]*controller) + vde.updateStats() +} + +// updateStats must only be called while holding the engine lock. +func (vre *Engine) updateStats() { + globalStats.mu.Lock() + defer globalStats.mu.Unlock() + + globalStats.controllers = make(map[int64]*controller, len(vre.controllers)) + for id, ct := range vre.controllers { + globalStats.controllers[id] = ct + } } diff --git a/go/vt/vttablet/tabletmanager/vdiff/stats.go b/go/vt/vttablet/tabletmanager/vdiff/stats.go index 3d984366bc9..b68e1f86556 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/stats.go +++ b/go/vt/vttablet/tabletmanager/vdiff/stats.go @@ -17,6 +17,7 @@ limitations under the License. package vdiff import ( + "fmt" "sync" "vitess.io/vitess/go/stats" @@ -34,21 +35,40 @@ func init() { // vdiffStats exports the stats for Engine. It's a separate structure to // prevent potential deadlocks with the mutex in Engine. type vdiffStats struct { - mu sync.Mutex + mu sync.Mutex + controllers map[int64]*controller + Count *stats.Gauge + ErrorCount *stats.Counter RestartedTableDiffs *stats.CountersWithSingleLabel + RowsDiffedCount *stats.Counter } -func (st *vdiffStats) register() { +func (vds *vdiffStats) register() { + globalStats.Count = stats.NewGauge("", "") + globalStats.ErrorCount = stats.NewCounter("", "") globalStats.RestartedTableDiffs = stats.NewCountersWithSingleLabel("", "", "Table", "") + globalStats.RowsDiffedCount = stats.NewCounter("", "") + + stats.NewGaugeFunc("VDiffCount", "Number of current vdiffs", vds.numControllers) + + stats.NewCounterFunc( + "VDiffErrorCountTotal", + "Number of errors encountered across all vdiff actions", + func() int64 { + vds.mu.Lock() + defer vds.mu.Unlock() + return globalStats.ErrorCount.Get() + }, + ) stats.NewGaugesFuncWithMultiLabels( "VDiffRestartedTableDiffsCount", - "vdiff table diffs restarted due to max-diff-duration counts per table", + "Table diffs restarted due to --max-diff-duration counts by table", []string{"table_name"}, func() map[string]int64 { - st.mu.Lock() - defer st.mu.Unlock() + vds.mu.Lock() + defer vds.mu.Unlock() result := make(map[string]int64) for label, count := range globalStats.RestartedTableDiffs.Counts() { if label == "" { @@ -59,4 +79,71 @@ func (st *vdiffStats) register() { return result }, ) + + stats.NewCounterFunc( + "VDiffRowsComparedTotal", + "Number of rows compared across all vdiffs", + func() int64 { + vds.mu.Lock() + defer vds.mu.Unlock() + return globalStats.RowsDiffedCount.Get() + }, + ) + + stats.NewGaugesFuncWithMultiLabels( + "VDiffRowsCompared", + "Live number of rows compared per vdiff by table", + []string{"workflow", "uuid", "table"}, + func() map[string]int64 { + vds.mu.Lock() + defer vds.mu.Unlock() + result := make(map[string]int64, len(vds.controllers)) + for _, ct := range vds.controllers { + for key, val := range ct.TableDiffRowCounts.Counts() { + result[fmt.Sprintf("%s.%s.%s", ct.workflow, ct.uuid, key)] = val + } + } + return result + }, + ) + + stats.NewCountersFuncWithMultiLabels( + "VDiffErrors", + "Count of specific errors seen during the lifetime of a vdiff", + []string{"workflow", "uuid", "error"}, + func() map[string]int64 { + vds.mu.Lock() + defer vds.mu.Unlock() + result := make(map[string]int64, len(vds.controllers)) + for _, ct := range vds.controllers { + for key, val := range ct.Errors.Counts() { + result[fmt.Sprintf("%s.%s.%s", ct.workflow, ct.uuid, key)] = val + } + } + return result + }, + ) + + stats.NewGaugesFuncWithMultiLabels( + "VDiffPhaseTimings", + "VDiff phase timings", + []string{"workflow", "uuid", "table", "phase"}, + func() map[string]int64 { + vds.mu.Lock() + defer vds.mu.Unlock() + result := make(map[string]int64, len(vds.controllers)) + for _, ct := range vds.controllers { + for tablePhase, h := range ct.TableDiffPhaseTimings.Histograms() { + result[fmt.Sprintf("%s.%s.%s", ct.workflow, ct.uuid, tablePhase)] = h.Total() + } + } + return result + }, + ) +} + +func (vds *vdiffStats) numControllers() int64 { + vds.mu.Lock() + defer vds.mu.Unlock() + return int64(len(vds.controllers)) } diff --git a/go/vt/vttablet/tabletmanager/vdiff/stats_test.go b/go/vt/vttablet/tabletmanager/vdiff/stats_test.go new file mode 100644 index 00000000000..8b1a174466f --- /dev/null +++ b/go/vt/vttablet/tabletmanager/vdiff/stats_test.go @@ -0,0 +1,76 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package vdiff + +import ( + "testing" + "time" + + "github.com/google/uuid" + "github.com/stretchr/testify/require" + + "vitess.io/vitess/go/stats" + + binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" +) + +func TestVDiffStats(t *testing.T) { + testStats := &vdiffStats{ + ErrorCount: stats.NewCounter("", ""), + RestartedTableDiffs: stats.NewCountersWithSingleLabel("", "", "Table", ""), + RowsDiffedCount: stats.NewCounter("", ""), + } + id := int64(1) + testStats.controllers = map[int64]*controller{ + id: { + id: id, + workflow: "testwf", + workflowType: binlogdatapb.VReplicationWorkflowType_MoveTables, + uuid: uuid.New().String(), + Errors: stats.NewCountersWithMultiLabels("", "", []string{"Error"}), + TableDiffRowCounts: stats.NewCountersWithMultiLabels("", "", []string{"Rows"}), + TableDiffPhaseTimings: stats.NewTimings("", "", "", "TablePhase"), + }, + } + + require.Equal(t, int64(1), testStats.numControllers()) + + sleepTime := 1 * time.Millisecond + record := func(phase string) { + defer testStats.controllers[id].TableDiffPhaseTimings.Record(phase, time.Now()) + time.Sleep(sleepTime) + } + want := int64(1.2 * float64(sleepTime)) // Allow 20% overhead for recording timing + record(string(initializing)) + require.Greater(t, want, testStats.controllers[id].TableDiffPhaseTimings.Histograms()[string(initializing)].Total()) + record(string(pickingTablets)) + require.Greater(t, want, testStats.controllers[id].TableDiffPhaseTimings.Histograms()[string(pickingTablets)].Total()) + record(string(diffingTable)) + require.Greater(t, want, testStats.controllers[id].TableDiffPhaseTimings.Histograms()[string(diffingTable)].Total()) + + testStats.ErrorCount.Set(11) + require.Equal(t, int64(11), testStats.ErrorCount.Get()) + + testStats.controllers[id].Errors.Add([]string{"test error"}, int64(12)) + require.Equal(t, int64(12), testStats.controllers[id].Errors.Counts()["test error"]) + + testStats.RestartedTableDiffs.Add("t1", int64(5)) + require.Equal(t, int64(5), testStats.RestartedTableDiffs.Counts()["t1"]) + + testStats.RowsDiffedCount.Add(512) + require.Equal(t, int64(512), testStats.RowsDiffedCount.Get()) +} diff --git a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go index b3634e37ab5..7ad83a3ad4b 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go +++ b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go @@ -49,6 +49,19 @@ import ( vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) +type tableDiffPhase string + +const ( + initializing = tableDiffPhase("initializing") + pickingTablets = tableDiffPhase("picking_streaming_tablets") + syncingSources = tableDiffPhase("syncing_source_streams") + syncingTargets = tableDiffPhase("syncing_target_streams") + startingSources = tableDiffPhase("starting_source_data_streams") + startingTargets = tableDiffPhase("starting_target_data_streams") + restartingVreplication = tableDiffPhase("restarting_vreplication_streams") + diffingTable = tableDiffPhase("diffing_table") +) + // how long to wait for background operations to complete var BackgroundOperationTimeout = topo.RemoteOperationTimeout * 4 @@ -90,6 +103,7 @@ func newTableDiffer(wd *workflowDiffer, table *tabletmanagerdatapb.TableDefiniti // initialize func (td *tableDiffer) initialize(ctx context.Context) error { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, initializing), time.Now()) vdiffEngine := td.wd.ct.vde vdiffEngine.snapshotMu.Lock() defer vdiffEngine.snapshotMu.Unlock() @@ -212,6 +226,7 @@ func (td *tableDiffer) forEachSource(cb func(source *migrationSource) error) err } func (td *tableDiffer) selectTablets(ctx context.Context) error { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, pickingTablets), time.Now()) var ( wg sync.WaitGroup sourceErr, targetErr error @@ -287,6 +302,7 @@ func (td *tableDiffer) pickTablet(ctx context.Context, ts *topo.Server, cells [] } func (td *tableDiffer) syncSourceStreams(ctx context.Context) error { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, syncingSources), time.Now()) // source can be replica, wait for them to at least reach max gtid of all target streams ct := td.wd.ct waitCtx, cancel := context.WithTimeout(ctx, time.Duration(ct.options.CoreOptions.TimeoutSeconds*int64(time.Second))) @@ -305,6 +321,7 @@ func (td *tableDiffer) syncSourceStreams(ctx context.Context) error { } func (td *tableDiffer) syncTargetStreams(ctx context.Context) error { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, syncingTargets), time.Now()) ct := td.wd.ct waitCtx, cancel := context.WithTimeout(ctx, time.Duration(ct.options.CoreOptions.TimeoutSeconds*int64(time.Second))) defer cancel() @@ -327,6 +344,7 @@ func (td *tableDiffer) syncTargetStreams(ctx context.Context) error { } func (td *tableDiffer) startTargetDataStream(ctx context.Context) error { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, startingTargets), time.Now()) ct := td.wd.ct gtidch := make(chan string, 1) ct.targetShardStreamer.result = make(chan *sqltypes.Result, 1) @@ -341,6 +359,7 @@ func (td *tableDiffer) startTargetDataStream(ctx context.Context) error { } func (td *tableDiffer) startSourceDataStreams(ctx context.Context) error { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, startingSources), time.Now()) if err := td.forEachSource(func(source *migrationSource) error { gtidch := make(chan string, 1) source.result = make(chan *sqltypes.Result, 1) @@ -359,6 +378,7 @@ func (td *tableDiffer) startSourceDataStreams(ctx context.Context) error { } func (td *tableDiffer) restartTargetVReplicationStreams(ctx context.Context) error { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, restartingVreplication), time.Now()) ct := td.wd.ct query := fmt.Sprintf("update _vt.vreplication set state='Running', message='', stop_pos='' where db_name=%s and workflow=%s", encodeString(ct.vde.dbName), encodeString(ct.workflow)) @@ -467,6 +487,7 @@ func (td *tableDiffer) setupRowSorters() { } func (td *tableDiffer) diff(ctx context.Context, rowsToCompare int64, debug, onlyPks bool, maxExtraRowsToCompare int64, maxReportSampleRows int64, stop <-chan time.Time) (*DiffReport, error) { + defer td.wd.ct.TableDiffPhaseTimings.Record(fmt.Sprintf("%s.%s", td.table.Name, diffingTable), time.Now()) dbClient := td.wd.ct.dbClientFactory() if err := dbClient.Connect(); err != nil { return nil, err @@ -515,6 +536,7 @@ func (td *tableDiffer) diff(ctx context.Context, rowsToCompare int64, debug, onl if err := td.updateTableProgress(dbClient, dr, lastProcessedRow); err != nil { log.Errorf("Failed to update vdiff progress on %s table: %v", td.table.Name, err) } + globalStats.RowsDiffedCount.Add(dr.ProcessedRows) }() for { @@ -741,6 +763,7 @@ func (td *tableDiffer) updateTableProgress(dbClient binlogplayer.DBClient, dr *D if _, err := dbClient.ExecuteFetch(query, 1); err != nil { return err } + td.wd.ct.TableDiffRowCounts.Add([]string{td.table.Name}, dr.ProcessedRows) return nil } diff --git a/go/vt/vttablet/tabletmanager/vdiff/workflow_differ.go b/go/vt/vttablet/tabletmanager/vdiff/workflow_differ.go index f477e88406e..97d2bd387cb 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/workflow_differ.go +++ b/go/vt/vttablet/tabletmanager/vdiff/workflow_differ.go @@ -235,7 +235,13 @@ func (wd *workflowDiffer) diffTable(ctx context.Context, dbClient binlogplayer.D return nil } -func (wd *workflowDiffer) diff(ctx context.Context) error { +func (wd *workflowDiffer) diff(ctx context.Context) (err error) { + defer func() { + if err != nil { + globalStats.ErrorCount.Add(1) + wd.ct.Errors.Add([]string{err.Error()}, 1) + } + }() dbClient := wd.ct.dbClientFactory() if err := dbClient.Connect(); err != nil { return err From 4b100ea3613bd0490c3715509de99187f783043a Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Wed, 14 Feb 2024 17:28:51 -0500 Subject: [PATCH 11/79] go1.22: remove outdated loopclosure captures in tests (#15227) Signed-off-by: Andrew Mason --- go/vt/vtctl/grpcvtctldserver/query_test.go | 16 ++++++++-------- go/vt/vtctl/grpcvtctldserver/server_test.go | 19 +++++++++++-------- .../tabletserver/tabletenv/config_test.go | 1 - 3 files changed, 19 insertions(+), 17 deletions(-) diff --git a/go/vt/vtctl/grpcvtctldserver/query_test.go b/go/vt/vtctl/grpcvtctldserver/query_test.go index 6073d3bc395..b9299592c15 100644 --- a/go/vt/vtctl/grpcvtctldserver/query_test.go +++ b/go/vt/vtctl/grpcvtctldserver/query_test.go @@ -25,12 +25,11 @@ import ( "vitess.io/vitess/go/protoutil" "vitess.io/vitess/go/sqltypes" - "vitess.io/vitess/go/vt/vtctl/schematools" - "vitess.io/vitess/go/test/utils" + "vitess.io/vitess/go/vt/vtctl/schematools" vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata" - "vitess.io/vitess/go/vt/proto/vttime" + vttimepb "vitess.io/vitess/go/vt/proto/vttime" ) var now = time.Now() @@ -86,7 +85,6 @@ func TestRowToSchemaMigration(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { out, err := rowToSchemaMigration(test.row) if test.shouldErr { @@ -110,7 +108,7 @@ func TestValueToVTTime(t *testing.T) { tests := []struct { name string value string - expected *vttime.Time + expected *vttimepb.Time shouldErr bool }{ { @@ -130,7 +128,6 @@ func TestValueToVTTime(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { t.Parallel() @@ -153,7 +150,7 @@ func TestValueToVTDuration(t *testing.T) { name string value string defaultUnit string - expected *vttime.Duration + expected *vttimepb.Duration shouldErr bool }{ { @@ -182,7 +179,6 @@ func TestValueToVTDuration(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { out, err := valueToVTDuration(test.value, test.defaultUnit) if test.shouldErr { @@ -197,6 +193,8 @@ func TestValueToVTDuration(t *testing.T) { } func TestAlterSchemaMigrationQuery(t *testing.T) { + t.Parallel() + uuid := "4e5dcf80_354b_11eb_82cd_f875a4d24e90" tcases := []struct { @@ -228,6 +226,8 @@ func TestAlterSchemaMigrationQuery(t *testing.T) { for _, tcase := range tcases { testName := fmt.Sprintf("%s %s", tcase.command, tcase.uuid) t.Run(testName, func(t *testing.T) { + t.Parallel() + query, err := alterSchemaMigrationQuery(tcase.command, tcase.uuid) assert.NoError(t, err) assert.Equal(t, tcase.expect, query) diff --git a/go/vt/vtctl/grpcvtctldserver/server_test.go b/go/vt/vtctl/grpcvtctldserver/server_test.go index c21e49eab26..ed6ee6aca1f 100644 --- a/go/vt/vtctl/grpcvtctldserver/server_test.go +++ b/go/vt/vtctl/grpcvtctldserver/server_test.go @@ -1426,8 +1426,8 @@ func TestCancelSchemaMigration(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { + t.Parallel() ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -1930,6 +1930,8 @@ func TestCleanupSchemaMigration(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { + t.Parallel() + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ts := memorytopo.NewServer(ctx, "zone1") @@ -2132,6 +2134,8 @@ func TestForceCutOverSchemaMigration(t *testing.T) { for _, test := range tests { t.Run(test.name, func(t *testing.T) { + t.Parallel() + ctx, cancel := context.WithCancel(context.Background()) defer cancel() ts := memorytopo.NewServer(ctx, "zone1") @@ -2333,11 +2337,11 @@ func TestCompleteSchemaMigration(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { + t.Parallel() - ctx, Complete := context.WithCancel(context.Background()) - defer Complete() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() ts := memorytopo.NewServer(ctx, "zone1") testutil.AddTablets(ctx, t, ts, &testutil.AddTabletOptions{ @@ -5998,7 +6002,6 @@ func TestGetSchemaMigrations(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { t.Parallel() @@ -7664,11 +7667,11 @@ func TestLaunchSchemaMigration(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { + t.Parallel() - ctx, Launch := context.WithCancel(context.Background()) - defer Launch() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() ts := memorytopo.NewServer(ctx, "zone1") testutil.AddTablets(ctx, t, ts, &testutil.AddTabletOptions{ diff --git a/go/vt/vttablet/tabletserver/tabletenv/config_test.go b/go/vt/vttablet/tabletserver/tabletenv/config_test.go index 1cf1559ba6e..c6f65cb94cb 100644 --- a/go/vt/vttablet/tabletserver/tabletenv/config_test.go +++ b/go/vt/vttablet/tabletserver/tabletenv/config_test.go @@ -424,7 +424,6 @@ func TestVerifyTxThrottlerConfig(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.Name, func(t *testing.T) { t.Parallel() From af1d6d6f47e6aee230d2662dbffcf98c813952af Mon Sep 17 00:00:00 2001 From: Florent Poinsard <35779988+frouioui@users.noreply.github.com> Date: Wed, 14 Feb 2024 16:33:46 -0600 Subject: [PATCH 12/79] use proper mysql version in the `vttestserver` images (#15235) Signed-off-by: Florent Poinsard --- docker/vttestserver/Dockerfile.mysql57 | 2 +- docker/vttestserver/Dockerfile.mysql80 | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docker/vttestserver/Dockerfile.mysql57 b/docker/vttestserver/Dockerfile.mysql57 index 824b4cc49b4..a4485cdb56b 100644 --- a/docker/vttestserver/Dockerfile.mysql57 +++ b/docker/vttestserver/Dockerfile.mysql57 @@ -58,4 +58,4 @@ USER vitess COPY docker/vttestserver/setup_vschema_folder.sh /vt/setup_vschema_folder.sh COPY docker/vttestserver/run.sh /vt/run.sh -CMD /vt/run.sh "5.7.9-vitess" +CMD /vt/run.sh "5.7.31-vitess" diff --git a/docker/vttestserver/Dockerfile.mysql80 b/docker/vttestserver/Dockerfile.mysql80 index 0437af6b445..229cef16e51 100644 --- a/docker/vttestserver/Dockerfile.mysql80 +++ b/docker/vttestserver/Dockerfile.mysql80 @@ -58,4 +58,4 @@ USER vitess COPY docker/vttestserver/setup_vschema_folder.sh /vt/setup_vschema_folder.sh COPY docker/vttestserver/run.sh /vt/run.sh -CMD /vt/run.sh "8.0.21-vitess" +CMD /vt/run.sh "8.0.30-Vitess" From 09c3d56027287193cb0248c764e1504c1cda845c Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Thu, 15 Feb 2024 07:43:53 +0200 Subject: [PATCH 13/79] New unified internal table names format: part 2, generating new names (#15178) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- .../tabletmanager/tablegc/tablegc_test.go | 6 +- go/vt/schema/name.go | 56 ++++++++++++- go/vt/schema/name_test.go | 54 +++++++++++- go/vt/schema/online_ddl_test.go | 2 +- go/vt/schema/tablegc.go | 82 ++++++++----------- go/vt/schema/tablegc_test.go | 29 +++++-- go/vt/vttablet/onlineddl/executor.go | 9 +- go/vt/vttablet/onlineddl/util.go | 19 ----- go/vt/vttablet/onlineddl/util_test.go | 9 -- .../tabletmanager/vreplication/vreplicator.go | 2 +- 10 files changed, 177 insertions(+), 91 deletions(-) diff --git a/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go b/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go index 028d9788e5e..685c361cef7 100644 --- a/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go +++ b/go/test/endtoend/tabletmanager/tablegc/tablegc_test.go @@ -321,9 +321,9 @@ func TestPopulateTable(t *testing.T) { func generateRenameStatement(newFormat bool, fromTableName string, state schema.TableGCState, tm time.Time) (statement string, toTableName string, err error) { if newFormat { - return schema.GenerateRenameStatementNewFormat(fromTableName, state, tm) + return schema.GenerateRenameStatement(fromTableName, state, tm) } - return schema.GenerateRenameStatement(fromTableName, state, tm) + return schema.GenerateRenameStatementOldFormat(fromTableName, state, tm) } func TestHold(t *testing.T) { @@ -449,7 +449,7 @@ func TestPurge(t *testing.T) { func TestPurgeView(t *testing.T) { populateTable(t) - query, tableName, err := schema.GenerateRenameStatement("v1", schema.PurgeTableGCState, time.Now().UTC().Add(tableTransitionExpiration)) + query, tableName, err := generateRenameStatement(true, "v1", schema.PurgeTableGCState, time.Now().UTC().Add(tableTransitionExpiration)) require.NoError(t, err) _, err = primaryTablet.VttabletProcess.QueryTablet(query, keyspaceName, true) diff --git a/go/vt/schema/name.go b/go/vt/schema/name.go index 9a3f038c477..c9754129c39 100644 --- a/go/vt/schema/name.go +++ b/go/vt/schema/name.go @@ -17,6 +17,7 @@ limitations under the License. package schema import ( + "fmt" "regexp" "strings" "time" @@ -32,8 +33,23 @@ const ( InternalTableNameExpression string = `^_vt_([a-zA-Z0-9]{3})_([0-f]{32})_([0-9]{14})_$` ) +type InternalTableHint string + +const ( + InternalTableUnknownHint InternalTableHint = "nil" + InternalTableGCHoldHint InternalTableHint = "hld" + InternalTableGCPurgeHint InternalTableHint = "prg" + InternalTableGCEvacHint InternalTableHint = "evc" + InternalTableGCDropHint InternalTableHint = "drp" + InternalTableVreplicationHint InternalTableHint = "vrp" +) + +func (h InternalTableHint) String() string { + return string(h) +} + var ( - // internalTableNameRegexp parses new intrnal table name format, e.g. _vt_hld_6ace8bcef73211ea87e9f875a4d24e90_20200915120410_ + // internalTableNameRegexp parses new internal table name format, e.g. _vt_hld_6ace8bcef73211ea87e9f875a4d24e90_20200915120410_ internalTableNameRegexp = regexp.MustCompile(InternalTableNameExpression) ) @@ -65,6 +81,44 @@ func ToReadableTimestamp(t time.Time) string { return t.Format(readableTimeFormat) } +// ReadableTimestamp returns the current timestamp, in seconds resolution, that is human readable +func ReadableTimestamp() string { + return ToReadableTimestamp(time.Now()) +} + +func condenseUUID(uuid string) string { + uuid = strings.ReplaceAll(uuid, "-", "") + uuid = strings.ReplaceAll(uuid, "_", "") + return uuid +} + +// isCondensedUUID answers 'true' when the given string is a condensed UUID, e.g.: +// a0638f6bec7b11ea9bf8000d3a9b8a9a +func isCondensedUUID(uuid string) bool { + return condensedUUIDRegexp.MatchString(uuid) +} + +// generateGCTableName creates an internal table name, based on desired hint and time, and with optional preset UUID. +// If uuid is given, then it must be in condensed-UUID format. If empty, the function auto-generates a UUID. +func GenerateInternalTableName(hint string, uuid string, t time.Time) (tableName string, err error) { + if len(hint) != 3 { + return "", fmt.Errorf("Invalid hint: %s, expected 3 characters", hint) + } + if uuid == "" { + uuid, err = CreateUUIDWithDelimiter("") + } else { + uuid = condenseUUID(uuid) + } + if err != nil { + return "", err + } + if !isCondensedUUID(uuid) { + return "", fmt.Errorf("Invalid UUID: %s, expected condensed 32 hexadecimals", uuid) + } + timestamp := ToReadableTimestamp(t) + return fmt.Sprintf("_vt_%s_%s_%s_", hint, uuid, timestamp), nil +} + // IsInternalOperationTableName answers 'true' when the given table name stands for an internal Vitess // table used for operations such as: // - Online DDL (gh-ost, pt-online-schema-change) diff --git a/go/vt/schema/name_test.go b/go/vt/schema/name_test.go index 24571b91b9f..7d1d086cc45 100644 --- a/go/vt/schema/name_test.go +++ b/go/vt/schema/name_test.go @@ -21,6 +21,7 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNameIsGCTableName(t *testing.T) { @@ -165,10 +166,61 @@ func TestAnalyzeInternalTableName(t *testing.T) { assert.Equal(t, ts.isInternal, isInternal) if ts.isInternal { assert.NoError(t, err) - assert.True(t, IsGCUUID(uuid)) + assert.True(t, isCondensedUUID(uuid)) assert.Equal(t, ts.hint, hint) assert.Equal(t, ts.t, tm) } }) } } + +func TestToReadableTimestamp(t *testing.T) { + ti, err := time.Parse(time.UnixDate, "Wed Feb 25 11:06:39 PST 2015") + assert.NoError(t, err) + + readableTimestamp := ToReadableTimestamp(ti) + assert.Equal(t, "20150225110639", readableTimestamp) +} + +func TestGenerateInternalTableName(t *testing.T) { + ti, err := time.Parse(time.UnixDate, "Wed Feb 25 11:06:39 PST 2015") + assert.NoError(t, err) + + { + uuid := "6ace8bcef73211ea87e9f875a4d24e90" + tableName, err := GenerateInternalTableName(InternalTableGCPurgeHint.String(), uuid, ti) + require.NoError(t, err) + assert.Equal(t, "_vt_prg_6ace8bcef73211ea87e9f875a4d24e90_20150225110639_", tableName) + assert.True(t, IsInternalOperationTableName(tableName)) + } + { + uuid := "4e5dcf80_354b_11eb_82cd_f875a4d24e90" + tableName, err := GenerateInternalTableName(InternalTableGCPurgeHint.String(), uuid, ti) + require.NoError(t, err) + assert.Equal(t, "_vt_prg_4e5dcf80354b11eb82cdf875a4d24e90_20150225110639_", tableName) + assert.True(t, IsInternalOperationTableName(tableName)) + } + { + uuid := "4e5dcf80-354b-11eb-82cd-f875a4d24e90" + tableName, err := GenerateInternalTableName(InternalTableGCPurgeHint.String(), uuid, ti) + require.NoError(t, err) + assert.Equal(t, "_vt_prg_4e5dcf80354b11eb82cdf875a4d24e90_20150225110639_", tableName) + assert.True(t, IsInternalOperationTableName(tableName)) + } + { + uuid := "" + tableName, err := GenerateInternalTableName(InternalTableGCPurgeHint.String(), uuid, ti) + require.NoError(t, err) + assert.True(t, IsInternalOperationTableName(tableName)) + } + { + uuid := "4e5dcf80_354b_11eb_82cd_f875a4d24e90_00001111" + _, err := GenerateInternalTableName(InternalTableGCPurgeHint.String(), uuid, ti) + require.ErrorContains(t, err, "Invalid UUID") + } + { + uuid := "6ace8bcef73211ea87e9f875a4d24e90" + _, err := GenerateInternalTableName("abcdefg", uuid, ti) + require.ErrorContains(t, err, "Invalid hint") + } +} diff --git a/go/vt/schema/online_ddl_test.go b/go/vt/schema/online_ddl_test.go index f73984bcf20..c443f6b28ce 100644 --- a/go/vt/schema/online_ddl_test.go +++ b/go/vt/schema/online_ddl_test.go @@ -59,7 +59,7 @@ func TestGetGCUUID(t *testing.T) { onlineDDL, err := NewOnlineDDL("ks", "tbl", "alter table t drop column c", NewDDLStrategySetting(DDLStrategyDirect, ""), "", "", parser) assert.NoError(t, err) gcUUID := onlineDDL.GetGCUUID() - assert.True(t, IsGCUUID(gcUUID)) + assert.True(t, isCondensedUUID(gcUUID)) uuids[gcUUID] = true } assert.Equal(t, count, len(uuids)) diff --git a/go/vt/schema/tablegc.go b/go/vt/schema/tablegc.go index 2f102085f00..fc1b8361fb4 100644 --- a/go/vt/schema/tablegc.go +++ b/go/vt/schema/tablegc.go @@ -44,73 +44,66 @@ const ( TableDroppedGCState TableGCState = "" ) +func (s TableGCState) TableHint() InternalTableHint { + if hint, ok := gcStatesTableHints[s]; ok { + return hint + } + return InternalTableUnknownHint +} + const ( - GCTableNameExpression string = `^_vt_(HOLD|PURGE|EVAC|DROP)_([0-f]{32})_([0-9]{14})$` - // NewGCTableNameExpression parses new intrnal table name format, e.g. _vt_hld_6ace8bcef73211ea87e9f875a4d24e90_20200915120410_ - NewGCTableNameExpression string = `^_vt_(hld|prg|evc|drp)_([0-f]{32})_([0-9]{14})_$` + OldGCTableNameExpression string = `^_vt_(HOLD|PURGE|EVAC|DROP)_([0-f]{32})_([0-9]{14})$` + // GCTableNameExpression parses new internal table name format, e.g. _vt_hld_6ace8bcef73211ea87e9f875a4d24e90_20200915120410_ + GCTableNameExpression string = `^_vt_(hld|prg|evc|drp)_([0-f]{32})_([0-9]{14})_$` ) var ( - gcUUIDRegexp = regexp.MustCompile(`^[0-f]{32}$`) - gcTableNameRegexp = regexp.MustCompile(GCTableNameExpression) - - gcStates = map[string]TableGCState{ - string(HoldTableGCState): HoldTableGCState, - "hld": HoldTableGCState, - string(PurgeTableGCState): PurgeTableGCState, - "prg": PurgeTableGCState, - string(EvacTableGCState): EvacTableGCState, - "evc": EvacTableGCState, - string(DropTableGCState): DropTableGCState, - "drp": DropTableGCState, - } + condensedUUIDRegexp = regexp.MustCompile(`^[0-f]{32}$`) + oldGCTableNameRegexp = regexp.MustCompile(OldGCTableNameExpression) + + gcStates = map[string]TableGCState{} + gcStatesTableHints = map[TableGCState]InternalTableHint{} ) -// IsGCUUID answers 'true' when the given string is an GC UUID, e.g.: -// a0638f6bec7b11ea9bf8000d3a9b8a9a -func IsGCUUID(uuid string) bool { - return gcUUIDRegexp.MatchString(uuid) +func init() { + gcStatesTableHints[HoldTableGCState] = InternalTableGCHoldHint + gcStatesTableHints[PurgeTableGCState] = InternalTableGCPurgeHint + gcStatesTableHints[EvacTableGCState] = InternalTableGCEvacHint + gcStatesTableHints[DropTableGCState] = InternalTableGCDropHint + for _, gcState := range []TableGCState{HoldTableGCState, PurgeTableGCState, EvacTableGCState, DropTableGCState} { + gcStates[string(gcState)] = gcState + gcStates[gcState.TableHint().String()] = gcState + } } // generateGCTableName creates a GC table name, based on desired state and time, and with optional preset UUID. // If uuid is given, then it must be in GC-UUID format. If empty, the function auto-generates a UUID. -func generateGCTableName(state TableGCState, uuid string, t time.Time) (tableName string, err error) { +func generateGCTableNameOldFormat(state TableGCState, uuid string, t time.Time) (tableName string, err error) { if uuid == "" { uuid, err = CreateUUIDWithDelimiter("") } if err != nil { return "", err } - if !IsGCUUID(uuid) { + if !isCondensedUUID(uuid) { return "", fmt.Errorf("Not a valid GC UUID format: %s", uuid) } timestamp := ToReadableTimestamp(t) return fmt.Sprintf("_vt_%s_%s_%s", state, uuid, timestamp), nil } -// generateGCTableNameNewFormat creates a GC table name, based on desired state and time, and with optional preset UUID. +// generateGCTableName creates a GC table name, based on desired state and time, and with optional preset UUID. // If uuid is given, then it must be in GC-UUID format. If empty, the function auto-generates a UUID. -func generateGCTableNameNewFormat(state TableGCState, uuid string, t time.Time) (tableName string, err error) { - if uuid == "" { - uuid, err = CreateUUIDWithDelimiter("") - } - if err != nil { - return "", err - } - if !IsGCUUID(uuid) { - return "", fmt.Errorf("Not a valid GC UUID format: %s", uuid) - } - timestamp := ToReadableTimestamp(t) - var hint string +func generateGCTableName(state TableGCState, uuid string, t time.Time) (tableName string, err error) { for k, v := range gcStates { if v != state { continue } if len(k) == 3 && k != string(state) { // the "new" format - hint = k + return GenerateInternalTableName(k, uuid, t) } } - return fmt.Sprintf("_vt_%s_%s_%s_", hint, uuid, timestamp), nil + return "", fmt.Errorf("Unknown GC state: %v", state) } // GenerateGCTableName creates a GC table name, based on desired state and time, and with random UUID @@ -118,11 +111,6 @@ func GenerateGCTableName(state TableGCState, t time.Time) (tableName string, err return generateGCTableName(state, "", t) } -// GenerateGCTableNameNewFormat creates a GC table name, based on desired state and time, and with random UUID -func GenerateGCTableNameNewFormat(state TableGCState, t time.Time) (tableName string, err error) { - return generateGCTableNameNewFormat(state, "", t) -} - // AnalyzeGCTableName analyzes a given table name to see if it's a GC table, and if so, parse out // its state, uuid, and timestamp func AnalyzeGCTableName(tableName string) (isGCTable bool, state TableGCState, uuid string, t time.Time, err error) { @@ -134,7 +122,7 @@ func AnalyzeGCTableName(tableName string) (isGCTable bool, state TableGCState, u } // Try old naming formats. These names will not be generated in v20. // TODO(shlomi): the code below should be remvoed in v21 - submatch := gcTableNameRegexp.FindStringSubmatch(tableName) + submatch := oldGCTableNameRegexp.FindStringSubmatch(tableName) if len(submatch) == 0 { return false, state, uuid, t, nil } @@ -165,8 +153,8 @@ func GenerateRenameStatementWithUUID(fromTableName string, state TableGCState, u } // GenerateRenameStatementWithUUIDNewFormat generates a "RENAME TABLE" statement, where a table is renamed to a GC table, with preset UUID -func GenerateRenameStatementWithUUIDNewFormat(fromTableName string, state TableGCState, uuid string, t time.Time) (statement string, toTableName string, err error) { - toTableName, err = generateGCTableNameNewFormat(state, uuid, t) +func generateRenameStatementWithUUIDOldFormat(fromTableName string, state TableGCState, uuid string, t time.Time) (statement string, toTableName string, err error) { + toTableName, err = generateGCTableNameOldFormat(state, uuid, t) if err != nil { return "", "", err } @@ -179,8 +167,8 @@ func GenerateRenameStatement(fromTableName string, state TableGCState, t time.Ti } // GenerateRenameStatement generates a "RENAME TABLE" statement, where a table is renamed to a GC table. -func GenerateRenameStatementNewFormat(fromTableName string, state TableGCState, t time.Time) (statement string, toTableName string, err error) { - return GenerateRenameStatementWithUUIDNewFormat(fromTableName, state, "", t) +func GenerateRenameStatementOldFormat(fromTableName string, state TableGCState, t time.Time) (statement string, toTableName string, err error) { + return generateRenameStatementWithUUIDOldFormat(fromTableName, state, "", t) } // ParseGCLifecycle parses a comma separated list of gc states and returns a map of indicated states diff --git a/go/vt/schema/tablegc_test.go b/go/vt/schema/tablegc_test.go index fb9795d4978..3f4e4e7bc09 100644 --- a/go/vt/schema/tablegc_test.go +++ b/go/vt/schema/tablegc_test.go @@ -25,20 +25,37 @@ import ( "github.com/stretchr/testify/require" ) +func TestGCStates(t *testing.T) { + // These are all hard coded + require.Equal(t, HoldTableGCState, gcStates["hld"]) + require.Equal(t, HoldTableGCState, gcStates["HOLD"]) + require.Equal(t, PurgeTableGCState, gcStates["prg"]) + require.Equal(t, PurgeTableGCState, gcStates["PURGE"]) + require.Equal(t, EvacTableGCState, gcStates["evc"]) + require.Equal(t, EvacTableGCState, gcStates["EVAC"]) + require.Equal(t, DropTableGCState, gcStates["drp"]) + require.Equal(t, DropTableGCState, gcStates["DROP"]) + _, ok := gcStates["purge"] + require.False(t, ok) + _, ok = gcStates["vrp"] + require.False(t, ok) + require.Equal(t, 2*4, len(gcStates)) // 4 states, 2 forms each +} + func TestIsGCTableName(t *testing.T) { tm := time.Now() states := []TableGCState{HoldTableGCState, PurgeTableGCState, EvacTableGCState, DropTableGCState} for _, state := range states { for i := 0; i < 10; i++ { - tableName, err := generateGCTableName(state, "", tm) + tableName, err := generateGCTableNameOldFormat(state, "", tm) assert.NoError(t, err) - assert.True(t, IsGCTableName(tableName)) + assert.Truef(t, IsGCTableName(tableName), "table name: %s", tableName) - tableName, err = generateGCTableNameNewFormat(state, "6ace8bcef73211ea87e9f875a4d24e90", tm) + tableName, err = generateGCTableName(state, "6ace8bcef73211ea87e9f875a4d24e90", tm) assert.NoError(t, err) assert.Truef(t, IsGCTableName(tableName), "table name: %s", tableName) - tableName, err = GenerateGCTableNameNewFormat(state, tm) + tableName, err = GenerateGCTableName(state, tm) assert.NoError(t, err) assert.Truef(t, IsGCTableName(tableName), "table name: %s", tableName) } @@ -77,7 +94,7 @@ func TestIsGCTableName(t *testing.T) { t.Run("explicit regexp", func(t *testing.T) { // NewGCTableNameExpression regexp is used externally by vreplication. Its a redundant form of // InternalTableNameExpression, but is nonetheless required. We verify it works correctly - re := regexp.MustCompile(NewGCTableNameExpression) + re := regexp.MustCompile(GCTableNameExpression) t.Run("accept", func(t *testing.T) { names := []string{ "_vt_hld_6ace8bcef73211ea87e9f875a4d24e90_20200915120410_", @@ -173,7 +190,7 @@ func TestAnalyzeGCTableName(t *testing.T) { assert.Equal(t, ts.isGC, isGC) if ts.isGC { assert.NoError(t, err) - assert.True(t, IsGCUUID(uuid)) + assert.True(t, isCondensedUUID(uuid)) assert.Equal(t, ts.state, state) assert.Equal(t, ts.t, tm) } diff --git a/go/vt/vttablet/onlineddl/executor.go b/go/vt/vttablet/onlineddl/executor.go index dcebc0b9bd4..30bb465a1f0 100644 --- a/go/vt/vttablet/onlineddl/executor.go +++ b/go/vt/vttablet/onlineddl/executor.go @@ -1438,7 +1438,10 @@ func (e *Executor) initVreplicationOriginalMigration(ctx context.Context, online return v, err } - vreplTableName := fmt.Sprintf("_%s_%s_vrepl", onlineDDL.UUID, ReadableTimestamp()) + vreplTableName, err := schema.GenerateInternalTableName(schema.InternalTableVreplicationHint.String(), onlineDDL.UUID, time.Now()) + if err != nil { + return v, err + } if err := e.updateArtifacts(ctx, onlineDDL.UUID, vreplTableName); err != nil { return v, err } @@ -1757,7 +1760,7 @@ exit $exit_code runGhost := func(execute bool) error { alterOptions := e.parseAlterOptions(ctx, onlineDDL) - forceTableNames := fmt.Sprintf("%s_%s", onlineDDL.UUID, ReadableTimestamp()) + forceTableNames := fmt.Sprintf("%s_%s", onlineDDL.UUID, schema.ReadableTimestamp()) if err := e.updateArtifacts(ctx, onlineDDL.UUID, fmt.Sprintf("_%s_gho", forceTableNames), @@ -1988,7 +1991,7 @@ export MYSQL_PWD runPTOSC := func(execute bool) error { os.Setenv("MYSQL_PWD", onlineDDLPassword) - newTableName := fmt.Sprintf("_%s_%s_new", onlineDDL.UUID, ReadableTimestamp()) + newTableName := fmt.Sprintf("_%s_%s_new", onlineDDL.UUID, schema.ReadableTimestamp()) if err := e.updateArtifacts(ctx, onlineDDL.UUID, fmt.Sprintf("_%s_old", onlineDDL.Table), diff --git a/go/vt/vttablet/onlineddl/util.go b/go/vt/vttablet/onlineddl/util.go index 305b01c057f..3d06e6df60e 100644 --- a/go/vt/vttablet/onlineddl/util.go +++ b/go/vt/vttablet/onlineddl/util.go @@ -26,15 +26,10 @@ import ( "os/exec" "path/filepath" "strings" - "time" "vitess.io/vitess/go/vt/log" ) -const ( - readableTimeFormat = "20060102150405" -) - // execCmd searches the PATH for a command and runs it, logging the output. // If input is not nil, pipe it to the command's stdin. func execCmd(name string, args, env []string, dir string, input io.Reader, output io.Writer) (cmd *exec.Cmd, err error) { @@ -89,17 +84,3 @@ func RandomHash() string { hasher.Write(rb) return hex.EncodeToString(hasher.Sum(nil)) } - -// ToReadableTimestamp returns a timestamp, in seconds resolution, that is human readable -// (as opposed to unix timestamp which is just a number) -// Example: for Aug 25 2020, 16:04:25 we return "20200825160425" -func ToReadableTimestamp(t time.Time) string { - return t.Format(readableTimeFormat) -} - -// ReadableTimestamp returns a timestamp, in seconds resolution, that is human readable -// (as opposed to unix timestamp which is just a number), and which corresponds to the time now. -// Example: for Aug 25 2020, 16:04:25 we return "20200825160425" -func ReadableTimestamp() string { - return ToReadableTimestamp(time.Now()) -} diff --git a/go/vt/vttablet/onlineddl/util_test.go b/go/vt/vttablet/onlineddl/util_test.go index 707e321c6f5..4beb154c0ae 100644 --- a/go/vt/vttablet/onlineddl/util_test.go +++ b/go/vt/vttablet/onlineddl/util_test.go @@ -18,7 +18,6 @@ package onlineddl import ( "testing" - "time" "github.com/stretchr/testify/assert" ) @@ -31,11 +30,3 @@ func TestRandomHash(t *testing.T) { assert.Equal(t, len(h2), 64) assert.NotEqual(t, h1, h2) } - -func TestToReadableTimestamp(t *testing.T) { - ti, err := time.Parse(time.UnixDate, "Wed Feb 25 11:06:39 PST 2015") - assert.NoError(t, err) - - readableTimestamp := ToReadableTimestamp(ti) - assert.Equal(t, readableTimestamp, "20150225110639") -} diff --git a/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go b/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go index 11633d95f33..67f4815b2a1 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go @@ -330,8 +330,8 @@ func (vr *vreplicator) buildColInfoMap(ctx context.Context) (map[string][]*Colum req := &tabletmanagerdatapb.GetSchemaRequest{ Tables: []string{"/.*/"}, ExcludeTables: []string{ + "/" + schema.OldGCTableNameExpression + "/", "/" + schema.GCTableNameExpression + "/", - "/" + schema.NewGCTableNameExpression + "/", }, } schema, err := vr.mysqld.GetSchema(ctx, vr.dbClient.DBName(), req) From 532f76777a63664df7b8d856d90203dc945e15f9 Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Thu, 15 Feb 2024 09:47:43 +0100 Subject: [PATCH 14/79] evalengine: Implement BIN, OCT & CHAR functions (#15226) Signed-off-by: Dirkjan Bussink --- go/mysql/fastparse/fastparse.go | 45 ++++++++++- go/mysql/fastparse/fastparse_test.go | 66 +++++++++++++++ go/vt/vtgate/evalengine/cached_size.go | 12 +++ go/vt/vtgate/evalengine/compiler_asm.go | 25 +++++- go/vt/vtgate/evalengine/fn_numeric.go | 2 +- go/vt/vtgate/evalengine/fn_string.go | 84 ++++++++++++++++++++ go/vt/vtgate/evalengine/testcases/cases.go | 46 +++++++++++ go/vt/vtgate/evalengine/translate_builtin.go | 43 ++++++++++ 8 files changed, 317 insertions(+), 6 deletions(-) diff --git a/go/mysql/fastparse/fastparse.go b/go/mysql/fastparse/fastparse.go index a17401b7fdd..a669a584d72 100644 --- a/go/mysql/fastparse/fastparse.go +++ b/go/mysql/fastparse/fastparse.go @@ -26,11 +26,19 @@ import ( "vitess.io/vitess/go/hack" ) +func ParseUint64(s string, base int) (uint64, error) { + return parseUint64(s, base, false) +} + +func ParseUint64WithNeg(s string, base int) (uint64, error) { + return parseUint64(s, base, true) +} + // ParseUint64 parses uint64 from s. // // It is equivalent to strconv.ParseUint(s, base, 64) in case it succeeds, // but on error it will return the best effort value of what it has parsed so far. -func ParseUint64(s string, base int) (uint64, error) { +func parseUint64(s string, base int, allowNeg bool) (uint64, error) { if len(s) == 0 { return 0, fmt.Errorf("cannot parse uint64 from empty string") } @@ -45,6 +53,22 @@ func ParseUint64(s string, base int) (uint64, error) { i++ } + if i >= uint(len(s)) { + return 0, fmt.Errorf("cannot parse uint64 from %q", s) + } + // For some reason, MySQL parses things as uint64 even with + // a negative sign and then turns it into the 2s complement value. + minus := s[i] == '-' + if minus { + if !allowNeg { + return 0, fmt.Errorf("cannot parse uint64 from %q", s) + } + i++ + if i >= uint(len(s)) { + return 0, fmt.Errorf("cannot parse uint64 from %q", s) + } + } + d := uint64(0) j := i next: @@ -75,17 +99,23 @@ next: cutoff = math.MaxUint64/uint64(base) + 1 } if d >= cutoff { + if minus { + return 0, fmt.Errorf("cannot parse uint64 from %q: %w", s, ErrOverflow) + } return math.MaxUint64, fmt.Errorf("cannot parse uint64 from %q: %w", s, ErrOverflow) } v := d*uint64(base) + uint64(b) if v < d { + if minus { + return 0, fmt.Errorf("cannot parse uint64 from %q: %w", s, ErrOverflow) + } return math.MaxUint64, fmt.Errorf("cannot parse uint64 from %q: %w", s, ErrOverflow) } d = v i++ } if i <= j { - return d, fmt.Errorf("cannot parse uint64 from %q", s) + return uValue(d, minus), fmt.Errorf("cannot parse uint64 from %q", s) } for i < uint(len(s)) { @@ -97,9 +127,9 @@ next: if i < uint(len(s)) { // Unparsed tail left. - return d, fmt.Errorf("unparsed tail left after parsing uint64 from %q: %q", s, s[i:]) + return uValue(d, minus), fmt.Errorf("unparsed tail left after parsing uint64 from %q: %q", s, s[i:]) } - return d, nil + return uValue(d, minus), nil } var ErrOverflow = errors.New("overflow") @@ -261,3 +291,10 @@ func isSpace(c byte) bool { return false } } + +func uValue(v uint64, neg bool) uint64 { + if neg { + return -v + } + return v +} diff --git a/go/mysql/fastparse/fastparse_test.go b/go/mysql/fastparse/fastparse_test.go index d1bf351284c..5ee87a617d1 100644 --- a/go/mysql/fastparse/fastparse_test.go +++ b/go/mysql/fastparse/fastparse_test.go @@ -334,6 +334,17 @@ func TestParseUint64(t *testing.T) { base: 2, expected: 1, }, + { + input: "-", + base: 10, + expected: 0, + err: `cannot parse uint64 from "-"`, + }, + { + input: "-1", + base: 10, + err: `cannot parse uint64 from "-1"`, + }, { input: "10", base: 2, @@ -478,6 +489,61 @@ func TestParseUint64(t *testing.T) { } } +func TestParseUint64WithNeg(t *testing.T) { + testcases := []struct { + input string + base int + expected uint64 + err string + }{ + { + input: "-", + base: 10, + expected: 0, + err: `cannot parse uint64 from "-"`, + }, + { + input: "-1", + base: 10, + expected: 18446744073709551615, + }, + { + input: "-9223372036854775808", + base: 10, + expected: 9223372036854775808, + }, + { + input: "-9223372036854775809", + base: 10, + expected: 9223372036854775807, + }, + { + input: "-18446744073709551616", + base: 10, + expected: 0, + err: `cannot parse uint64 from "-18446744073709551616": overflow`, + }, + { + input: "-31415926535897932384", + base: 10, + expected: 0, + err: `cannot parse uint64 from "-31415926535897932384": overflow`, + }, + } + for _, tc := range testcases { + t.Run(tc.input, func(t *testing.T) { + val, err := ParseUint64WithNeg(tc.input, tc.base) + if tc.err == "" { + require.NoError(t, err) + require.Equal(t, tc.expected, val) + } else { + require.Equal(t, tc.expected, val) + require.EqualError(t, err, tc.err) + } + }) + } +} + func TestParseFloat64(t *testing.T) { testcases := []struct { input string diff --git a/go/vt/vtgate/evalengine/cached_size.go b/go/vt/vtgate/evalengine/cached_size.go index c80fabb5dca..2e57011ca4c 100644 --- a/go/vt/vtgate/evalengine/cached_size.go +++ b/go/vt/vtgate/evalengine/cached_size.go @@ -571,6 +571,18 @@ func (cached *builtinChangeCase) CachedSize(alloc bool) int64 { size += cached.CallExpr.CachedSize(false) return size } +func (cached *builtinChar) CachedSize(alloc bool) int64 { + if cached == nil { + return int64(0) + } + size := int64(0) + if alloc { + size += int64(48) + } + // field CallExpr vitess.io/vitess/go/vt/vtgate/evalengine.CallExpr + size += cached.CallExpr.CachedSize(false) + return size +} func (cached *builtinCharLength) CachedSize(alloc bool) int64 { if cached == nil { return int64(0) diff --git a/go/vt/vtgate/evalengine/compiler_asm.go b/go/vt/vtgate/evalengine/compiler_asm.go index 5097d54dbd6..cf7bea44a02 100644 --- a/go/vt/vtgate/evalengine/compiler_asm.go +++ b/go/vt/vtgate/evalengine/compiler_asm.go @@ -2008,7 +2008,7 @@ func (asm *assembler) Fn_CONV_bu(offset int, baseOffset int) { i, err := fastparse.ParseInt64(arg.string(), int(base.i)) u = uint64(i) if errors.Is(err, fastparse.ErrOverflow) { - u, _ = fastparse.ParseUint64(arg.string(), int(base.i)) + u, _ = fastparse.ParseUint64WithNeg(arg.string(), int(base.i)) } env.vm.stack[env.vm.sp-offset] = env.vm.arena.newEvalUint64(u) return 1 @@ -4206,6 +4206,29 @@ func (asm *assembler) Fn_CONCAT_WS(tt querypb.Type, tc collations.TypedCollation }, "FN CONCAT_WS VARCHAR(SP-1) VARCHAR(SP-2)...VARCHAR(SP-N)") } +func (asm *assembler) Fn_CHAR(tt querypb.Type, tc collations.TypedCollation, args int) { + cs := colldata.Lookup(tc.Collation).Charset() + asm.adjustStack(-(args - 1)) + asm.emit(func(env *ExpressionEnv) int { + buf := make([]byte, 0, args) + for i := 0; i < args; i++ { + if env.vm.stack[env.vm.sp-args+i] == nil { + continue + } + arg := env.vm.stack[env.vm.sp-args+i].(*evalInt64) + buf = encodeChar(buf, uint32(arg.i)) + } + + if charset.Validate(cs, buf) { + env.vm.stack[env.vm.sp-args] = env.vm.arena.newEvalRaw(buf, tt, tc) + } else { + env.vm.stack[env.vm.sp-args] = nil + } + env.vm.sp -= args - 1 + return 1 + }, "FN CHAR INT64(SP-1) INT64(SP-2)...INT64(SP-N)") +} + func (asm *assembler) Fn_BIN_TO_UUID0(col collations.TypedCollation) { asm.emit(func(env *ExpressionEnv) int { arg := env.vm.stack[env.vm.sp-1].(*evalBytes) diff --git a/go/vt/vtgate/evalengine/fn_numeric.go b/go/vt/vtgate/evalengine/fn_numeric.go index deeb53a3186..c4a77b80fb8 100644 --- a/go/vt/vtgate/evalengine/fn_numeric.go +++ b/go/vt/vtgate/evalengine/fn_numeric.go @@ -1332,7 +1332,7 @@ func (call *builtinConv) eval(env *ExpressionEnv) (eval, error) { i, err := fastparse.ParseInt64(nStr.string(), int(fromBase)) u = uint64(i) if errors.Is(err, fastparse.ErrOverflow) { - u, _ = fastparse.ParseUint64(nStr.string(), int(fromBase)) + u, _ = fastparse.ParseUint64WithNeg(nStr.string(), int(fromBase)) } } diff --git a/go/vt/vtgate/evalengine/fn_string.go b/go/vt/vtgate/evalengine/fn_string.go index e65800c9824..05df198f1f2 100644 --- a/go/vt/vtgate/evalengine/fn_string.go +++ b/go/vt/vtgate/evalengine/fn_string.go @@ -1643,3 +1643,87 @@ func (call *builtinConcatWs) compile(c *compiler) (ctype, error) { return ctype{Type: tt, Flag: args[0].Flag, Col: tc}, nil } + +type builtinChar struct { + CallExpr + collate collations.ID +} + +var _ IR = (*builtinChar)(nil) + +func (call *builtinChar) eval(env *ExpressionEnv) (eval, error) { + vals := make([]eval, 0, len(call.Arguments)) + for _, arg := range call.Arguments { + a, err := arg.eval(env) + if err != nil { + return nil, err + } + if a == nil { + continue + } + vals = append(vals, a) + } + + buf := make([]byte, 0, len(vals)) + for _, v := range vals { + buf = encodeChar(buf, uint32(evalToInt64(v).i)) + } + if call.collate == collations.CollationBinaryID { + return newEvalBinary(buf), nil + } + + cs := colldata.Lookup(call.collate).Charset() + if !charset.Validate(cs, buf) { + return nil, nil + } + + return newEvalText(buf, collations.TypedCollation{ + Collation: call.collate, + Coercibility: collations.CoerceCoercible, + Repertoire: collations.RepertoireASCII, + }), nil +} + +func (call *builtinChar) compile(c *compiler) (ctype, error) { + for _, arg := range call.Arguments { + a, err := arg.compile(c) + if err != nil { + return ctype{}, err + } + j := c.compileNullCheck1(a) + switch a.Type { + case sqltypes.Int64: + // No-op, already correct type + case sqltypes.Uint64: + c.asm.Convert_ui(1) + default: + c.asm.Convert_xi(1) + } + c.asm.jumpDestination(j) + } + tt := sqltypes.VarBinary + if call.collate != collations.CollationBinaryID { + tt = sqltypes.VarChar + } + col := collations.TypedCollation{ + Collation: call.collate, + Coercibility: collations.CoerceCoercible, + Repertoire: collations.RepertoireASCII, + } + c.asm.Fn_CHAR(tt, col, len(call.Arguments)) + return ctype{Type: tt, Flag: flagNullable, Col: col}, nil +} + +func encodeChar(buf []byte, i uint32) []byte { + switch { + case i < 0x100: + buf = append(buf, byte(i)) + case i < 0x10000: + buf = append(buf, byte(i>>8), byte(i)) + case i < 0x1000000: + buf = append(buf, byte(i>>16), byte(i>>8), byte(i)) + default: + buf = append(buf, byte(i>>24), byte(i>>16), byte(i>>8), byte(i)) + } + return buf +} diff --git a/go/vt/vtgate/evalengine/testcases/cases.go b/go/vt/vtgate/evalengine/testcases/cases.go index 9dbb7276e12..c53faa7f217 100644 --- a/go/vt/vtgate/evalengine/testcases/cases.go +++ b/go/vt/vtgate/evalengine/testcases/cases.go @@ -85,6 +85,7 @@ var Cases = []TestCase{ {Run: FnLocate}, {Run: FnConcat}, {Run: FnConcatWs}, + {Run: FnChar}, {Run: FnHex}, {Run: FnUnhex}, {Run: FnCeil}, @@ -116,6 +117,8 @@ var Cases = []TestCase{ {Run: FnTruncate}, {Run: FnCrc32}, {Run: FnConv}, + {Run: FnBin}, + {Run: FnOct}, {Run: FnMD5}, {Run: FnSHA1}, {Run: FnSHA2}, @@ -664,6 +667,24 @@ func FnConv(yield Query) { } } +func FnBin(yield Query) { + for _, num := range radianInputs { + yield(fmt.Sprintf("BIN(%s)", num), nil) + } + for _, num := range inputBitwise { + yield(fmt.Sprintf("BIN(%s)", num), nil) + } +} + +func FnOct(yield Query) { + for _, num := range radianInputs { + yield(fmt.Sprintf("OCT(%s)", num), nil) + } + for _, num := range inputBitwise { + yield(fmt.Sprintf("OCT(%s)", num), nil) + } +} + func FnMD5(yield Query) { for _, num := range radianInputs { yield(fmt.Sprintf("MD5(%s)", num), nil) @@ -1606,6 +1627,31 @@ func FnConcatWs(yield Query) { } } +func FnChar(yield Query) { + mysqlDocSamples := []string{ + `CHAR(77,121,83,81,'76')`, + `CHAR(77,77.3,'77.3')`, + `CHAR(77,121,83,81,'76' USING utf8mb4)`, + `CHAR(77,77.3,'77.3' USING utf8mb4)`, + `HEX(CHAR(1,0))`, + `HEX(CHAR(256))`, + `HEX(CHAR(1,0,0))`, + `HEX(CHAR(256*256)`, + } + + for _, q := range mysqlDocSamples { + yield(q, nil) + } + + for _, i1 := range radianInputs { + for _, i2 := range inputBitwise { + for _, i3 := range inputConversions { + yield(fmt.Sprintf("CHAR(%s, %s, %s)", i1, i2, i3), nil) + } + } + } +} + func FnHex(yield Query) { for _, str := range inputStrings { yield(fmt.Sprintf("hex(%s)", str), nil) diff --git a/go/vt/vtgate/evalengine/translate_builtin.go b/go/vt/vtgate/evalengine/translate_builtin.go index 73beb7fd59e..d4d979a8708 100644 --- a/go/vt/vtgate/evalengine/translate_builtin.go +++ b/go/vt/vtgate/evalengine/translate_builtin.go @@ -20,6 +20,7 @@ import ( "fmt" "strings" + "vitess.io/vitess/go/mysql/collations" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/vterrors" @@ -255,6 +256,22 @@ func (ast *astCompiler) translateFuncExpr(fn *sqlparser.FuncExpr) (IR, error) { return nil, argError(method) } return &builtinConv{CallExpr: call, collate: ast.cfg.Collation}, nil + case "bin": + if len(args) != 1 { + return nil, argError(method) + } + args = append(args, NewLiteralInt(10)) + args = append(args, NewLiteralInt(2)) + var cexpr = CallExpr{Arguments: args, Method: "BIN"} + return &builtinConv{CallExpr: cexpr, collate: ast.cfg.Collation}, nil + case "oct": + if len(args) != 1 { + return nil, argError(method) + } + args = append(args, NewLiteralInt(10)) + args = append(args, NewLiteralInt(8)) + var cexpr = CallExpr{Arguments: args, Method: "OCT"} + return &builtinConv{CallExpr: cexpr, collate: ast.cfg.Collation}, nil case "left", "right": if len(args) != 2 { return nil, argError(method) @@ -1044,6 +1061,32 @@ func (ast *astCompiler) translateCallable(call sqlparser.Callable) (IR, error) { CallExpr: cexpr, collate: ast.cfg.Collation, }, nil + case *sqlparser.CharExpr: + args := make([]IR, 0, len(call.Exprs)) + for _, expr := range call.Exprs { + arg, err := ast.translateExpr(expr) + if err != nil { + return nil, err + } + args = append(args, arg) + } + + var cexpr = CallExpr{Arguments: args, Method: "CHAR"} + var coll collations.ID + if call.Charset == "" { + coll = collations.CollationBinaryID + } else { + var err error + coll, err = ast.translateConvertCharset(call.Charset, false) + if err != nil { + return nil, err + } + } + + return &builtinChar{ + CallExpr: cexpr, + collate: coll, + }, nil default: return nil, translateExprNotSupported(call) } From 7327b22e24091d13084b10bb963441aceeaa0986 Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Thu, 15 Feb 2024 10:34:45 +0100 Subject: [PATCH 15/79] Update toolchain version in go.mod (#15245) Signed-off-by: Dirkjan Bussink --- go.mod | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go.mod b/go.mod index d47d781a49d..b9d8ba06b85 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module vitess.io/vitess -go 1.22 +go 1.22.0 require ( cloud.google.com/go/storage v1.37.0 From bcfc5fb9332c04d8f3e7c1cff9c33211aa80e2b0 Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Thu, 15 Feb 2024 11:41:12 +0100 Subject: [PATCH 16/79] statsd: Update to datadog-go v5 API (#15247) Signed-off-by: Dirkjan Bussink --- go.mod | 3 +-- go.sum | 2 -- go/stats/statsd/statsd.go | 15 +++++++++------ go/stats/statsd/statsd_test.go | 5 ++--- 4 files changed, 12 insertions(+), 13 deletions(-) diff --git a/go.mod b/go.mod index b9d8ba06b85..28cf40c1907 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,6 @@ require ( github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 github.com/Azure/azure-pipeline-go v0.2.3 github.com/Azure/azure-storage-blob-go v0.15.0 - github.com/DataDog/datadog-go v4.8.3+incompatible github.com/HdrHistogram/hdrhistogram-go v0.9.0 // indirect github.com/aquarapid/vaultlib v0.5.1 github.com/armon/go-metrics v0.4.1 // indirect @@ -92,6 +91,7 @@ require ( ) require ( + github.com/DataDog/datadog-go/v5 v5.5.0 github.com/Shopify/toxiproxy/v2 v2.7.0 github.com/bndr/gotabulate v1.1.2 github.com/gammazero/deque v0.2.1 @@ -119,7 +119,6 @@ require ( github.com/DataDog/appsec-internal-go v1.4.0 // indirect github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2 // indirect github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 // indirect - github.com/DataDog/datadog-go/v5 v5.5.0 // indirect github.com/DataDog/go-libddwaf/v2 v2.2.3 // indirect github.com/DataDog/go-sqllexer v0.0.10 // indirect github.com/DataDog/go-tuf v1.0.2-0.5.2 // indirect diff --git a/go.sum b/go.sum index ee64870fec3..456c1a3e194 100644 --- a/go.sum +++ b/go.sum @@ -35,8 +35,6 @@ github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2/go.mod h1:A4nLJvxlg6BO/8/ github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 h1:7jn5EOu84uph4sd+pB3vF8LnsdTjhh+1/NnCvfNpG4A= github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2/go.mod h1:Vc+snp0Bey4MrrJyiV2tVxxJb6BmLomPvN1RgAvjGaQ= github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= -github.com/DataDog/datadog-go v4.8.3+incompatible h1:fNGaYSuObuQb5nzeTQqowRAd9bpDIRRV4/gUtIBjh8Q= -github.com/DataDog/datadog-go v4.8.3+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= github.com/DataDog/datadog-go/v5 v5.5.0 h1:G5KHeB8pWBNXT4Jtw0zAkhdxEAWSpWH00geHI6LDrKU= github.com/DataDog/datadog-go/v5 v5.5.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= github.com/DataDog/go-libddwaf/v2 v2.2.3 h1:LpKE8AYhVrEhlmlw6FGD41udtDf7zW/aMdLNbCXpegQ= diff --git a/go/stats/statsd/statsd.go b/go/stats/statsd/statsd.go index f791d7b742d..099b8eea0f6 100644 --- a/go/stats/statsd/statsd.go +++ b/go/stats/statsd/statsd.go @@ -8,7 +8,7 @@ import ( "strings" "sync" - "github.com/DataDog/datadog-go/statsd" + "github.com/DataDog/datadog-go/v5/statsd" "github.com/spf13/pflag" "vitess.io/vitess/go/stats" @@ -81,15 +81,18 @@ func InitWithoutServenv(namespace string) { log.Info("statsdAddress is empty") return } - statsdC, err := statsd.NewBuffered(statsdAddress, 100) + opts := []statsd.Option{ + statsd.WithMaxMessagesPerPayload(100), + statsd.WithNamespace(namespace), + } + if tags := stats.ParseCommonTags(stats.CommonTags); len(tags) > 0 { + opts = append(opts, statsd.WithTags(makeCommonTags(tags))) + } + statsdC, err := statsd.New(statsdAddress, opts...) if err != nil { log.Errorf("Failed to create statsd client %v", err) return } - statsdC.Namespace = namespace + "." - if tags := stats.ParseCommonTags(stats.CommonTags); len(tags) > 0 { - statsdC.Tags = makeCommonTags(tags) - } sb.namespace = namespace sb.statsdClient = statsdC sb.sampleRate = statsdSampleRate diff --git a/go/stats/statsd/statsd_test.go b/go/stats/statsd/statsd_test.go index c615da3cdfd..feab8ae6759 100644 --- a/go/stats/statsd/statsd_test.go +++ b/go/stats/statsd/statsd_test.go @@ -8,7 +8,7 @@ import ( "testing" "time" - "github.com/DataDog/datadog-go/statsd" + "github.com/DataDog/datadog-go/v5/statsd" "github.com/stretchr/testify/assert" "vitess.io/vitess/go/stats" @@ -19,8 +19,7 @@ func getBackend(t *testing.T) (StatsBackend, *net.UDPConn) { udpAddr, _ := net.ResolveUDPAddr("udp", addr) server, _ := net.ListenUDP("udp", udpAddr) bufferLength := 9 - client, _ := statsd.NewBuffered(addr, bufferLength) - client.Namespace = "test." + client, _ := statsd.New(addr, statsd.WithMaxMessagesPerPayload(bufferLength), statsd.WithNamespace("test")) var sb StatsBackend sb.namespace = "foo" sb.sampleRate = 1 From 365f936ace72df84619dcda2a7348720dab45810 Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Thu, 15 Feb 2024 14:50:52 +0200 Subject: [PATCH 17/79] Tablet throttler: adding more stats (#15224) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- go/vt/vttablet/tabletmanager/rpc_throttler.go | 2 ++ .../tabletserver/throttle/throttler.go | 20 ++++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/go/vt/vttablet/tabletmanager/rpc_throttler.go b/go/vt/vttablet/tabletmanager/rpc_throttler.go index dfdc0d230fb..c961761c5f2 100644 --- a/go/vt/vttablet/tabletmanager/rpc_throttler.go +++ b/go/vt/vttablet/tabletmanager/rpc_throttler.go @@ -19,6 +19,7 @@ package tabletmanager import ( "context" + "vitess.io/vitess/go/stats" tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata" "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/vterrors" @@ -28,6 +29,7 @@ import ( // CheckThrottler executes a throttler check func (tm *TabletManager) CheckThrottler(ctx context.Context, req *tabletmanagerdatapb.CheckThrottlerRequest) (*tabletmanagerdatapb.CheckThrottlerResponse, error) { + go stats.GetOrNewCounter("ThrottlerCheckRequest", "CheckThrottler requests").Add(1) if req.AppName == "" { req.AppName = throttlerapp.VitessName.String() } diff --git a/go/vt/vttablet/tabletserver/throttle/throttler.go b/go/vt/vttablet/tabletserver/throttle/throttler.go index a451850a23f..b75898a3256 100644 --- a/go/vt/vttablet/tabletserver/throttle/throttler.go +++ b/go/vt/vttablet/tabletserver/throttle/throttler.go @@ -59,6 +59,7 @@ import ( "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/protoutil" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/textutil" "vitess.io/vitess/go/timer" @@ -443,7 +444,7 @@ func (throttler *Throttler) Enable() *sync.WaitGroup { throttler.Operate(ctx, wg) // Make a one-time request for a lease of heartbeats - go throttler.heartbeatWriter.RequestHeartbeats() + throttler.requestHeartbeats() return wg } @@ -568,6 +569,13 @@ func (throttler *Throttler) Close() { log.Infof("Throttler: finished execution of Close") } +// requestHeartbeats sends a heartbeat lease request to the heartbeat writer. +// This action is recorded in stats. +func (throttler *Throttler) requestHeartbeats() { + go throttler.heartbeatWriter.RequestHeartbeats() + go stats.GetOrNewCounter("ThrottlerHeartbeatRequests", "heartbeat requests").Add(1) +} + func (throttler *Throttler) generateSelfMySQLThrottleMetricFunc(ctx context.Context, probe *mysql.Probe) func() *mysql.MySQLThrottleMetric { f := func() *mysql.MySQLThrottleMetric { return throttler.readSelfThrottleMetric(ctx, probe) @@ -708,7 +716,7 @@ func (throttler *Throttler) Operate(ctx context.Context, wg *sync.WaitGroup) { if transitionedIntoLeader { // transitioned into leadership, let's speed up the next 'refresh' and 'collect' ticks go mysqlRefreshTicker.TickNow() - go throttler.heartbeatWriter.RequestHeartbeats() + throttler.requestHeartbeats() } }() case <-mysqlCollectTicker.C: @@ -782,7 +790,8 @@ func (throttler *Throttler) generateTabletProbeFunction(ctx context.Context, clu if resp.RecentlyChecked { // We have just probed a tablet, and it reported back that someone just recently "check"ed it. // We therefore renew the heartbeats lease. - go throttler.heartbeatWriter.RequestHeartbeats() + throttler.requestHeartbeats() + go stats.GetOrNewCounter("ThrottlerProbeRecentlyChecked", "probe recently checked").Add(1) } return mySQLThrottleMetric } @@ -1017,7 +1026,7 @@ func (throttler *Throttler) ThrottleApp(appName string, expireAt time.Time, rati func (throttler *Throttler) UnthrottleApp(appName string) (appThrottle *base.AppThrottle) { throttler.throttledApps.Delete(appName) // the app is likely to check - go throttler.heartbeatWriter.RequestHeartbeats() + throttler.requestHeartbeats() return base.NewAppThrottle(appName, time.Now(), 0, false) } @@ -1164,7 +1173,7 @@ func (throttler *Throttler) checkStore(ctx context.Context, appName string, stor return okMetricCheckResult } if !flags.SkipRequestHeartbeats && !throttlerapp.VitessName.Equals(appName) { - go throttler.heartbeatWriter.RequestHeartbeats() + throttler.requestHeartbeats() // This check was made by someone other than the throttler itself, i.e. this came from online-ddl or vreplication or other. // We mark the fact that someone just made a check. If this is a REPLICA or RDONLY tables, this will be reported back // to the PRIMARY so that it knows it must renew the heartbeat lease. @@ -1178,6 +1187,7 @@ func (throttler *Throttler) checkStore(ctx context.Context, appName string, stor // If this tablet is a REPLICA or RDONLY, we want to advertise to the PRIMARY that someone did a recent check, // so that the PRIMARY knows it must renew the heartbeat lease. checkResult.RecentlyChecked = true + go stats.GetOrNewCounter("ThrottlerRecentlyChecked", "recently checked").Add(1) } return checkResult From c0b303d97edb7289e7c72ab7b021d038e7460edb Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Thu, 15 Feb 2024 21:34:09 +0530 Subject: [PATCH 18/79] Fix Delete with multi-tables related by foreign keys (#15218) Signed-off-by: Manan Gupta --- go/test/endtoend/vtgate/foreignkey/fk_test.go | 10 + go/vt/sqlparser/ast_format.go | 2 +- go/vt/sqlparser/ast_format_fast.go | 2 +- go/vt/sqlparser/ast_funcs.go | 2 +- go/vt/vtgate/planbuilder/operators/delete.go | 32 +- .../testdata/foreignkey_cases.json | 345 ++++++++++++------ .../testdata/foreignkey_checks_on_cases.json | 8 +- 7 files changed, 284 insertions(+), 117 deletions(-) diff --git a/go/test/endtoend/vtgate/foreignkey/fk_test.go b/go/test/endtoend/vtgate/foreignkey/fk_test.go index ff4126387b8..b16da5bfabd 100644 --- a/go/test/endtoend/vtgate/foreignkey/fk_test.go +++ b/go/test/endtoend/vtgate/foreignkey/fk_test.go @@ -967,6 +967,16 @@ func TestFkQueries(t *testing.T) { "update fk_t16 set col = col * (col - (col)) where id = 4", }, }, + { + name: "Multi table delete that uses two tables related by foreign keys", + queries: []string{ + "insert /*+ SET_VAR(foreign_key_checks=0) */ into fk_t10 (id, col) values (1, '5'), (2, NULL), (3, NULL), (4, '4'), (6, '1'), (7, '2')", + "insert /*+ SET_VAR(foreign_key_checks=0) */ into fk_t11 (id, col) values (4, '1'), (5, '3'), (7, '22'), (8, '5'), (9, NULL), (10, '3')", + "insert /*+ SET_VAR(foreign_key_checks=0) */ into fk_t12 (id, col) values (2, NULL), (3, NULL), (4, '1'), (6, '6'), (8, NULL), (10, '1')", + "insert /*+ SET_VAR(foreign_key_checks=0) */ into fk_t13 (id, col) values (2, '1'), (5, '5'), (7, '5')", + "delete fk_t11 from fk_t11 join fk_t12 using (id) where fk_t11.id = 4", + }, + }, } for _, testcase := range testcases { diff --git a/go/vt/sqlparser/ast_format.go b/go/vt/sqlparser/ast_format.go index 59ed4add5ee..33ea8666c9d 100644 --- a/go/vt/sqlparser/ast_format.go +++ b/go/vt/sqlparser/ast_format.go @@ -177,7 +177,7 @@ func (node *Delete) Format(buf *TrackedBuffer) { if node.Ignore { buf.literal("ignore ") } - if node.Targets != nil && !node.isSingleAliasExpr() { + if node.Targets != nil && !node.IsSingleAliasExpr() { buf.astPrintf(node, "%v ", node.Targets) } prefix := "from " diff --git a/go/vt/sqlparser/ast_format_fast.go b/go/vt/sqlparser/ast_format_fast.go index bad1854d28e..0f84cb64e7f 100644 --- a/go/vt/sqlparser/ast_format_fast.go +++ b/go/vt/sqlparser/ast_format_fast.go @@ -257,7 +257,7 @@ func (node *Delete) FormatFast(buf *TrackedBuffer) { if node.Ignore { buf.WriteString("ignore ") } - if node.Targets != nil && !node.isSingleAliasExpr() { + if node.Targets != nil && !node.IsSingleAliasExpr() { node.Targets.FormatFast(buf) buf.WriteByte(' ') } diff --git a/go/vt/sqlparser/ast_funcs.go b/go/vt/sqlparser/ast_funcs.go index a8d231d6aa1..5e63774f5bf 100644 --- a/go/vt/sqlparser/ast_funcs.go +++ b/go/vt/sqlparser/ast_funcs.go @@ -2587,7 +2587,7 @@ func (ct *ColumnType) Invisible() bool { return ct.Options.Invisible != nil && *ct.Options.Invisible } -func (node *Delete) isSingleAliasExpr() bool { +func (node *Delete) IsSingleAliasExpr() bool { if len(node.Targets) > 1 { return false } diff --git a/go/vt/vtgate/planbuilder/operators/delete.go b/go/vt/vtgate/planbuilder/operators/delete.go index 4bc2f48f4d8..7a497d5511c 100644 --- a/go/vt/vtgate/planbuilder/operators/delete.go +++ b/go/vt/vtgate/planbuilder/operators/delete.go @@ -82,10 +82,11 @@ func (d *Delete) ShortDescription() string { func createOperatorFromDelete(ctx *plancontext.PlanningContext, deleteStmt *sqlparser.Delete) (op Operator) { childFks := ctx.SemTable.GetChildForeignKeysForTable(deleteStmt.Targets[0]) - // If the delete statement has a limit and has foreign keys, we will use a DMLWithInput - // operator wherein we do a selection first and use that output for the subsequent deletes. - if len(childFks) > 0 && deleteStmt.Limit != nil { - return deletePlanningForLimitFk(ctx, deleteStmt) + // We check if delete with input plan is required. DML with input planning is generally + // slower, because it does a selection and then creates a delete statement wherein we have to + // list all the primary key values. + if deleteWithInputPlanningRequired(childFks, deleteStmt) { + return deleteWithInputPlanningForFk(ctx, deleteStmt) } delClone := sqlparser.CloneRefOfDelete(deleteStmt) @@ -107,7 +108,23 @@ func createOperatorFromDelete(ctx *plancontext.PlanningContext, deleteStmt *sqlp return createFkCascadeOpForDelete(ctx, op, delClone, childFks, delOp.Target.VTable) } -func deletePlanningForLimitFk(ctx *plancontext.PlanningContext, del *sqlparser.Delete) Operator { +func deleteWithInputPlanningRequired(childFks []vindexes.ChildFKInfo, deleteStmt *sqlparser.Delete) bool { + // If there are no foreign keys, we don't need to use delete with input. + if len(childFks) == 0 { + return false + } + // Limit requires delete with input. + if deleteStmt.Limit != nil { + return true + } + // If there are no limit clauses, and it is not a multi-delete, we don't need delete with input. + // TODO: In the future, we can check if the tables involved in the multi-table delete are related by foreign keys or not. + // If they aren't then we don't need the multi-table delete. But this check isn't so straight-forward. We need to check if the two + // tables are connected in the undirected graph built from the tables related by foreign keys. + return !deleteStmt.IsSingleAliasExpr() +} + +func deleteWithInputPlanningForFk(ctx *plancontext.PlanningContext, del *sqlparser.Delete) Operator { delClone := ctx.SemTable.Clone(del).(*sqlparser.Delete) del.Limit = nil del.OrderBy = nil @@ -129,7 +146,7 @@ func deletePlanningForLimitFk(ctx *plancontext.PlanningContext, del *sqlparser.D var leftComp sqlparser.ValTuple cols := make([]*sqlparser.ColName, 0, len(vTbl.PrimaryKey)) for _, col := range vTbl.PrimaryKey { - colName := sqlparser.NewColName(col.String()) + colName := sqlparser.NewColNameWithQualifier(col.String(), vTbl.GetTableName()) selectStmt.SelectExprs = append(selectStmt.SelectExprs, aeWrap(colName)) cols = append(cols, colName) leftComp = append(leftComp, colName) @@ -141,6 +158,9 @@ func deletePlanningForLimitFk(ctx *plancontext.PlanningContext, del *sqlparser.D lhs = leftComp[0] } compExpr := sqlparser.NewComparisonExpr(sqlparser.InOp, lhs, sqlparser.ListArg(engine.DmlVals), nil) + + del.Targets = sqlparser.TableNames{del.Targets[0]} + del.TableExprs = sqlparser.TableExprs{ti.GetAliasedTableExpr()} del.Where = sqlparser.NewWhere(sqlparser.WhereClause, compExpr) return &DMLWithInput{ diff --git a/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json b/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json index 1c1bcc9144a..c8f059b7b88 100644 --- a/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json @@ -1265,8 +1265,8 @@ "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select id from u_tbl2 where 1 != 1", - "Query": "select id from u_tbl2 limit 2 for update", + "FieldQuery": "select u_tbl2.id from u_tbl2 where 1 != 1", + "Query": "select u_tbl2.id from u_tbl2 limit 2 for update", "Table": "u_tbl2" }, { @@ -1281,7 +1281,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl2.col2 from u_tbl2 where 1 != 1", - "Query": "select u_tbl2.col2 from u_tbl2 where id in ::dml_vals for update", + "Query": "select u_tbl2.col2 from u_tbl2 where u_tbl2.id in ::dml_vals for update", "Table": "u_tbl2" }, { @@ -1309,7 +1309,7 @@ "Sharded": false }, "TargetTabletType": "PRIMARY", - "Query": "delete from u_tbl2 where id in ::dml_vals", + "Query": "delete from u_tbl2 where u_tbl2.id in ::dml_vals", "Table": "u_tbl2" } ] @@ -3128,47 +3128,67 @@ "QueryType": "DELETE", "Original": "delete u from u_tbl6 u join u_tbl5 m on u.col = m.col where u.col2 = 4 and m.col3 = 6", "Instructions": { - "OperatorType": "FkCascade", + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + 0 + ], "Inputs": [ { - "InputName": "Selection", "OperatorType": "Route", "Variant": "Unsharded", "Keyspace": { "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select u_tbl6.col6 from u_tbl6 as u, u_tbl5 as m where 1 != 1", - "Query": "select u_tbl6.col6 from u_tbl6 as u, u_tbl5 as m where u.col = m.col and u.col2 = 4 and m.col3 = 6 for update", + "FieldQuery": "select u_tbl6.id from u_tbl6 as u, u_tbl5 as m where 1 != 1", + "Query": "select u_tbl6.id from u_tbl6 as u, u_tbl5 as m where u.col2 = 4 and m.col3 = 6 and u.col = m.col for update", "Table": "u_tbl5, u_tbl6" }, { - "InputName": "CascadeChild-1", - "OperatorType": "Delete", - "Variant": "Unsharded", - "Keyspace": { - "Name": "unsharded_fk_allow", - "Sharded": false - }, - "TargetTabletType": "PRIMARY", - "BvName": "fkc_vals", - "Cols": [ - 0 - ], - "Query": "delete from u_tbl8 where (col8) in ::fkc_vals", - "Table": "u_tbl8" - }, - { - "InputName": "Parent", - "OperatorType": "Delete", - "Variant": "Unsharded", - "Keyspace": { - "Name": "unsharded_fk_allow", - "Sharded": false - }, - "TargetTabletType": "PRIMARY", - "Query": "delete u from u_tbl6 as u, u_tbl5 as m where u.col2 = 4 and m.col3 = 6 and u.col = m.col", - "Table": "u_tbl6" + "OperatorType": "FkCascade", + "Inputs": [ + { + "InputName": "Selection", + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "FieldQuery": "select u_tbl6.col6 from u_tbl6 as u where 1 != 1", + "Query": "select u_tbl6.col6 from u_tbl6 as u where u_tbl6.id in ::dml_vals for update", + "Table": "u_tbl6" + }, + { + "InputName": "CascadeChild-1", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "BvName": "fkc_vals", + "Cols": [ + 0 + ], + "Query": "delete from u_tbl8 where (col8) in ::fkc_vals", + "Table": "u_tbl8" + }, + { + "InputName": "Parent", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from u_tbl6 as u where u_tbl6.id in ::dml_vals", + "Table": "u_tbl6" + } + ] } ] }, @@ -3186,47 +3206,67 @@ "QueryType": "DELETE", "Original": "delete u_tbl10 from u_tbl10 join u_tbl11 using (id) where id = 5", "Instructions": { - "OperatorType": "FkCascade", + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + 0 + ], "Inputs": [ { - "InputName": "Selection", "OperatorType": "Route", "Variant": "Unsharded", "Keyspace": { "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select u_tbl10.col from u_tbl10, u_tbl11 where 1 != 1", - "Query": "select u_tbl10.col from u_tbl10, u_tbl11 where u_tbl10.id = u_tbl11.id and u_tbl10.id = 5 for update", + "FieldQuery": "select u_tbl10.id from u_tbl10, u_tbl11 where 1 != 1", + "Query": "select u_tbl10.id from u_tbl10, u_tbl11 where u_tbl10.id = 5 and u_tbl10.id = u_tbl11.id for update", "Table": "u_tbl10, u_tbl11" }, { - "InputName": "CascadeChild-1", - "OperatorType": "Delete", - "Variant": "Unsharded", - "Keyspace": { - "Name": "unsharded_fk_allow", - "Sharded": false - }, - "TargetTabletType": "PRIMARY", - "BvName": "fkc_vals", - "Cols": [ - 0 - ], - "Query": "delete from u_tbl11 where (col) in ::fkc_vals", - "Table": "u_tbl11" - }, - { - "InputName": "Parent", - "OperatorType": "Delete", - "Variant": "Unsharded", - "Keyspace": { - "Name": "unsharded_fk_allow", - "Sharded": false - }, - "TargetTabletType": "PRIMARY", - "Query": "delete u_tbl10 from u_tbl10, u_tbl11 where u_tbl10.id = 5 and u_tbl10.id = u_tbl11.id", - "Table": "u_tbl10" + "OperatorType": "FkCascade", + "Inputs": [ + { + "InputName": "Selection", + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "FieldQuery": "select u_tbl10.col from u_tbl10 where 1 != 1", + "Query": "select u_tbl10.col from u_tbl10 where u_tbl10.id in ::dml_vals for update", + "Table": "u_tbl10" + }, + { + "InputName": "CascadeChild-1", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "BvName": "fkc_vals", + "Cols": [ + 0 + ], + "Query": "delete from u_tbl11 where (col) in ::fkc_vals", + "Table": "u_tbl11" + }, + { + "InputName": "Parent", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from u_tbl10 where u_tbl10.id in ::dml_vals", + "Table": "u_tbl10" + } + ] } ] }, @@ -3243,27 +3283,25 @@ "QueryType": "DELETE", "Original": "delete u_tbl1 from u_tbl10 join u_tbl1 on u_tbl10.col = u_tbl1.col", "Instructions": { - "OperatorType": "FkCascade", + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + 0 + ], "Inputs": [ { - "InputName": "Selection", "OperatorType": "Route", "Variant": "Unsharded", "Keyspace": { "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select u_tbl1.col1 from u_tbl10, u_tbl1 where 1 != 1", - "Query": "select u_tbl1.col1 from u_tbl10, u_tbl1 where u_tbl10.col = u_tbl1.col for update", + "FieldQuery": "select u_tbl1.id from u_tbl10, u_tbl1 where 1 != 1", + "Query": "select u_tbl1.id from u_tbl10, u_tbl1 where u_tbl10.col = u_tbl1.col for update", "Table": "u_tbl1, u_tbl10" }, { - "InputName": "CascadeChild-1", "OperatorType": "FkCascade", - "BvName": "fkc_vals", - "Cols": [ - 0 - ], "Inputs": [ { "InputName": "Selection", @@ -3273,25 +3311,59 @@ "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select u_tbl2.col2 from u_tbl2 where 1 != 1", - "Query": "select u_tbl2.col2 from u_tbl2 where (col2) in ::fkc_vals for update", - "Table": "u_tbl2" + "FieldQuery": "select u_tbl1.col1 from u_tbl1 where 1 != 1", + "Query": "select u_tbl1.col1 from u_tbl1 where u_tbl1.id in ::dml_vals for update", + "Table": "u_tbl1" }, { "InputName": "CascadeChild-1", - "OperatorType": "Update", - "Variant": "Unsharded", - "Keyspace": { - "Name": "unsharded_fk_allow", - "Sharded": false - }, - "TargetTabletType": "PRIMARY", - "BvName": "fkc_vals1", + "OperatorType": "FkCascade", + "BvName": "fkc_vals", "Cols": [ 0 ], - "Query": "update u_tbl3 set col3 = null where (col3) in ::fkc_vals1", - "Table": "u_tbl3" + "Inputs": [ + { + "InputName": "Selection", + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "FieldQuery": "select u_tbl2.col2 from u_tbl2 where 1 != 1", + "Query": "select u_tbl2.col2 from u_tbl2 where (col2) in ::fkc_vals for update", + "Table": "u_tbl2" + }, + { + "InputName": "CascadeChild-1", + "OperatorType": "Update", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "BvName": "fkc_vals1", + "Cols": [ + 0 + ], + "Query": "update u_tbl3 set col3 = null where (col3) in ::fkc_vals1", + "Table": "u_tbl3" + }, + { + "InputName": "Parent", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from u_tbl2 where (col2) in ::fkc_vals", + "Table": "u_tbl2" + } + ] }, { "InputName": "Parent", @@ -3302,22 +3374,10 @@ "Sharded": false }, "TargetTabletType": "PRIMARY", - "Query": "delete from u_tbl2 where (col2) in ::fkc_vals", - "Table": "u_tbl2" + "Query": "delete from u_tbl1 where u_tbl1.id in ::dml_vals", + "Table": "u_tbl1" } ] - }, - { - "InputName": "Parent", - "OperatorType": "Delete", - "Variant": "Unsharded", - "Keyspace": { - "Name": "unsharded_fk_allow", - "Sharded": false - }, - "TargetTabletType": "PRIMARY", - "Query": "delete u_tbl1 from u_tbl10, u_tbl1 where u_tbl10.col = u_tbl1.col", - "Table": "u_tbl1" } ] }, @@ -3349,8 +3409,8 @@ "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select id from u_tbl1 where 1 != 1", - "Query": "select id from u_tbl1 order by id asc limit 1 for update", + "FieldQuery": "select u_tbl1.id from u_tbl1 where 1 != 1", + "Query": "select u_tbl1.id from u_tbl1 order by id asc limit 1 for update", "Table": "u_tbl1" }, { @@ -3365,7 +3425,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl1.col1 from u_tbl1 where 1 != 1", - "Query": "select u_tbl1.col1 from u_tbl1 where id in ::dml_vals for update", + "Query": "select u_tbl1.col1 from u_tbl1 where u_tbl1.id in ::dml_vals for update", "Table": "u_tbl1" }, { @@ -3427,7 +3487,7 @@ "Sharded": false }, "TargetTabletType": "PRIMARY", - "Query": "delete from u_tbl1 where id in ::dml_vals", + "Query": "delete from u_tbl1 where u_tbl1.id in ::dml_vals", "Table": "u_tbl1" } ] @@ -3669,5 +3729,82 @@ "unsharded_fk_allow.u_tbl9" ] } + }, + { + "comment": "Multi table delete such that the two tables are foreign key related", + "query": "delete u_tbl6 from u_tbl6 join u_tbl8 on u_tbl6.id = u_tbl8.id where u_tbl6.id = 4", + "plan": { + "QueryType": "DELETE", + "Original": "delete u_tbl6 from u_tbl6 join u_tbl8 on u_tbl6.id = u_tbl8.id where u_tbl6.id = 4", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + 0 + ], + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "FieldQuery": "select u_tbl6.id from u_tbl6, u_tbl8 where 1 != 1", + "Query": "select u_tbl6.id from u_tbl6, u_tbl8 where u_tbl6.id = 4 and u_tbl6.id = u_tbl8.id for update", + "Table": "u_tbl6, u_tbl8" + }, + { + "OperatorType": "FkCascade", + "Inputs": [ + { + "InputName": "Selection", + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "FieldQuery": "select u_tbl6.col6 from u_tbl6 where 1 != 1", + "Query": "select u_tbl6.col6 from u_tbl6 where u_tbl6.id in ::dml_vals for update", + "Table": "u_tbl6" + }, + { + "InputName": "CascadeChild-1", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "BvName": "fkc_vals", + "Cols": [ + 0 + ], + "Query": "delete from u_tbl8 where (col8) in ::fkc_vals", + "Table": "u_tbl8" + }, + { + "InputName": "Parent", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "unsharded_fk_allow", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from u_tbl6 where u_tbl6.id in ::dml_vals", + "Table": "u_tbl6" + } + ] + } + ] + }, + "TablesUsed": [ + "unsharded_fk_allow.u_tbl6", + "unsharded_fk_allow.u_tbl8" + ] + } } ] diff --git a/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json b/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json index 5404be4e1dc..311ff6adbff 100644 --- a/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json @@ -1265,8 +1265,8 @@ "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select id from u_tbl2 where 1 != 1", - "Query": "select id from u_tbl2 limit 2 for update", + "FieldQuery": "select u_tbl2.id from u_tbl2 where 1 != 1", + "Query": "select u_tbl2.id from u_tbl2 limit 2 for update", "Table": "u_tbl2" }, { @@ -1281,7 +1281,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl2.col2 from u_tbl2 where 1 != 1", - "Query": "select u_tbl2.col2 from u_tbl2 where id in ::dml_vals for update", + "Query": "select u_tbl2.col2 from u_tbl2 where u_tbl2.id in ::dml_vals for update", "Table": "u_tbl2" }, { @@ -1309,7 +1309,7 @@ "Sharded": false }, "TargetTabletType": "PRIMARY", - "Query": "delete /*+ SET_VAR(foreign_key_checks=On) */ from u_tbl2 where id in ::dml_vals", + "Query": "delete /*+ SET_VAR(foreign_key_checks=On) */ from u_tbl2 where u_tbl2.id in ::dml_vals", "Table": "u_tbl2" } ] From 3a5907f1dae52b512b05df0bd942d0bba683a715 Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Thu, 15 Feb 2024 11:31:24 -0500 Subject: [PATCH 19/79] New for loops and some assert/require (#15194) Signed-off-by: Andrew Mason --- examples/compose/client.go | 2 +- examples/compose/vtcompose/vtcompose.go | 46 +------- go/bucketpool/bucketpool_test.go | 141 +++++++----------------- go/cache/theine/bf/bf.go | 4 +- go/cache/theine/list_test.go | 10 +- go/cache/theine/singleflight_test.go | 59 ++++------ go/cache/theine/sketch_test.go | 2 +- go/cache/theine/store.go | 2 +- go/cache/theine/store_test.go | 4 +- go/cache/theine/tlfu_test.go | 6 +- 10 files changed, 79 insertions(+), 197 deletions(-) diff --git a/examples/compose/client.go b/examples/compose/client.go index 8beaef683cd..95d6b4f4815 100644 --- a/examples/compose/client.go +++ b/examples/compose/client.go @@ -53,7 +53,7 @@ func main() { // Insert some messages on random pages. fmt.Println("Inserting into primary...") - for i := 0; i < 3; i++ { + for range 3 { tx, err := db.Begin() if err != nil { fmt.Printf("begin failed: %v\n", err) diff --git a/examples/compose/vtcompose/vtcompose.go b/examples/compose/vtcompose/vtcompose.go index c6df1d72e48..3bcfd8315e5 100644 --- a/examples/compose/vtcompose/vtcompose.go +++ b/examples/compose/vtcompose/vtcompose.go @@ -218,24 +218,6 @@ func main() { writeFile(dockerComposeFile, "docker-compose.yml") } -func applyFilePatch(dockerYaml []byte, patchFile string) []byte { - yamlPatch, err := os.ReadFile(patchFile) - if err != nil { - log.Fatalf("reading yaml patch file %s: %s", patchFile, err) - } - - patch, err := yamlpatch.DecodePatch(yamlPatch) - if err != nil { - log.Fatalf("decoding patch failed: %s", err) - } - - bs, err := patch.Apply(dockerYaml) - if err != nil { - log.Fatalf("applying patch failed: %s", err) - } - return bs -} - func applyJsonInMemoryPatch(vSchemaFile []byte, patchString string) []byte { patch, err := jsonpatch.DecodePatch([]byte(patchString)) if err != nil { @@ -446,7 +428,7 @@ func applyKeyspaceDependentPatches( dockerComposeFile = applyShardPatches(dockerComposeFile, tabAlias, shard, keyspaceData, externalDbInfoMap, opts) } else { // Determine shard range - for i := 0; i < keyspaceData.shards; i++ { + for i := range keyspaceData.shards { if i == 0 { shard = fmt.Sprintf("-%x", interval) } else if i == (keyspaceData.shards - 1) { @@ -517,28 +499,6 @@ func applyShardPatches( return dockerComposeFile } -func generateDefaultShard(tabAlias int, shard string, keyspaceData keyspaceInfo, opts vtOptions) string { - aliases := []int{tabAlias + 1} // primary alias, e.g. 201 - for i := 0; i < keyspaceData.replicaTablets; i++ { - aliases = append(aliases, tabAlias+2+i) // replica aliases, e.g. 202, 203, ... - } - tabletDepends := make([]string, len(aliases)) - for i, tabletId := range aliases { - tabletDepends[i] = fmt.Sprintf("vttablet%d: {condition : service_healthy}", tabletId) - } - // Wait on all shard tablets to be healthy - dependsOn := "depends_on: {" + strings.Join(tabletDepends, ", ") + "}" - - return fmt.Sprintf(` -- op: add - path: /services/init_shard_primary%[2]d - value: - image: vitess/lite:${VITESS_TAG:-latest} - command: ["sh", "-c", "/vt/bin/vtctldclient %[5]s InitShardPrimary --force %[4]s/%[3]s %[6]s-%[2]d "] - %[1]s -`, dependsOn, aliases[0], shard, keyspaceData.keyspace, opts.topologyFlags, opts.cell) -} - func generateExternalPrimary( tabAlias int, shard string, @@ -548,7 +508,7 @@ func generateExternalPrimary( ) string { aliases := []int{tabAlias + 1} // primary alias, e.g. 201 - for i := 0; i < keyspaceData.replicaTablets; i++ { + for i := range keyspaceData.replicaTablets { aliases = append(aliases, tabAlias+2+i) // replica aliases, e.g. 202, 203, ... } @@ -611,7 +571,7 @@ func applyTabletPatches( dbInfo = val } dockerComposeFile = applyInMemoryPatch(dockerComposeFile, generateDefaultTablet(tabAlias+1, shard, "primary", keyspaceData.keyspace, dbInfo, opts)) - for i := 0; i < keyspaceData.replicaTablets; i++ { + for i := range keyspaceData.replicaTablets { dockerComposeFile = applyInMemoryPatch(dockerComposeFile, generateDefaultTablet(tabAlias+2+i, shard, "replica", keyspaceData.keyspace, dbInfo, opts)) } return dockerComposeFile diff --git a/go/bucketpool/bucketpool_test.go b/go/bucketpool/bucketpool_test.go index cc8bcff0eec..af9693a523f 100644 --- a/go/bucketpool/bucketpool_test.go +++ b/go/bucketpool/bucketpool_test.go @@ -19,166 +19,105 @@ package bucketpool import ( "math/rand" "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestPool(t *testing.T) { maxSize := 16384 pool := New(1024, maxSize) - if pool.maxSize != maxSize { - t.Fatalf("Invalid max pool size: %d, expected %d", pool.maxSize, maxSize) - } - if len(pool.pools) != 5 { - t.Fatalf("Invalid number of pools: %d, expected %d", len(pool.pools), 5) - } + require.Equal(t, maxSize, pool.maxSize, "Invalid max pool size") + require.Len(t, pool.pools, 5, "Invalid number of pools") buf := pool.Get(64) - if len(*buf) != 64 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 1024 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 64, "unexpected buf length") + require.Equal(t, 1024, cap(*buf), "unexpected buf cap") // get from same pool, check that length is right buf = pool.Get(128) - if len(*buf) != 128 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 1024 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 128, "unexpected buf length") + require.Equal(t, 1024, cap(*buf), "unexpected buf cap") pool.Put(buf) // get boundary size buf = pool.Get(1024) - if len(*buf) != 1024 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 1024 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 1024, "unexpected buf length") + require.Equal(t, 1024, cap(*buf), "unexpected buf cap") pool.Put(buf) // get from the middle buf = pool.Get(5000) - if len(*buf) != 5000 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 8192 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 5000, "unexpected buf length") + require.Equal(t, 8192, cap(*buf), "unexpected buf cap") pool.Put(buf) // check last pool buf = pool.Get(16383) - if len(*buf) != 16383 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 16384 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 16383, "unexpected buf length") + require.Equal(t, 16384, cap(*buf), "unexpected buf cap") pool.Put(buf) // get big buffer buf = pool.Get(16385) - if len(*buf) != 16385 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 16385 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 16385, "unexpected buf length") + require.Equal(t, 16385, cap(*buf), "unexpected buf cap") pool.Put(buf) } func TestPoolOneSize(t *testing.T) { maxSize := 1024 pool := New(1024, maxSize) - if pool.maxSize != maxSize { - t.Fatalf("Invalid max pool size: %d, expected %d", pool.maxSize, maxSize) - } + require.Equal(t, maxSize, pool.maxSize, "Invalid max pool size") buf := pool.Get(64) - if len(*buf) != 64 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 1024 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 64, "unexpected buf length") + require.Equal(t, 1024, cap(*buf), "unexpected buf cap") pool.Put(buf) buf = pool.Get(1025) - if len(*buf) != 1025 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 1025 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 1025, "unexpected buf length") + require.Equal(t, 1025, cap(*buf), "unexpected buf cap") pool.Put(buf) } func TestPoolTwoSizeNotMultiplier(t *testing.T) { maxSize := 2000 pool := New(1024, maxSize) - if pool.maxSize != maxSize { - t.Fatalf("Invalid max pool size: %d, expected %d", pool.maxSize, maxSize) - } + require.Equal(t, maxSize, pool.maxSize, "Invalid max pool size") buf := pool.Get(64) - if len(*buf) != 64 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 1024 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 64, "unexpected buf length") + require.Equal(t, 1024, cap(*buf), "unexpected buf cap") pool.Put(buf) buf = pool.Get(2001) - if len(*buf) != 2001 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 2001 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 2001, "unexpected buf length") + require.Equal(t, 2001, cap(*buf), "unexpected buf cap") pool.Put(buf) } func TestPoolMaxSizeLessThanMinSize(t *testing.T) { - defer func() { - if r := recover(); r == nil { - t.Errorf("Expected the code to panic") - } - }() - - New(15000, 1024) + assert.Panics(t, func() { New(15000, 1024) }) } func TestPoolWeirdMaxSize(t *testing.T) { maxSize := 15000 pool := New(1024, maxSize) - if pool.maxSize != maxSize { - t.Fatalf("Invalid max pool size: %d, expected %d", pool.maxSize, maxSize) - } + require.Equal(t, maxSize, pool.maxSize, "Invalid max pool size") buf := pool.Get(14000) - if len(*buf) != 14000 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 15000 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 14000, "unexpected buf length") + require.Equal(t, 15000, cap(*buf), "unexpected buf cap") pool.Put(buf) buf = pool.Get(16383) - if len(*buf) != 16383 { - t.Fatalf("unexpected buf length: %d", len(*buf)) - } - if cap(*buf) != 16383 { - t.Fatalf("unexpected buf cap: %d", cap(*buf)) - } + require.Len(t, *buf, 16383, "unexpected buf length") + require.Equal(t, 16383, cap(*buf), "unexpected buf cap") pool.Put(buf) } func TestFuzz(t *testing.T) { maxTestSize := 16384 - for i := 0; i < 20000; i++ { + for range 20000 { minSize := rand.Intn(maxTestSize) if minSize == 0 { minSize = 1 @@ -187,18 +126,12 @@ func TestFuzz(t *testing.T) { p := New(minSize, maxSize) bufSize := rand.Intn(maxTestSize) buf := p.Get(bufSize) - if len(*buf) != bufSize { - t.Fatalf("Invalid length %d, expected %d", len(*buf), bufSize) - } + require.Len(t, *buf, bufSize, "unexpected buf length") sPool := p.findPool(bufSize) if sPool == nil { - if cap(*buf) != len(*buf) { - t.Fatalf("Invalid cap %d, expected %d", cap(*buf), len(*buf)) - } + require.Equal(t, len(*buf), cap(*buf), "unexpected buf cap") } else { - if cap(*buf) != sPool.size { - t.Fatalf("Invalid cap %d, expected %d", cap(*buf), sPool.size) - } + require.Equal(t, sPool.size, cap(*buf), "unexpected buf cap") } p.Put(buf) } diff --git a/go/cache/theine/bf/bf.go b/go/cache/theine/bf/bf.go index f68e34d81e3..97b27a5c217 100644 --- a/go/cache/theine/bf/bf.go +++ b/go/cache/theine/bf/bf.go @@ -54,7 +54,7 @@ func (d *Bloomfilter) EnsureCapacity(capacity int) { func (d *Bloomfilter) Exist(h uint64) bool { h1, h2 := uint32(h), uint32(h>>32) var o uint = 1 - for i := uint32(0); i < d.K; i++ { + for i := range d.K { o &= d.Filter.get((h1 + (i * h2)) & (d.M - 1)) } return o == 1 @@ -65,7 +65,7 @@ func (d *Bloomfilter) Exist(h uint64) bool { func (d *Bloomfilter) Insert(h uint64) bool { h1, h2 := uint32(h), uint32(h>>32) var o uint = 1 - for i := uint32(0); i < d.K; i++ { + for i := range d.K { o &= d.Filter.getset((h1 + (i * h2)) & (d.M - 1)) } return o == 1 diff --git a/go/cache/theine/list_test.go b/go/cache/theine/list_test.go index aad68f5c142..a0b607338dd 100644 --- a/go/cache/theine/list_test.go +++ b/go/cache/theine/list_test.go @@ -28,7 +28,7 @@ func TestList(t *testing.T) { l := NewList[StringKey, string](5, LIST_PROBATION) require.Equal(t, uint(5), l.capacity) require.Equal(t, LIST_PROBATION, l.listType) - for i := 0; i < 5; i++ { + for i := range 5 { evicted := l.PushFront(NewEntry(StringKey(fmt.Sprintf("%d", i)), "", 1)) require.Nil(t, evicted) } @@ -42,7 +42,7 @@ func TestList(t *testing.T) { require.Equal(t, "5/4/3/2/1", l.display()) require.Equal(t, "1/2/3/4/5", l.displayReverse()) - for i := 0; i < 5; i++ { + for i := range 5 { entry := l.PopTail() require.Equal(t, StringKey(fmt.Sprintf("%d", i+1)), entry.key) } @@ -50,7 +50,7 @@ func TestList(t *testing.T) { require.Nil(t, entry) var entries []*Entry[StringKey, string] - for i := 0; i < 5; i++ { + for i := range 5 { new := NewEntry(StringKey(fmt.Sprintf("%d", i)), "", 1) evicted := l.PushFront(new) entries = append(entries, new) @@ -76,13 +76,13 @@ func TestListCountCost(t *testing.T) { l := NewList[StringKey, string](100, LIST_PROBATION) require.Equal(t, uint(100), l.capacity) require.Equal(t, LIST_PROBATION, l.listType) - for i := 0; i < 5; i++ { + for i := range 5 { evicted := l.PushFront(NewEntry(StringKey(fmt.Sprintf("%d", i)), "", 20)) require.Nil(t, evicted) } require.Equal(t, 100, l.len) require.Equal(t, 5, l.count) - for i := 0; i < 3; i++ { + for range 3 { entry := l.PopTail() require.NotNil(t, entry) } diff --git a/go/cache/theine/singleflight_test.go b/go/cache/theine/singleflight_test.go index 60b28e69b4e..4ae235f97e2 100644 --- a/go/cache/theine/singleflight_test.go +++ b/go/cache/theine/singleflight_test.go @@ -32,6 +32,9 @@ import ( "sync/atomic" "testing" "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestDo(t *testing.T) { @@ -39,12 +42,9 @@ func TestDo(t *testing.T) { v, err, _ := g.Do("key", func() (string, error) { return "bar", nil }) - if got, want := fmt.Sprintf("%v (%T)", v, v), "bar (string)"; got != want { - t.Errorf("Do = %v; want %v", got, want) - } - if err != nil { - t.Errorf("Do error = %v", err) - } + + assert.Equal(t, "bar (string)", fmt.Sprintf("%v (%T)", v, v), "incorrect Do value") + assert.NoError(t, err, "got Do error") } func TestDoErr(t *testing.T) { @@ -53,12 +53,9 @@ func TestDoErr(t *testing.T) { v, err, _ := g.Do("key", func() (string, error) { return "", someErr }) - if err != someErr { - t.Errorf("Do error = %v; want someErr %v", err, someErr) - } - if v != "" { - t.Errorf("unexpected non-nil value %#v", v) - } + + assert.ErrorIs(t, err, someErr, "incorrect Do error") + assert.Empty(t, v, "unexpected non-empty value") } func TestDoDupSuppress(t *testing.T) { @@ -81,20 +78,18 @@ func TestDoDupSuppress(t *testing.T) { const n = 10 wg1.Add(1) - for i := 0; i < n; i++ { + for range n { wg1.Add(1) wg2.Add(1) go func() { defer wg2.Done() wg1.Done() v, err, _ := g.Do("key", fn) - if err != nil { - t.Errorf("Do error: %v", err) + if !assert.NoError(t, err, "unexpected Do error") { return } - if s := v; s != "bar" { - t.Errorf("Do = %T %v; want %q", v, v, "bar") - } + + assert.Equal(t, "bar", v, "unexpected Do value") }() } wg1.Wait() @@ -102,9 +97,8 @@ func TestDoDupSuppress(t *testing.T) { // least reached the line before the Do. c <- "bar" wg2.Wait() - if got := atomic.LoadInt32(&calls); got <= 0 || got >= n { - t.Errorf("number of calls = %d; want over 0 and less than %d", got, n) - } + got := atomic.LoadInt32(&calls) + assert.True(t, got > 0 && got < n, "number of calls not between 0 and %d", n) } // Test singleflight behaves correctly after Do panic. @@ -119,7 +113,7 @@ func TestPanicDo(t *testing.T) { waited := int32(n) panicCount := int32(0) done := make(chan struct{}) - for i := 0; i < n; i++ { + for range n { go func() { defer func() { if err := recover(); err != nil { @@ -137,11 +131,9 @@ func TestPanicDo(t *testing.T) { select { case <-done: - if panicCount != n { - t.Errorf("Expect %d panic, but got %d", n, panicCount) - } + assert.Equal(t, int32(n), panicCount, "unexpected number of panics") case <-time.After(time.Second): - t.Fatalf("Do hangs") + require.Fail(t, "Do hangs") } } @@ -155,13 +147,11 @@ func TestGoexitDo(t *testing.T) { const n = 5 waited := int32(n) done := make(chan struct{}) - for i := 0; i < n; i++ { + for range n { go func() { var err error defer func() { - if err != nil { - t.Errorf("Error should be nil, but got: %v", err) - } + assert.NoError(t, err) if atomic.AddInt32(&waited, -1) == 0 { close(done) } @@ -173,7 +163,7 @@ func TestGoexitDo(t *testing.T) { select { case <-done: case <-time.After(time.Second): - t.Fatalf("Do hangs") + require.Fail(t, "Do hangs") } } @@ -201,10 +191,9 @@ func randKeys(b *testing.B, count, length uint) []string { keys := make([]string, 0, count) key := make([]byte, length) - for i := uint(0); i < count; i++ { - if _, err := io.ReadFull(rand.Reader, key); err != nil { - b.Fatalf("Failed to generate random key %d of %d of length %d: %s", i+1, count, length, err) - } + for i := range uint(count) { + _, err := io.ReadFull(rand.Reader, key) + require.NoError(b, err, "Failed to generate random key %d of %d length %d", i+1, count, length) keys = append(keys, string(key)) } return keys diff --git a/go/cache/theine/sketch_test.go b/go/cache/theine/sketch_test.go index 3437f0cac3c..fb53fa8e5fb 100644 --- a/go/cache/theine/sketch_test.go +++ b/go/cache/theine/sketch_test.go @@ -23,7 +23,7 @@ func TestSketch(t *testing.T) { sketch.SampleSize = 5120 failed := 0 - for i := 0; i < 500; i++ { + for i := range 500 { key := fmt.Sprintf("key:%d", i) keyh := xxhash.Sum64String(key) sketch.Add(keyh) diff --git a/go/cache/theine/store.go b/go/cache/theine/store.go index 21ce084e8a5..cef5a89c8b7 100644 --- a/go/cache/theine/store.go +++ b/go/cache/theine/store.go @@ -208,7 +208,7 @@ func NewStore[K cachekey, V cacheval](maxsize int64, doorkeeper bool) *Store[K, writebufsize: writeBufSize, } s.shards = make([]*Shard[K, V], 0, s.shardCount) - for i := 0; i < int(s.shardCount); i++ { + for range s.shardCount { s.shards = append(s.shards, NewShard[K, V](uint(dequeSize), doorkeeper)) } diff --git a/go/cache/theine/store_test.go b/go/cache/theine/store_test.go index 9f337b818ad..e6a2f9d5679 100644 --- a/go/cache/theine/store_test.go +++ b/go/cache/theine/store_test.go @@ -52,7 +52,7 @@ func TestProcessDeque(t *testing.T) { shard := store.shards[index] shard.qsize = 10 - for i := keyint(0); i < 5; i++ { + for i := range keyint(5) { entry := &Entry[keyint, cachedint]{key: i} entry.cost.Store(1) store.shards[index].deque.PushFront(entry) @@ -75,7 +75,7 @@ func TestDoorKeeperDynamicSize(t *testing.T) { store := NewStore[keyint, cachedint](200000, true) shard := store.shards[0] require.True(t, shard.doorkeeper.Capacity == 512) - for i := keyint(0); i < 5000; i++ { + for i := range keyint(5000) { shard.set(i, &Entry[keyint, cachedint]{}) } require.True(t, shard.doorkeeper.Capacity > 100000) diff --git a/go/cache/theine/tlfu_test.go b/go/cache/theine/tlfu_test.go index ac6ddaabdb6..f798f89549f 100644 --- a/go/cache/theine/tlfu_test.go +++ b/go/cache/theine/tlfu_test.go @@ -33,7 +33,7 @@ func TestTlfu(t *testing.T) { require.Equal(t, 0, tlfu.slru.protected.len) var entries []*Entry[StringKey, string] - for i := 0; i < 200; i++ { + for i := range 200 { e := NewEntry(StringKey(fmt.Sprintf("%d", i)), "", 1) evicted := tlfu.Set(e) entries = append(entries, e) @@ -78,7 +78,7 @@ func TestTlfu(t *testing.T) { require.Equal(t, 998, tlfu.slru.probation.len) var entries2 []*Entry[StringKey, string] - for i := 0; i < 1000; i++ { + for i := range 1000 { e := NewEntry(StringKey(fmt.Sprintf("%d*", i)), "", 1) tlfu.Set(e) entries2 = append(entries2, e) @@ -103,7 +103,7 @@ func TestEvictEntries(t *testing.T) { require.Equal(t, 0, tlfu.slru.probation.len) require.Equal(t, 0, tlfu.slru.protected.len) - for i := 0; i < 500; i++ { + for i := range 500 { tlfu.Set(NewEntry(StringKey(fmt.Sprintf("%d:1", i)), "", 1)) } require.Equal(t, 500, tlfu.slru.probation.len) From 7a2f029ce4c16409c576e07545b507cbd4c56328 Mon Sep 17 00:00:00 2001 From: Harshit Gangal Date: Thu, 15 Feb 2024 22:23:52 +0530 Subject: [PATCH 20/79] Fix routing rule query rewrite (#15253) Signed-off-by: Harshit Gangal Signed-off-by: Florent Poinsard <35779988+frouioui@users.noreply.github.com> Signed-off-by: Florent Poinsard Co-authored-by: Florent Poinsard <35779988+frouioui@users.noreply.github.com> Co-authored-by: Florent Poinsard --- go/vt/vtgate/planbuilder/rewrite.go | 1 + .../planbuilder/testdata/dml_cases.json | 73 +++++++++++++++++++ .../planbuilder/testdata/select_cases.json | 22 ++++++ .../planbuilder/testdata/vschemas/schema.json | 9 ++- 4 files changed, 103 insertions(+), 2 deletions(-) diff --git a/go/vt/vtgate/planbuilder/rewrite.go b/go/vt/vtgate/planbuilder/rewrite.go index 396c27bd559..915b5e753cd 100644 --- a/go/vt/vtgate/planbuilder/rewrite.go +++ b/go/vt/vtgate/planbuilder/rewrite.go @@ -70,6 +70,7 @@ func (r *rewriter) rewriteDown(cursor *sqlparser.Cursor) bool { node.As = tableName.Name } // replace the table name with the original table + tableName.Qualifier = sqlparser.IdentifierCS{} tableName.Name = vindexTable.Name node.Expr = tableName } diff --git a/go/vt/vtgate/planbuilder/testdata/dml_cases.json b/go/vt/vtgate/planbuilder/testdata/dml_cases.json index 995795fc209..18ba14db06e 100644 --- a/go/vt/vtgate/planbuilder/testdata/dml_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/dml_cases.json @@ -5828,5 +5828,78 @@ "comment": "update with derived table", "query": "update (select id from user) as u set id = 4", "plan": "VT03031: the target table (select id from `user`) as u of the UPDATE is not updatable" + }, + { + "comment": "Delete with routed table on music", + "query": "delete from second_user.bar", + "plan": { + "QueryType": "DELETE", + "Original": "delete from second_user.bar", + "Instructions": { + "OperatorType": "Delete", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select user_id, id from music as bar for update", + "Query": "delete from music as bar", + "Table": "music" + }, + "TablesUsed": [ + "user.music" + ] + } + }, + { + "comment": "Update with routed table on music", + "query": "update second_user.bar set col = 23", + "plan": { + "QueryType": "UPDATE", + "Original": "update second_user.bar set col = 23", + "Instructions": { + "OperatorType": "Update", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "Query": "update music as bar set col = 23", + "Table": "music" + }, + "TablesUsed": [ + "user.music" + ] + } + }, + { + "comment": "Insert with routed table on music", + "query": "insert into second_user.bar(id) values (2)", + "plan": { + "QueryType": "INSERT", + "Original": "insert into second_user.bar(id) values (2)", + "Instructions": { + "OperatorType": "Insert", + "Variant": "Sharded", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "Query": "insert into music(id, user_id) values (:_id_0, :_user_id_0)", + "TableName": "music", + "VindexValues": { + "music_user_map": "2", + "user_index": "null" + } + }, + "TablesUsed": [ + "user.music" + ] + } } ] diff --git a/go/vt/vtgate/planbuilder/testdata/select_cases.json b/go/vt/vtgate/planbuilder/testdata/select_cases.json index 9e75a2a2f32..0ef10b5247f 100644 --- a/go/vt/vtgate/planbuilder/testdata/select_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/select_cases.json @@ -1651,6 +1651,28 @@ ] } }, + { + "comment": "routing table on music", + "query": "select * from second_user.bar where id > 2", + "plan": { + "QueryType": "SELECT", + "Original": "select * from second_user.bar where id > 2", + "Instructions": { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select * from music as bar where 1 != 1", + "Query": "select * from music as bar where id > 2", + "Table": "music" + }, + "TablesUsed": [ + "user.music" + ] + } + }, { "comment": "testing SingleRow Projection", "query": "select 42", diff --git a/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json b/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json index 70f55c62f1f..7aaa2648388 100644 --- a/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json +++ b/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json @@ -25,6 +25,12 @@ "user.user" ] }, + { + "from_table": "second_user.bar", + "to_tables": [ + "user.music" + ] + }, { "from_table": "primary_redirect@primary", "to_tables": [ @@ -508,8 +514,7 @@ "sharded": true, "vindexes": { "hash_dup": { - "type": "hash_test", - "owner": "user" + "type": "hash_test" } }, "tables": { From de3c9c5813f62fd1d6c6b1386883a2819d0da287 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Thu, 15 Feb 2024 10:54:00 -0600 Subject: [PATCH 21/79] Upgrade the Golang Dependencies (#15241) Signed-off-by: Florent Poinsard Co-authored-by: Florent Poinsard --- go.mod | 77 +++++++++++++------------- go.sum | 168 +++++++++++++++++++++++++-------------------------------- 2 files changed, 111 insertions(+), 134 deletions(-) diff --git a/go.mod b/go.mod index 28cf40c1907..9963f901765 100644 --- a/go.mod +++ b/go.mod @@ -3,14 +3,14 @@ module vitess.io/vitess go 1.22.0 require ( - cloud.google.com/go/storage v1.37.0 + cloud.google.com/go/storage v1.38.0 github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 github.com/Azure/azure-pipeline-go v0.2.3 github.com/Azure/azure-storage-blob-go v0.15.0 github.com/HdrHistogram/hdrhistogram-go v0.9.0 // indirect github.com/aquarapid/vaultlib v0.5.1 github.com/armon/go-metrics v0.4.1 // indirect - github.com/aws/aws-sdk-go v1.50.8 + github.com/aws/aws-sdk-go v1.50.18 github.com/buger/jsonparser v1.1.1 github.com/cespare/xxhash/v2 v2.2.0 github.com/corpix/uarand v0.1.1 // indirect @@ -33,7 +33,7 @@ require ( github.com/hashicorp/serf v0.10.1 // indirect github.com/icrowley/fake v0.0.0-20180203215853-4178557ae428 github.com/jmespath/go-jmespath v0.4.0 // indirect - github.com/klauspost/compress v1.17.5 + github.com/klauspost/compress v1.17.6 github.com/klauspost/pgzip v1.2.6 github.com/krishicks/yaml-patch v0.0.10 github.com/magiconair/properties v1.8.7 // indirect @@ -59,7 +59,7 @@ require ( github.com/spf13/viper v1.18.2 github.com/stretchr/testify v1.8.4 github.com/tchap/go-patricia v2.3.0+incompatible - github.com/tidwall/gjson v1.17.0 + github.com/tidwall/gjson v1.17.1 github.com/tinylib/msgp v1.1.9 // indirect github.com/uber/jaeger-client-go v2.30.0+incompatible github.com/uber/jaeger-lib v2.4.1+incompatible // indirect @@ -69,22 +69,22 @@ require ( go.etcd.io/etcd/client/pkg/v3 v3.5.12 go.etcd.io/etcd/client/v3 v3.5.12 go.uber.org/mock v0.2.0 - golang.org/x/crypto v0.18.0 // indirect - golang.org/x/mod v0.14.0 // indirect - golang.org/x/net v0.20.0 - golang.org/x/oauth2 v0.16.0 - golang.org/x/sys v0.16.0 - golang.org/x/term v0.16.0 + golang.org/x/crypto v0.19.0 // indirect + golang.org/x/mod v0.15.0 // indirect + golang.org/x/net v0.21.0 + golang.org/x/oauth2 v0.17.0 + golang.org/x/sys v0.17.0 + golang.org/x/term v0.17.0 golang.org/x/text v0.14.0 // indirect golang.org/x/time v0.5.0 - golang.org/x/tools v0.17.0 - google.golang.org/api v0.161.0 - google.golang.org/genproto v0.0.0-20240125205218-1f4bbc51befe // indirect - google.golang.org/grpc v1.61.0 + golang.org/x/tools v0.18.0 + google.golang.org/api v0.165.0 + google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 // indirect + google.golang.org/grpc v1.61.1 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0 google.golang.org/grpc/examples v0.0.0-20210430044426-28078834f35b google.golang.org/protobuf v1.32.0 - gopkg.in/DataDog/dd-trace-go.v1 v1.60.0 + gopkg.in/DataDog/dd-trace-go.v1 v1.60.3 gopkg.in/asn1-ber.v1 v1.0.0-20181015200546-f715ec2f112d // indirect gopkg.in/ldap.v2 v2.5.1 sigs.k8s.io/yaml v1.4.0 @@ -105,23 +105,23 @@ require ( github.com/spf13/jwalterweatherman v1.1.0 github.com/xlab/treeprint v1.2.0 go.uber.org/goleak v1.3.0 - golang.org/x/exp v0.0.0-20240119083558-1b970713d09a + golang.org/x/exp v0.0.0-20240213143201-ec583247a57a golang.org/x/sync v0.6.0 gonum.org/v1/gonum v0.14.0 - modernc.org/sqlite v1.28.0 + modernc.org/sqlite v1.29.1 ) require ( cloud.google.com/go v0.112.0 // indirect - cloud.google.com/go/compute v1.23.4 // indirect + cloud.google.com/go/compute v1.24.0 // indirect cloud.google.com/go/compute/metadata v0.2.3 // indirect cloud.google.com/go/iam v1.1.6 // indirect - github.com/DataDog/appsec-internal-go v1.4.0 // indirect + github.com/DataDog/appsec-internal-go v1.4.1 // indirect github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2 // indirect github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 // indirect - github.com/DataDog/go-libddwaf/v2 v2.2.3 // indirect + github.com/DataDog/go-libddwaf/v2 v2.3.2 // indirect github.com/DataDog/go-sqllexer v0.0.10 // indirect - github.com/DataDog/go-tuf v1.0.2-0.5.2 // indirect + github.com/DataDog/go-tuf v1.0.4-0.5.2 // indirect github.com/DataDog/sketches-go v1.4.4 // indirect github.com/Microsoft/go-winio v0.6.1 // indirect github.com/beorn7/perks v1.0.1 // indirect @@ -129,31 +129,34 @@ require ( github.com/coreos/go-systemd/v22 v22.5.0 // indirect github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/dgrijalva/lfu-go v0.0.0-20141010002404-f174e76c5138 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/ebitengine/purego v0.5.2 // indirect + github.com/ebitengine/purego v0.6.0 // indirect github.com/fatih/color v1.16.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/go-logr/logr v1.4.1 // indirect github.com/go-logr/stdr v1.2.2 // indirect + github.com/goccy/go-json v0.10.2 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/google/s2a-go v0.1.7 // indirect github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect - github.com/googleapis/gax-go/v2 v2.12.0 // indirect + github.com/googleapis/gax-go/v2 v2.12.1 // indirect github.com/hashicorp/errwrap v1.1.0 // indirect github.com/hashicorp/go-cleanhttp v0.5.2 // indirect github.com/hashicorp/go-hclog v1.6.2 // indirect github.com/hashicorp/go-multierror v1.1.1 // indirect github.com/hashicorp/go-rootcerts v1.0.2 // indirect github.com/hashicorp/golang-lru v1.0.2 // indirect + github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/hashicorp/hcl v1.0.1-vault-5 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect - github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-ieproxy v0.0.11 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/mattn/go-runewidth v0.0.15 // indirect github.com/mitchellh/go-homedir v1.1.0 // indirect + github.com/ncruces/go-strftime v0.1.9 // indirect github.com/onsi/ginkgo v1.16.5 // indirect github.com/onsi/gomega v1.23.0 // indirect github.com/outcaste-io/ristretto v0.2.3 // indirect @@ -162,7 +165,7 @@ require ( github.com/prometheus/client_model v0.5.0 // indirect github.com/prometheus/procfs v0.12.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect - github.com/rivo/uniseg v0.4.6 // indirect + github.com/rivo/uniseg v0.4.7 // indirect github.com/rogpeppe/go-internal v1.12.0 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/sagikazarmark/locafero v0.4.0 // indirect @@ -174,31 +177,25 @@ require ( github.com/tidwall/match v1.1.1 // indirect github.com/tidwall/pretty v1.2.1 // indirect go.opencensus.io v0.24.0 // indirect - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0 // indirect - go.opentelemetry.io/otel v1.22.0 // indirect - go.opentelemetry.io/otel/metric v1.22.0 // indirect - go.opentelemetry.io/otel/trace v1.22.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.48.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.48.0 // indirect + go.opentelemetry.io/otel v1.23.1 // indirect + go.opentelemetry.io/otel/metric v1.23.1 // indirect + go.opentelemetry.io/otel/trace v1.23.1 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.26.0 // indirect - go4.org/intern v0.0.0-20230525184215-6c62f75575cb // indirect - go4.org/unsafe/assume-no-moving-gc v0.0.0-20231121144256-b99613f794b6 // indirect golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect google.golang.org/appengine v1.6.8 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20240125205218-1f4bbc51befe // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20240213162025-012b6fc9bca9 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240213162025-012b6fc9bca9 // indirect gopkg.in/ini.v1 v1.67.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - inet.af/netaddr v0.0.0-20230525184311-b8eac61e914a // indirect - lukechampine.com/uint128 v1.3.0 // indirect - modernc.org/cc/v3 v3.41.0 // indirect - modernc.org/ccgo/v3 v3.16.15 // indirect - modernc.org/libc v1.40.10 // indirect + modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 // indirect + modernc.org/libc v1.41.0 // indirect modernc.org/mathutil v1.6.0 // indirect modernc.org/memory v1.7.2 // indirect - modernc.org/opt v0.1.3 // indirect modernc.org/strutil v1.2.0 // indirect modernc.org/token v1.1.0 // indirect ) diff --git a/go.sum b/go.sum index 456c1a3e194..89064a955f8 100644 --- a/go.sum +++ b/go.sum @@ -2,14 +2,14 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.112.0 h1:tpFCD7hpHFlQ8yPwT3x+QeXqc2T6+n6T+hmABHfDUSM= cloud.google.com/go v0.112.0/go.mod h1:3jEEVwZ/MHU4djK5t5RHuKOA/GbLddgTdVubX1qnPD4= -cloud.google.com/go/compute v1.23.4 h1:EBT9Nw4q3zyE7G45Wvv3MzolIrCJEuHys5muLY0wvAw= -cloud.google.com/go/compute v1.23.4/go.mod h1:/EJMj55asU6kAFnuZET8zqgwgJ9FvXWXOkkfQZa4ioI= +cloud.google.com/go/compute v1.24.0 h1:phWcR2eWzRJaL/kOiJwfFsPs4BaKq1j6vnpZrc1YlVg= +cloud.google.com/go/compute v1.24.0/go.mod h1:kw1/T+h/+tK2LJK0wiPPx1intgdAM3j/g3hFDlscY40= cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY= cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= cloud.google.com/go/iam v1.1.6 h1:bEa06k05IO4f4uJonbB5iAgKTPpABy1ayxaIZV/GHVc= cloud.google.com/go/iam v1.1.6/go.mod h1:O0zxdPeGBoFdWW3HWmBxJsk0pfvNM/p/qa82rWOGTwI= -cloud.google.com/go/storage v1.37.0 h1:WI8CsaFO8Q9KjPVtsZ5Cmi0dXV25zMoX0FklT7c3Jm4= -cloud.google.com/go/storage v1.37.0/go.mod h1:i34TiT2IhiNDmcj65PqwCjcoUX7Z5pLzS8DEmoiFq1k= +cloud.google.com/go/storage v1.38.0 h1:Az68ZRGlnNTpIBbLjSMIV2BDcwwXYlRlQzis0llkpJg= +cloud.google.com/go/storage v1.38.0/go.mod h1:tlUADB0mAb9BgYls9lq+8MGkfzOXuLrnHXlpHmvFJoY= github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 h1:bvDV9vkmnHYOMsOr4WLk+Vo07yKIzd94sVoIqshQ4bU= github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8= github.com/Azure/azure-pipeline-go v0.2.3 h1:7U9HBg1JFK3jHl5qmo4CTZKFTVgMwdFHMVtCdfBE21U= @@ -28,8 +28,8 @@ github.com/Azure/go-autorest/logger v0.2.1/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZ github.com/Azure/go-autorest/tracing v0.6.0 h1:TYi4+3m5t6K48TGI9AUdb+IzbnSxvnvUMfuitfgcfuo= github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/DataDog/appsec-internal-go v1.4.0 h1:KFI8ElxkJOgpw+cUm9TXK/jh5EZvRaWM07sXlxGg9Ck= -github.com/DataDog/appsec-internal-go v1.4.0/go.mod h1:ONW8aV6R7Thgb4g0bB9ZQCm+oRgyz5eWiW7XoQ19wIc= +github.com/DataDog/appsec-internal-go v1.4.1 h1:xpAS/hBo429pVh7rngquAK2DezUaJjfsX7Wd8cw0aIk= +github.com/DataDog/appsec-internal-go v1.4.1/go.mod h1:rmZ+tpq5ZPKmeOUMYjWFg+q1mRd13mxZwSLBG+xa1ik= github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2 h1:y08IzbpFM/HBaKfgayFZe1FpcbZn6bVPXoZ++93vxv8= github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2/go.mod h1:A4nLJvxlg6BO/8/zg81til9yT0uRPuXDFMAzDMpmgn4= github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 h1:7jn5EOu84uph4sd+pB3vF8LnsdTjhh+1/NnCvfNpG4A= @@ -37,12 +37,12 @@ github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2/go.mod h1:Vc+snp github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= github.com/DataDog/datadog-go/v5 v5.5.0 h1:G5KHeB8pWBNXT4Jtw0zAkhdxEAWSpWH00geHI6LDrKU= github.com/DataDog/datadog-go/v5 v5.5.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= -github.com/DataDog/go-libddwaf/v2 v2.2.3 h1:LpKE8AYhVrEhlmlw6FGD41udtDf7zW/aMdLNbCXpegQ= -github.com/DataDog/go-libddwaf/v2 v2.2.3/go.mod h1:8nX0SYJMB62+fbwYmx5J7zuCGEjiC/RxAo3+AuYJuFE= +github.com/DataDog/go-libddwaf/v2 v2.3.2 h1:pdi9xjWW57IpOpTeOyPuNveEDFLmmInsHDeuZk3TY34= +github.com/DataDog/go-libddwaf/v2 v2.3.2/go.mod h1:gsCdoijYQfj8ce/T2bEDNPZFIYnmHluAgVDpuQOWMZE= github.com/DataDog/go-sqllexer v0.0.10 h1:u07DuRfdlPPmOX/dclb1gcn/zaqWxUiURRRVenKILxc= github.com/DataDog/go-sqllexer v0.0.10/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= -github.com/DataDog/go-tuf v1.0.2-0.5.2 h1:EeZr937eKAWPxJ26IykAdWA4A0jQXJgkhUjqEI/w7+I= -github.com/DataDog/go-tuf v1.0.2-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DataDog/go-tuf v1.0.4-0.5.2 h1:p7Owb1bMhV9CuGpXv2r3gYxcfcKP+lwRi33MLMIEFuo= +github.com/DataDog/go-tuf v1.0.4-0.5.2/go.mod h1:eaweB+HCRl3YBlX3X4/a5WpxErQMPpHw6HRAx4NOWGQ= github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= github.com/DataDog/sketches-go v1.4.4 h1:dF52vzXRFSPOj2IjXSWLvXq3jubL4CI69kwYjJ1w5Z8= @@ -69,8 +69,8 @@ github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJ github.com/armon/go-metrics v0.4.1/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= -github.com/aws/aws-sdk-go v1.50.8 h1:gY0WoOW+/Wz6XmYSgDH9ge3wnAevYDSQWPxxJvqAkP4= -github.com/aws/aws-sdk-go v1.50.8/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/aws-sdk-go v1.50.18 h1:h+FQjxp5sSDqFKScTUXHVahBlqduKtiR0qM18evcvag= +github.com/aws/aws-sdk-go v1.50.18/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= @@ -107,14 +107,15 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgrijalva/lfu-go v0.0.0-20141010002404-f174e76c5138 h1:dnHgW/+2AbIFKEIhb3mXw6OuPNPrMmrJ6GZylDT556s= +github.com/dgrijalva/lfu-go v0.0.0-20141010002404-f174e76c5138/go.mod h1:NBHEfzv9sqF3bQdv4L3+buvhN5JtVkuO1EhpELjZxXk= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/dvyukov/go-fuzz v0.0.0-20210103155950-6a8e9d1f2415/go.mod h1:11Gm+ccJnvAhCNLlf5+cS9KjtbaD5I5zaZpFMsTHWTw= -github.com/ebitengine/purego v0.5.2 h1:r2MQEtkGzZ4LRtFZVAg5bjYKnUbxxloaeuGxH0t7qfs= -github.com/ebitengine/purego v0.5.2/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ= +github.com/ebitengine/purego v0.6.0 h1:Yo9uBc1x+ETQbfEaf6wcBsjrQfCEnh/gaGUg7lguEJY= +github.com/ebitengine/purego v0.6.0/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= @@ -155,6 +156,8 @@ github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrt github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= +github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= @@ -217,8 +220,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs= github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= -github.com/googleapis/gax-go/v2 v2.12.0 h1:A+gCJKdRfqXkr+BIRGtZLibNXf0m1f9E4HG56etFpas= -github.com/googleapis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qKpsEkdD5+I6QGU= +github.com/googleapis/gax-go/v2 v2.12.1 h1:9F8GV9r9ztXyAi00gsMQHNoF51xPZm8uj1dpYt2ZETM= +github.com/googleapis/gax-go/v2 v2.12.1/go.mod h1:61M8vcyyXR2kqKFxKrfA22jaA8JGF7Dc8App1U3H6jc= github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gorilla/handlers v1.5.2 h1:cLTUSsNkgcwhgRqvCNmdbRWG0A3N4F+M2nWKdScwyEE= github.com/gorilla/handlers v1.5.2/go.mod h1:dX+xVpaxdSw+q0Qek8SSsl3dfMk3jNddUkMzo0GtH0w= @@ -267,6 +270,8 @@ github.com/hashicorp/go-version v1.6.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c= github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/hashicorp/hcl v1.0.1-vault-5 h1:kI3hhbbyzr4dldA8UdTb7ZlVVlI2DACdCfz31RPDgJM= github.com/hashicorp/hcl v1.0.1-vault-5/go.mod h1:XYhtn6ijBSAj6n4YqAaf7RBPS4I06AItNorpy+MoQNM= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= @@ -288,12 +293,10 @@ github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCV github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= -github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs= -github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.17.5 h1:d4vBd+7CHydUqpFBgUEKkSdtSugf9YFmSkvUYPquI5E= -github.com/klauspost/compress v1.17.5/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI= +github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU= github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= @@ -353,6 +356,8 @@ github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3Rllmb github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE= github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= +github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/ngdinhtoan/glide-cleanup v0.2.0/go.mod h1:UQzsmiDOb8YV3nOsCxK/c9zPpCZVNoHScRE3EO9pVMM= github.com/nsf/jsondiff v0.0.0-20210926074059-1e845ec5d249 h1:NHrXEjTNQY7P0Zfx1aMrNhpgxHmow66XQtm0aQLY0AE= github.com/nsf/jsondiff v0.0.0-20210926074059-1e845ec5d249/go.mod h1:mpRZBD8SJ55OIICQ3iWH0Yz3cjzA61JdqMLoWXeB2+8= @@ -430,8 +435,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq github.com/richardartoul/molecule v1.0.1-0.20221107223329-32cfee06a052 h1:Qp27Idfgi6ACvFQat5+VJvlYToylpM/hcyLBI3WaKPA= github.com/richardartoul/molecule v1.0.1-0.20221107223329-32cfee06a052/go.mod h1:uvX/8buq8uVeiZiFht+0lqSLBHF+uGV8BrTv8W/SIwk= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rivo/uniseg v0.4.6 h1:Sovz9sDSwbOz9tgUy8JpT+KgCkPYJEN/oYzlJiYTNLg= -github.com/rivo/uniseg v0.4.6/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= @@ -493,8 +498,8 @@ github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= github.com/tchap/go-patricia v2.3.0+incompatible h1:GkY4dP3cEfEASBPPkWd+AmjYxhmDkqO9/zg7R0lSQRs= github.com/tchap/go-patricia v2.3.0+incompatible/go.mod h1:bmLyhP68RS6kStMGxByiQ23RP/odRBOTVjwp2cDyi6I= -github.com/tidwall/gjson v1.17.0 h1:/Jocvlh98kcTfpN2+JzGQWQcqrPQwDrVEMApx/M5ZwM= -github.com/tidwall/gjson v1.17.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= +github.com/tidwall/gjson v1.17.1 h1:wlYEnwqAHgzmhNUFfw7Xalt2JzQvsMx2Se4PcoFCT/U= +github.com/tidwall/gjson v1.17.1/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= @@ -525,18 +530,18 @@ go.etcd.io/etcd/client/v3 v3.5.12 h1:v5lCPXn1pf1Uu3M4laUE2hp/geOTc5uPcYYsNe1lDxg go.etcd.io/etcd/client/v3 v3.5.12/go.mod h1:tSbBCakoWmmddL+BKVAJHa9km+O/E+bumDe9mSbPiqw= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 h1:UNQQKPfTDe1J81ViolILjTKPr9WetKW6uei2hFgJmFs= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0/go.mod h1:r9vWsPS/3AQItv3OSlEJ/E4mbrhUbbw18meOjArPtKQ= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0 h1:sv9kVfal0MK0wBMCOGr+HeJm9v803BkJxGrk2au7j08= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0/go.mod h1:SK2UL73Zy1quvRPonmOmRDiWk1KBV3LyIeeIxcEApWw= -go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y= -go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI= -go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg= -go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.48.0 h1:P+/g8GpuJGYbOp2tAdKrIPUX9JO02q8Q0YNlHolpibA= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.48.0/go.mod h1:tIKj3DbO8N9Y2xo52og3irLsPI4GW02DSMtrVgNMgxg= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.48.0 h1:doUP+ExOpH3spVTLS0FcWGLnQrPct/hD/bCPbDRUEAU= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.48.0/go.mod h1:rdENBZMT2OE6Ne/KLwpiXudnAsbdrdBaqBvTN8M8BgA= +go.opentelemetry.io/otel v1.23.1 h1:Za4UzOqJYS+MUczKI320AtqZHZb7EqxO00jAHE0jmQY= +go.opentelemetry.io/otel v1.23.1/go.mod h1:Td0134eafDLcTS4y+zQ26GE8u3dEuRBiBCTUIRHaikA= +go.opentelemetry.io/otel/metric v1.23.1 h1:PQJmqJ9u2QaJLBOELl1cxIdPcpbwzbkjfEyelTl2rlo= +go.opentelemetry.io/otel/metric v1.23.1/go.mod h1:mpG2QPlAfnK8yNhNJAxDZruU9Y1/HubbC+KyH8FaCWI= go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8= go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E= -go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0= -go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo= +go.opentelemetry.io/otel/trace v1.23.1 h1:4LrmmEd8AU2rFvU1zegmvqW7+kWarxtNOPyeL6HmYY8= +go.opentelemetry.io/otel/trace v1.23.1/go.mod h1:4IpnpJFwr1mo/6HL8XIPJaE9y0+u1KcVmuW7dwFSVrI= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -552,13 +557,6 @@ go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN8 go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= -go4.org/intern v0.0.0-20211027215823-ae77deb06f29/go.mod h1:cS2ma+47FKrLPdXFpr7CuxiTW3eyJbWew4qx0qtQWDA= -go4.org/intern v0.0.0-20230525184215-6c62f75575cb h1:ae7kzL5Cfdmcecbh22ll7lYP3iuUdnfnhiPcSaDgH/8= -go4.org/intern v0.0.0-20230525184215-6c62f75575cb/go.mod h1:Ycrt6raEcnF5FTsLiLKkhBTO6DPX3RCUCUVnks3gFJU= -go4.org/unsafe/assume-no-moving-gc v0.0.0-20211027215541-db492cf91b37/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E= -go4.org/unsafe/assume-no-moving-gc v0.0.0-20230525183740-e7c30c78aeb2/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E= -go4.org/unsafe/assume-no-moving-gc v0.0.0-20231121144256-b99613f794b6 h1:lGdhQUN/cnWdSH3291CUuxSEqc+AsGTiDxPP3r2J0l4= -go4.org/unsafe/assume-no-moving-gc v0.0.0-20231121144256-b99613f794b6/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190128193316-c7b33c32a30b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= @@ -568,11 +566,11 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc= -golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= +golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20240119083558-1b970713d09a h1:Q8/wZp0KX97QFTc2ywcOE0YRjZPVIx+MXInMzdvQqcA= -golang.org/x/exp v0.0.0-20240119083558-1b970713d09a/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08= +golang.org/x/exp v0.0.0-20240213143201-ec583247a57a h1:HinSgX1tJRX3KsL//Gxynpw5CTOAIPhgL4W8PNiIpVE= +golang.org/x/exp v0.0.0-20240213143201-ec583247a57a/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= @@ -581,8 +579,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= -golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.15.0 h1:SernR4v+D55NyBH2QiEQrlBAnj1ECL6AGrA5+dPaMY8= +golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -607,12 +605,12 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8= golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo= -golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= +golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.16.0 h1:aDkGMBSYxElaoP81NpoUoz2oo2R2wHdZpGToUxfyQrQ= -golang.org/x/oauth2 v0.16.0/go.mod h1:hqZ+0LWXsiVoZpeld6jVt06P3adbS2Uu911W1SsJv2o= +golang.org/x/oauth2 v0.17.0 h1:6m3ZPmLEFdVxKKWnKq4VqZ60gutO35zm+zrAHVmHyDQ= +golang.org/x/oauth2 v0.17.0/go.mod h1:OzPDGQiuQMguemayvdylqddI7qcD9lnSDb+1FiwQ5HA= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -647,7 +645,6 @@ golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -664,12 +661,12 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU= -golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE= -golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY= +golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= @@ -691,11 +688,10 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc= -golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps= +golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ= +golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -704,8 +700,8 @@ golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSm golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= gonum.org/v1/gonum v0.14.0 h1:2NiG67LD1tEH0D7kM+ps2V+fXmsAnpUeec7n8tcr4S0= gonum.org/v1/gonum v0.14.0/go.mod h1:AoWeoz0becf9QMWtE8iWXNXc27fK4fNeHNf/oMejGfU= -google.golang.org/api v0.161.0 h1:oYzk/bs26WN10AV7iU7MVJVXBH8oCPS2hHyBiEeFoSU= -google.golang.org/api v0.161.0/go.mod h1:0mu0TpK33qnydLvWqbImq2b1eQ5FHRSDCBzAxX9ZHyw= +google.golang.org/api v0.165.0 h1:zd5d4JIIIaYYsfVy1HzoXYZ9rWCSBxxAglbczzo7Bgc= +google.golang.org/api v0.165.0/go.mod h1:2OatzO7ZDQsoS7IFf3rvsE17/TldiU3F/zxFHeqUB5o= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= @@ -715,12 +711,12 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98 google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= google.golang.org/genproto v0.0.0-20200806141610-86f49bd18e98/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20240125205218-1f4bbc51befe h1:USL2DhxfgRchafRvt/wYyyQNzwgL7ZiURcozOE/Pkvo= -google.golang.org/genproto v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:cc8bqMqtv9gMOr0zHg2Vzff5ULhhL2IXP4sbcn32Dro= -google.golang.org/genproto/googleapis/api v0.0.0-20240125205218-1f4bbc51befe h1:0poefMBYvYbs7g5UkjS6HcxBPaTRAmznle9jnxYoAI8= -google.golang.org/genproto/googleapis/api v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:4jWUdICTdgc3Ibxmr8nAJiiLHwQBY0UI0XZcEMaFKaA= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe h1:bQnxqljG/wqi4NTXu2+DJ3n7APcEA882QZ1JvhQAq9o= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:PAREbraiVEVGVdTZsVWjSbbTtSyGbAgIIvni8a8CD5s= +google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 h1:9+tzLLstTlPTRyJTh+ah5wIMsBW5c4tQwGTN3thOW9Y= +google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:mqHbVIp48Muh7Ywss/AD6I5kNVKZMmAa/QEW58Gxp2s= +google.golang.org/genproto/googleapis/api v0.0.0-20240213162025-012b6fc9bca9 h1:4++qSzdWBUy9/2x8L5KZgwZw+mjJZ2yDSCGMVM0YzRs= +google.golang.org/genproto/googleapis/api v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:PVreiBMirk8ypES6aw9d4p6iiBNSIfZEBqr3UGoAi2E= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240213162025-012b6fc9bca9 h1:hZB7eLIaYlW9qXRfCq/qDaPdbeY3757uARz5Vvfv+cY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:YUWgXUFRPfoYK1IHMuxH5K6nPEXSCzIMljnQ59lLRCk= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= @@ -729,8 +725,8 @@ google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8 google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.61.0 h1:TOvOcuXn30kRao+gfcvsebNEa5iZIiLkisYEkf7R7o0= -google.golang.org/grpc v1.61.0/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= +google.golang.org/grpc v1.61.1 h1:kLAiWrZs7YeDM6MumDe7m3y4aM6wacLzM1Y/wiLP9XY= +google.golang.org/grpc v1.61.1/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0 h1:rNBFJjBCOgVr9pWD7rs/knKL4FRTKgpZmsRfV214zcA= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0/go.mod h1:Dk1tviKTvMCz5tvh7t+fh94dhmQVHuCt2OzJB3CTW9Y= google.golang.org/grpc/examples v0.0.0-20210430044426-28078834f35b h1:D/GTYPo6I1oEo08Bfpuj3xl5XE+UGHj7//5fVyKxhsQ= @@ -750,8 +746,8 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I= google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= -gopkg.in/DataDog/dd-trace-go.v1 v1.60.0 h1:hjDiU6PWRgMoUeSJkXdtimUP76cFzREPIGIIQJD0mYU= -gopkg.in/DataDog/dd-trace-go.v1 v1.60.0/go.mod h1:6aArYrAHjnuaofJ3lKuSRQbhrBx1LcSpiEYCIScJE5Y= +gopkg.in/DataDog/dd-trace-go.v1 v1.60.3 h1:BbAk9qEUKTJcxDqwn7OGlTWTfKPNzt6jbhzmx4m33dw= +gopkg.in/DataDog/dd-trace-go.v1 v1.60.3/go.mod h1:XF/Y0lFGnmgedNXnltCm6hXkt9iwyeVVVFbKhJvVwtY= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/asn1-ber.v1 v1.0.0-20181015200546-f715ec2f112d h1:TxyelI5cVkbREznMhfzycHdkp5cLA7DpE+GKjSslYhM= gopkg.in/asn1-ber.v1 v1.0.0-20181015200546-f715ec2f112d/go.mod h1:cuepJuh7vyXfUyUwEgHQXw849cJrilpS5NeIjOWESAw= @@ -784,35 +780,19 @@ honnef.co/go/gotraceui v0.2.0 h1:dmNsfQ9Vl3GwbiVD7Z8d/osC6WtGGrasyrC2suc4ZIQ= honnef.co/go/gotraceui v0.2.0/go.mod h1:qHo4/W75cA3bX0QQoSvDjbJa4R8mAyyFjbWAj63XElc= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -inet.af/netaddr v0.0.0-20230525184311-b8eac61e914a h1:1XCVEdxrvL6c0TGOhecLuB7U9zYNdxZEjvOqJreKZiM= -inet.af/netaddr v0.0.0-20230525184311-b8eac61e914a/go.mod h1:e83i32mAQOW1LAqEIweALsuK2Uw4mhQadA5r7b0Wobo= -lukechampine.com/uint128 v1.3.0 h1:cDdUVfRwDUDovz610ABgFD17nXD4/uDgVHl2sC3+sbo= -lukechampine.com/uint128 v1.3.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= -modernc.org/cc/v3 v3.41.0 h1:QoR1Sn3YWlmA1T4vLaKZfawdVtSiGx8H+cEojbC7v1Q= -modernc.org/cc/v3 v3.41.0/go.mod h1:Ni4zjJYJ04CDOhG7dn640WGfwBzfE0ecX8TyMB0Fv0Y= -modernc.org/ccgo/v3 v3.16.15 h1:KbDR3ZAVU+wiLyMESPtbtE/Add4elztFyfsWoNTgxS0= -modernc.org/ccgo/v3 v3.16.15/go.mod h1:yT7B+/E2m43tmMOT51GMoM98/MtHIcQQSleGnddkUNI= -modernc.org/ccorpus v1.11.6 h1:J16RXiiqiCgua6+ZvQot4yUuUy8zxgqbqEEUuGPlISk= -modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ= -modernc.org/httpfs v1.0.6 h1:AAgIpFZRXuYnkjftxTAZwMIiwEqAfk8aVB2/oA6nAeM= -modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM= -modernc.org/libc v1.40.10 h1:oCWzNF5k6gedzmiqtOQACV07U4RxWy2qPBTyVWwObjw= -modernc.org/libc v1.40.10/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI= +modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4= +modernc.org/libc v1.41.0 h1:g9YAc6BkKlgORsUWj+JwqoB1wU3o4DE3bM3yvA3k+Gk= +modernc.org/libc v1.41.0/go.mod h1:w0eszPsiXoOnoMJgrXjglgLuDy/bt5RR4y3QzUUeodY= modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E= modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E= -modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4= -modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= -modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ= -modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0= +modernc.org/sqlite v1.29.1 h1:19GY2qvWB4VPw0HppFlZCPAbmxFU41r+qjKZQdQ1ryA= +modernc.org/sqlite v1.29.1/go.mod h1:hG41jCYxOAOoO6BRK66AdRlmOcDzXf7qnwlwjUIOqa0= modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= -modernc.org/tcl v1.15.2 h1:C4ybAYCGJw968e+Me18oW55kD/FexcHbqH2xak1ROSY= -modernc.org/tcl v1.15.2/go.mod h1:3+k/ZaEbKrC8ePv8zJWPtBSW0V7Gg9g8rkmhI1Kfs3c= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= -modernc.org/z v1.7.3 h1:zDJf6iHjrnB+WRD88stbXokugjyc0/pB91ri1gO6LZY= -modernc.org/z v1.7.3/go.mod h1:Ipv4tsdxZRbQyLq9Q1M6gdbkxYzdlrciF2Hi/lS7nWE= sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E= sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY= From 096b8a828b402961d914e1c565c5b4f4e72a0c88 Mon Sep 17 00:00:00 2001 From: Florent Poinsard <35779988+frouioui@users.noreply.github.com> Date: Thu, 15 Feb 2024 15:41:55 -0600 Subject: [PATCH 22/79] Update paths filter action (#15254) Signed-off-by: Florent Poinsard --- .github/workflows/check_make_vtadmin_authz_testgen.yml | 2 +- .github/workflows/check_make_vtadmin_web_proto.yml | 2 +- .github/workflows/cluster_endtoend_12.yml | 2 +- .github/workflows/cluster_endtoend_13.yml | 2 +- .github/workflows/cluster_endtoend_15.yml | 2 +- .github/workflows/cluster_endtoend_18.yml | 2 +- .github/workflows/cluster_endtoend_21.yml | 2 +- .github/workflows/cluster_endtoend_22.yml | 2 +- .github/workflows/cluster_endtoend_backup_pitr.yml | 2 +- .github/workflows/cluster_endtoend_backup_pitr_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_backup_pitr_xtrabackup.yml | 2 +- .../cluster_endtoend_backup_pitr_xtrabackup_mysql57.yml | 2 +- .../workflows/cluster_endtoend_ers_prs_newfeatures_heavy.yml | 2 +- .github/workflows/cluster_endtoend_mysql80.yml | 2 +- .github/workflows/cluster_endtoend_mysql_server_vault.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_ghost.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_ghost_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_revert.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_revert_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_scheduler.yml | 2 +- .../workflows/cluster_endtoend_onlineddl_scheduler_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_vrepl.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_vrepl_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_vrepl_stress.yml | 2 +- .../cluster_endtoend_onlineddl_vrepl_stress_mysql57.yml | 2 +- .../workflows/cluster_endtoend_onlineddl_vrepl_stress_suite.yml | 2 +- .../cluster_endtoend_onlineddl_vrepl_stress_suite_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_onlineddl_vrepl_suite.yml | 2 +- .../cluster_endtoend_onlineddl_vrepl_suite_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_schemadiff_vrepl.yml | 2 +- .github/workflows/cluster_endtoend_schemadiff_vrepl_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_tabletmanager_consul.yml | 2 +- .github/workflows/cluster_endtoend_tabletmanager_tablegc.yml | 2 +- .../cluster_endtoend_tabletmanager_tablegc_mysql57.yml | 2 +- .../workflows/cluster_endtoend_tabletmanager_throttler_topo.yml | 2 +- .github/workflows/cluster_endtoend_topo_connection_cache.yml | 2 +- .../cluster_endtoend_vreplication_across_db_versions.yml | 2 +- .github/workflows/cluster_endtoend_vreplication_basic.yml | 2 +- .github/workflows/cluster_endtoend_vreplication_cellalias.yml | 2 +- .../cluster_endtoend_vreplication_foreign_key_stress.yml | 2 +- .../cluster_endtoend_vreplication_migrate_vdiff2_convert_tz.yml | 2 +- ...endtoend_vreplication_partial_movetables_and_materialize.yml | 2 +- .github/workflows/cluster_endtoend_vreplication_v2.yml | 2 +- .github/workflows/cluster_endtoend_vstream.yml | 2 +- .github/workflows/cluster_endtoend_vtbackup.yml | 2 +- .../cluster_endtoend_vtctlbackup_sharded_clustertest_heavy.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_concurrentdml.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_foreignkey_stress.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_gen4.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_general_heavy.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_godriver.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_partial_keyspace.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_queries.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_readafterwrite.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_reservedconn.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_schema.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_schema_tracker.yml | 2 +- .../cluster_endtoend_vtgate_tablet_healthcheck_cache.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_topo.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_topo_consul.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_topo_etcd.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_transaction.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_unsharded.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_vindex_heavy.yml | 2 +- .github/workflows/cluster_endtoend_vtgate_vschema.yml | 2 +- .github/workflows/cluster_endtoend_vtorc.yml | 2 +- .github/workflows/cluster_endtoend_vtorc_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_vttablet_prscomplex.yml | 2 +- .github/workflows/cluster_endtoend_xb_backup.yml | 2 +- .github/workflows/cluster_endtoend_xb_backup_mysql57.yml | 2 +- .github/workflows/cluster_endtoend_xb_recovery.yml | 2 +- .github/workflows/cluster_endtoend_xb_recovery_mysql57.yml | 2 +- .github/workflows/codecov.yml | 2 +- .github/workflows/docker_test_cluster_10.yml | 2 +- .github/workflows/docker_test_cluster_25.yml | 2 +- .github/workflows/e2e_race.yml | 2 +- .github/workflows/endtoend.yml | 2 +- .github/workflows/local_example.yml | 2 +- .github/workflows/region_example.yml | 2 +- .github/workflows/static_checks_etc.yml | 2 +- .github/workflows/unit_race.yml | 2 +- .github/workflows/unit_test_mysql57.yml | 2 +- .github/workflows/unit_test_mysql80.yml | 2 +- .github/workflows/upgrade_downgrade_test_backups_e2e.yml | 2 +- .../upgrade_downgrade_test_backups_e2e_next_release.yml | 2 +- .github/workflows/upgrade_downgrade_test_backups_manual.yml | 2 +- .../upgrade_downgrade_test_backups_manual_next_release.yml | 2 +- .../workflows/upgrade_downgrade_test_query_serving_queries.yml | 2 +- ...pgrade_downgrade_test_query_serving_queries_next_release.yml | 2 +- .../workflows/upgrade_downgrade_test_query_serving_schema.yml | 2 +- ...upgrade_downgrade_test_query_serving_schema_next_release.yml | 2 +- .github/workflows/upgrade_downgrade_test_reparent_new_vtctl.yml | 2 +- .../workflows/upgrade_downgrade_test_reparent_new_vttablet.yml | 2 +- .github/workflows/upgrade_downgrade_test_reparent_old_vtctl.yml | 2 +- .../workflows/upgrade_downgrade_test_reparent_old_vttablet.yml | 2 +- test/templates/cluster_endtoend_test.tpl | 2 +- test/templates/cluster_endtoend_test_docker.tpl | 2 +- test/templates/cluster_endtoend_test_mysql57.tpl | 2 +- test/templates/cluster_endtoend_test_self_hosted.tpl | 2 +- test/templates/unit_test.tpl | 2 +- test/templates/unit_test_self_hosted.tpl | 2 +- 101 files changed, 101 insertions(+), 101 deletions(-) diff --git a/.github/workflows/check_make_vtadmin_authz_testgen.yml b/.github/workflows/check_make_vtadmin_authz_testgen.yml index a0fff474fb6..8a6bd867db5 100644 --- a/.github/workflows/check_make_vtadmin_authz_testgen.yml +++ b/.github/workflows/check_make_vtadmin_authz_testgen.yml @@ -31,7 +31,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/check_make_vtadmin_web_proto.yml b/.github/workflows/check_make_vtadmin_web_proto.yml index 2eac01bd529..baa86a53964 100644 --- a/.github/workflows/check_make_vtadmin_web_proto.yml +++ b/.github/workflows/check_make_vtadmin_web_proto.yml @@ -31,7 +31,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_12.yml b/.github/workflows/cluster_endtoend_12.yml index f5e8d5952b4..179ee0e0a1a 100644 --- a/.github/workflows/cluster_endtoend_12.yml +++ b/.github/workflows/cluster_endtoend_12.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_13.yml b/.github/workflows/cluster_endtoend_13.yml index 2b9604d8b82..eadfd722f96 100644 --- a/.github/workflows/cluster_endtoend_13.yml +++ b/.github/workflows/cluster_endtoend_13.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_15.yml b/.github/workflows/cluster_endtoend_15.yml index ed1296fd079..ca9c6c29eac 100644 --- a/.github/workflows/cluster_endtoend_15.yml +++ b/.github/workflows/cluster_endtoend_15.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_18.yml b/.github/workflows/cluster_endtoend_18.yml index 4372ca4cda4..395fb895497 100644 --- a/.github/workflows/cluster_endtoend_18.yml +++ b/.github/workflows/cluster_endtoend_18.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_21.yml b/.github/workflows/cluster_endtoend_21.yml index e6cf791b2d3..92de13f00ee 100644 --- a/.github/workflows/cluster_endtoend_21.yml +++ b/.github/workflows/cluster_endtoend_21.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_22.yml b/.github/workflows/cluster_endtoend_22.yml index 79839b51bdb..486d7019b25 100644 --- a/.github/workflows/cluster_endtoend_22.yml +++ b/.github/workflows/cluster_endtoend_22.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_backup_pitr.yml b/.github/workflows/cluster_endtoend_backup_pitr.yml index 13c1a489c25..f96a8a64948 100644 --- a/.github/workflows/cluster_endtoend_backup_pitr.yml +++ b/.github/workflows/cluster_endtoend_backup_pitr.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_backup_pitr_mysql57.yml b/.github/workflows/cluster_endtoend_backup_pitr_mysql57.yml index f4c8520506b..42bb39a4b10 100644 --- a/.github/workflows/cluster_endtoend_backup_pitr_mysql57.yml +++ b/.github/workflows/cluster_endtoend_backup_pitr_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup.yml b/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup.yml index 42d95db5b4b..9457222437c 100644 --- a/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup.yml +++ b/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup_mysql57.yml b/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup_mysql57.yml index 82a5e55dee5..402a9485ca0 100644 --- a/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup_mysql57.yml +++ b/.github/workflows/cluster_endtoend_backup_pitr_xtrabackup_mysql57.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_ers_prs_newfeatures_heavy.yml b/.github/workflows/cluster_endtoend_ers_prs_newfeatures_heavy.yml index 59378877bb2..c46ead2633c 100644 --- a/.github/workflows/cluster_endtoend_ers_prs_newfeatures_heavy.yml +++ b/.github/workflows/cluster_endtoend_ers_prs_newfeatures_heavy.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_mysql80.yml b/.github/workflows/cluster_endtoend_mysql80.yml index 6a4512c02a2..682727916e0 100644 --- a/.github/workflows/cluster_endtoend_mysql80.yml +++ b/.github/workflows/cluster_endtoend_mysql80.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_mysql_server_vault.yml b/.github/workflows/cluster_endtoend_mysql_server_vault.yml index 8663bc12f3c..35cbebcc09a 100644 --- a/.github/workflows/cluster_endtoend_mysql_server_vault.yml +++ b/.github/workflows/cluster_endtoend_mysql_server_vault.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_ghost.yml b/.github/workflows/cluster_endtoend_onlineddl_ghost.yml index 427d8974177..aa4c688983e 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_ghost.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_ghost.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_ghost_mysql57.yml b/.github/workflows/cluster_endtoend_onlineddl_ghost_mysql57.yml index fca1d4edcca..d3658a78370 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_ghost_mysql57.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_ghost_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_revert.yml b/.github/workflows/cluster_endtoend_onlineddl_revert.yml index ccd0b644371..ef627b456d5 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_revert.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_revert.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_revert_mysql57.yml b/.github/workflows/cluster_endtoend_onlineddl_revert_mysql57.yml index a81f0cc151c..01b5744df3d 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_revert_mysql57.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_revert_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_scheduler.yml b/.github/workflows/cluster_endtoend_onlineddl_scheduler.yml index 93647b8d6ca..c41f29f1a5a 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_scheduler.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_scheduler.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_scheduler_mysql57.yml b/.github/workflows/cluster_endtoend_onlineddl_scheduler_mysql57.yml index 642b1ab269b..e12f8a4fdc7 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_scheduler_mysql57.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_scheduler_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl.yml index 9502c9a1763..c241d29dc97 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl_mysql57.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl_mysql57.yml index b132dd92a74..2714520edac 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl_mysql57.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress.yml index 1eedbfb9875..af41c9a04a1 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_mysql57.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_mysql57.yml index 5f3d71f544c..ce76de36f82 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_mysql57.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite.yml index 25b40c92005..1cf7c2e74fb 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite_mysql57.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite_mysql57.yml index c8bef44c3f6..fc4c427794a 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite_mysql57.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl_stress_suite_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite.yml index b5e6981a0de..4cd2663d45c 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite_mysql57.yml b/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite_mysql57.yml index 5def22496af..8e18bd318bd 100644 --- a/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite_mysql57.yml +++ b/.github/workflows/cluster_endtoend_onlineddl_vrepl_suite_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_schemadiff_vrepl.yml b/.github/workflows/cluster_endtoend_schemadiff_vrepl.yml index f0912c7b5ce..869a2fb5b1e 100644 --- a/.github/workflows/cluster_endtoend_schemadiff_vrepl.yml +++ b/.github/workflows/cluster_endtoend_schemadiff_vrepl.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_schemadiff_vrepl_mysql57.yml b/.github/workflows/cluster_endtoend_schemadiff_vrepl_mysql57.yml index 48b1e82bd5a..b15ee2076c1 100644 --- a/.github/workflows/cluster_endtoend_schemadiff_vrepl_mysql57.yml +++ b/.github/workflows/cluster_endtoend_schemadiff_vrepl_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_tabletmanager_consul.yml b/.github/workflows/cluster_endtoend_tabletmanager_consul.yml index 1e68095e41b..bb1ba2f6889 100644 --- a/.github/workflows/cluster_endtoend_tabletmanager_consul.yml +++ b/.github/workflows/cluster_endtoend_tabletmanager_consul.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_tabletmanager_tablegc.yml b/.github/workflows/cluster_endtoend_tabletmanager_tablegc.yml index 509746f5208..31af8d767be 100644 --- a/.github/workflows/cluster_endtoend_tabletmanager_tablegc.yml +++ b/.github/workflows/cluster_endtoend_tabletmanager_tablegc.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_tabletmanager_tablegc_mysql57.yml b/.github/workflows/cluster_endtoend_tabletmanager_tablegc_mysql57.yml index 06ab193074f..a628f79e9b8 100644 --- a/.github/workflows/cluster_endtoend_tabletmanager_tablegc_mysql57.yml +++ b/.github/workflows/cluster_endtoend_tabletmanager_tablegc_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_tabletmanager_throttler_topo.yml b/.github/workflows/cluster_endtoend_tabletmanager_throttler_topo.yml index 52476bbba8b..18a895983ea 100644 --- a/.github/workflows/cluster_endtoend_tabletmanager_throttler_topo.yml +++ b/.github/workflows/cluster_endtoend_tabletmanager_throttler_topo.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_topo_connection_cache.yml b/.github/workflows/cluster_endtoend_topo_connection_cache.yml index d0dd0e55aac..64c45d51f86 100644 --- a/.github/workflows/cluster_endtoend_topo_connection_cache.yml +++ b/.github/workflows/cluster_endtoend_topo_connection_cache.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vreplication_across_db_versions.yml b/.github/workflows/cluster_endtoend_vreplication_across_db_versions.yml index 810b629a4b4..8725ba46582 100644 --- a/.github/workflows/cluster_endtoend_vreplication_across_db_versions.yml +++ b/.github/workflows/cluster_endtoend_vreplication_across_db_versions.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vreplication_basic.yml b/.github/workflows/cluster_endtoend_vreplication_basic.yml index 04ecea976cb..4a708d134ee 100644 --- a/.github/workflows/cluster_endtoend_vreplication_basic.yml +++ b/.github/workflows/cluster_endtoend_vreplication_basic.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vreplication_cellalias.yml b/.github/workflows/cluster_endtoend_vreplication_cellalias.yml index fe262800e68..e5b5296dacf 100644 --- a/.github/workflows/cluster_endtoend_vreplication_cellalias.yml +++ b/.github/workflows/cluster_endtoend_vreplication_cellalias.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vreplication_foreign_key_stress.yml b/.github/workflows/cluster_endtoend_vreplication_foreign_key_stress.yml index 8ec12a51300..ca4145674a9 100644 --- a/.github/workflows/cluster_endtoend_vreplication_foreign_key_stress.yml +++ b/.github/workflows/cluster_endtoend_vreplication_foreign_key_stress.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vreplication_migrate_vdiff2_convert_tz.yml b/.github/workflows/cluster_endtoend_vreplication_migrate_vdiff2_convert_tz.yml index 69b74310451..64178904645 100644 --- a/.github/workflows/cluster_endtoend_vreplication_migrate_vdiff2_convert_tz.yml +++ b/.github/workflows/cluster_endtoend_vreplication_migrate_vdiff2_convert_tz.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vreplication_partial_movetables_and_materialize.yml b/.github/workflows/cluster_endtoend_vreplication_partial_movetables_and_materialize.yml index 72920bfb57a..f50124dd80a 100644 --- a/.github/workflows/cluster_endtoend_vreplication_partial_movetables_and_materialize.yml +++ b/.github/workflows/cluster_endtoend_vreplication_partial_movetables_and_materialize.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vreplication_v2.yml b/.github/workflows/cluster_endtoend_vreplication_v2.yml index f18f696e12a..e8117904cf6 100644 --- a/.github/workflows/cluster_endtoend_vreplication_v2.yml +++ b/.github/workflows/cluster_endtoend_vreplication_v2.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vstream.yml b/.github/workflows/cluster_endtoend_vstream.yml index 3b83e8ebb01..c532fde7774 100644 --- a/.github/workflows/cluster_endtoend_vstream.yml +++ b/.github/workflows/cluster_endtoend_vstream.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtbackup.yml b/.github/workflows/cluster_endtoend_vtbackup.yml index 9477f0f49cc..ea5bd88161a 100644 --- a/.github/workflows/cluster_endtoend_vtbackup.yml +++ b/.github/workflows/cluster_endtoend_vtbackup.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtctlbackup_sharded_clustertest_heavy.yml b/.github/workflows/cluster_endtoend_vtctlbackup_sharded_clustertest_heavy.yml index 7f61eba9103..cad638aa376 100644 --- a/.github/workflows/cluster_endtoend_vtctlbackup_sharded_clustertest_heavy.yml +++ b/.github/workflows/cluster_endtoend_vtctlbackup_sharded_clustertest_heavy.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_concurrentdml.yml b/.github/workflows/cluster_endtoend_vtgate_concurrentdml.yml index f0126ce5be1..da4fdc95b75 100644 --- a/.github/workflows/cluster_endtoend_vtgate_concurrentdml.yml +++ b/.github/workflows/cluster_endtoend_vtgate_concurrentdml.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_foreignkey_stress.yml b/.github/workflows/cluster_endtoend_vtgate_foreignkey_stress.yml index 013d3e25489..b5eaf284b6c 100644 --- a/.github/workflows/cluster_endtoend_vtgate_foreignkey_stress.yml +++ b/.github/workflows/cluster_endtoend_vtgate_foreignkey_stress.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_gen4.yml b/.github/workflows/cluster_endtoend_vtgate_gen4.yml index dd8cb711c22..f446f9ff99d 100644 --- a/.github/workflows/cluster_endtoend_vtgate_gen4.yml +++ b/.github/workflows/cluster_endtoend_vtgate_gen4.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_general_heavy.yml b/.github/workflows/cluster_endtoend_vtgate_general_heavy.yml index e5b08d5a33d..2a71a332567 100644 --- a/.github/workflows/cluster_endtoend_vtgate_general_heavy.yml +++ b/.github/workflows/cluster_endtoend_vtgate_general_heavy.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_godriver.yml b/.github/workflows/cluster_endtoend_vtgate_godriver.yml index 29da66ffa92..2997cebd919 100644 --- a/.github/workflows/cluster_endtoend_vtgate_godriver.yml +++ b/.github/workflows/cluster_endtoend_vtgate_godriver.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_partial_keyspace.yml b/.github/workflows/cluster_endtoend_vtgate_partial_keyspace.yml index e59c7c81b74..de139601780 100644 --- a/.github/workflows/cluster_endtoend_vtgate_partial_keyspace.yml +++ b/.github/workflows/cluster_endtoend_vtgate_partial_keyspace.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_queries.yml b/.github/workflows/cluster_endtoend_vtgate_queries.yml index 8b16849c011..dc456d62be9 100644 --- a/.github/workflows/cluster_endtoend_vtgate_queries.yml +++ b/.github/workflows/cluster_endtoend_vtgate_queries.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_readafterwrite.yml b/.github/workflows/cluster_endtoend_vtgate_readafterwrite.yml index 36c85f7bcbc..43276e7a9bb 100644 --- a/.github/workflows/cluster_endtoend_vtgate_readafterwrite.yml +++ b/.github/workflows/cluster_endtoend_vtgate_readafterwrite.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_reservedconn.yml b/.github/workflows/cluster_endtoend_vtgate_reservedconn.yml index a269a81d7ab..f963bd94e90 100644 --- a/.github/workflows/cluster_endtoend_vtgate_reservedconn.yml +++ b/.github/workflows/cluster_endtoend_vtgate_reservedconn.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_schema.yml b/.github/workflows/cluster_endtoend_vtgate_schema.yml index 249de3b8dd9..72d0d1f7c5a 100644 --- a/.github/workflows/cluster_endtoend_vtgate_schema.yml +++ b/.github/workflows/cluster_endtoend_vtgate_schema.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_schema_tracker.yml b/.github/workflows/cluster_endtoend_vtgate_schema_tracker.yml index 6676ec4379a..517bcf884f8 100644 --- a/.github/workflows/cluster_endtoend_vtgate_schema_tracker.yml +++ b/.github/workflows/cluster_endtoend_vtgate_schema_tracker.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_tablet_healthcheck_cache.yml b/.github/workflows/cluster_endtoend_vtgate_tablet_healthcheck_cache.yml index b4404dc1861..1cf1b1412d3 100644 --- a/.github/workflows/cluster_endtoend_vtgate_tablet_healthcheck_cache.yml +++ b/.github/workflows/cluster_endtoend_vtgate_tablet_healthcheck_cache.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_topo.yml b/.github/workflows/cluster_endtoend_vtgate_topo.yml index 978a0c2c904..e16567209b8 100644 --- a/.github/workflows/cluster_endtoend_vtgate_topo.yml +++ b/.github/workflows/cluster_endtoend_vtgate_topo.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_topo_consul.yml b/.github/workflows/cluster_endtoend_vtgate_topo_consul.yml index 0af8f79a584..a8c0253012c 100644 --- a/.github/workflows/cluster_endtoend_vtgate_topo_consul.yml +++ b/.github/workflows/cluster_endtoend_vtgate_topo_consul.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_topo_etcd.yml b/.github/workflows/cluster_endtoend_vtgate_topo_etcd.yml index 4b5e1bef4f1..c8cdefb4e1a 100644 --- a/.github/workflows/cluster_endtoend_vtgate_topo_etcd.yml +++ b/.github/workflows/cluster_endtoend_vtgate_topo_etcd.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_transaction.yml b/.github/workflows/cluster_endtoend_vtgate_transaction.yml index ae803e25a58..a2a3800d88b 100644 --- a/.github/workflows/cluster_endtoend_vtgate_transaction.yml +++ b/.github/workflows/cluster_endtoend_vtgate_transaction.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_unsharded.yml b/.github/workflows/cluster_endtoend_vtgate_unsharded.yml index a0de14d0e83..2fe07e70596 100644 --- a/.github/workflows/cluster_endtoend_vtgate_unsharded.yml +++ b/.github/workflows/cluster_endtoend_vtgate_unsharded.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_vindex_heavy.yml b/.github/workflows/cluster_endtoend_vtgate_vindex_heavy.yml index f2818f3483f..60043a7fc4a 100644 --- a/.github/workflows/cluster_endtoend_vtgate_vindex_heavy.yml +++ b/.github/workflows/cluster_endtoend_vtgate_vindex_heavy.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtgate_vschema.yml b/.github/workflows/cluster_endtoend_vtgate_vschema.yml index 30c3f8d55b9..fea02a620f7 100644 --- a/.github/workflows/cluster_endtoend_vtgate_vschema.yml +++ b/.github/workflows/cluster_endtoend_vtgate_vschema.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtorc.yml b/.github/workflows/cluster_endtoend_vtorc.yml index d78a4ec0b66..39413d28cde 100644 --- a/.github/workflows/cluster_endtoend_vtorc.yml +++ b/.github/workflows/cluster_endtoend_vtorc.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vtorc_mysql57.yml b/.github/workflows/cluster_endtoend_vtorc_mysql57.yml index a4a32717ae7..c33b13a1323 100644 --- a/.github/workflows/cluster_endtoend_vtorc_mysql57.yml +++ b/.github/workflows/cluster_endtoend_vtorc_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_vttablet_prscomplex.yml b/.github/workflows/cluster_endtoend_vttablet_prscomplex.yml index 1f9b56fecca..7104452f35f 100644 --- a/.github/workflows/cluster_endtoend_vttablet_prscomplex.yml +++ b/.github/workflows/cluster_endtoend_vttablet_prscomplex.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_xb_backup.yml b/.github/workflows/cluster_endtoend_xb_backup.yml index fa1bc41899f..f48b4d3198b 100644 --- a/.github/workflows/cluster_endtoend_xb_backup.yml +++ b/.github/workflows/cluster_endtoend_xb_backup.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_xb_backup_mysql57.yml b/.github/workflows/cluster_endtoend_xb_backup_mysql57.yml index 14d23bd7eac..dec8dba5c41 100644 --- a/.github/workflows/cluster_endtoend_xb_backup_mysql57.yml +++ b/.github/workflows/cluster_endtoend_xb_backup_mysql57.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_xb_recovery.yml b/.github/workflows/cluster_endtoend_xb_recovery.yml index c9c612622db..f00078d92de 100644 --- a/.github/workflows/cluster_endtoend_xb_recovery.yml +++ b/.github/workflows/cluster_endtoend_xb_recovery.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/cluster_endtoend_xb_recovery_mysql57.yml b/.github/workflows/cluster_endtoend_xb_recovery_mysql57.yml index f557888cb75..413cfca1622 100644 --- a/.github/workflows/cluster_endtoend_xb_recovery_mysql57.yml +++ b/.github/workflows/cluster_endtoend_xb_recovery_mysql57.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index 08e395f31e4..817d9b4135e 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -16,7 +16,7 @@ jobs: uses: actions/checkout@v3 - name: Check for changes in files relevant to code coverage - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/docker_test_cluster_10.yml b/.github/workflows/docker_test_cluster_10.yml index cb3bca1ff4e..155057bee3b 100644 --- a/.github/workflows/docker_test_cluster_10.yml +++ b/.github/workflows/docker_test_cluster_10.yml @@ -31,7 +31,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/docker_test_cluster_25.yml b/.github/workflows/docker_test_cluster_25.yml index 7d1d6224542..24ba24bd2d7 100644 --- a/.github/workflows/docker_test_cluster_25.yml +++ b/.github/workflows/docker_test_cluster_25.yml @@ -31,7 +31,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/e2e_race.yml b/.github/workflows/e2e_race.yml index a1db965adec..bfedef56c80 100644 --- a/.github/workflows/e2e_race.yml +++ b/.github/workflows/e2e_race.yml @@ -30,7 +30,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/endtoend.yml b/.github/workflows/endtoend.yml index f6846fe51d3..7c8ac2bfefa 100644 --- a/.github/workflows/endtoend.yml +++ b/.github/workflows/endtoend.yml @@ -30,7 +30,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/local_example.yml b/.github/workflows/local_example.yml index b6bc1335285..76b062c4f22 100644 --- a/.github/workflows/local_example.yml +++ b/.github/workflows/local_example.yml @@ -34,7 +34,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/region_example.yml b/.github/workflows/region_example.yml index 887758bbfd3..f6c009eabfc 100644 --- a/.github/workflows/region_example.yml +++ b/.github/workflows/region_example.yml @@ -34,7 +34,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/static_checks_etc.yml b/.github/workflows/static_checks_etc.yml index a9b9ca039c9..8d00930cf75 100644 --- a/.github/workflows/static_checks_etc.yml +++ b/.github/workflows/static_checks_etc.yml @@ -42,7 +42,7 @@ jobs: - name: Check for changes in Go files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/unit_race.yml b/.github/workflows/unit_race.yml index 5f77bfd667b..f0059511357 100644 --- a/.github/workflows/unit_race.yml +++ b/.github/workflows/unit_race.yml @@ -35,7 +35,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/unit_test_mysql57.yml b/.github/workflows/unit_test_mysql57.yml index 630b3362100..e4567d39085 100644 --- a/.github/workflows/unit_test_mysql57.yml +++ b/.github/workflows/unit_test_mysql57.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/unit_test_mysql80.yml b/.github/workflows/unit_test_mysql80.yml index d52fbb33152..1e752bf431b 100644 --- a/.github/workflows/unit_test_mysql80.yml +++ b/.github/workflows/unit_test_mysql80.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_backups_e2e.yml b/.github/workflows/upgrade_downgrade_test_backups_e2e.yml index 264b9cc73f7..c0fd1cbf829 100644 --- a/.github/workflows/upgrade_downgrade_test_backups_e2e.yml +++ b/.github/workflows/upgrade_downgrade_test_backups_e2e.yml @@ -49,7 +49,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_backups_e2e_next_release.yml b/.github/workflows/upgrade_downgrade_test_backups_e2e_next_release.yml index 346e27f4238..1ea62e10b09 100644 --- a/.github/workflows/upgrade_downgrade_test_backups_e2e_next_release.yml +++ b/.github/workflows/upgrade_downgrade_test_backups_e2e_next_release.yml @@ -51,7 +51,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_backups_manual.yml b/.github/workflows/upgrade_downgrade_test_backups_manual.yml index 81bfded87ae..aab3d1aee00 100644 --- a/.github/workflows/upgrade_downgrade_test_backups_manual.yml +++ b/.github/workflows/upgrade_downgrade_test_backups_manual.yml @@ -52,7 +52,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_backups_manual_next_release.yml b/.github/workflows/upgrade_downgrade_test_backups_manual_next_release.yml index 50479df56c5..6e8cb842102 100644 --- a/.github/workflows/upgrade_downgrade_test_backups_manual_next_release.yml +++ b/.github/workflows/upgrade_downgrade_test_backups_manual_next_release.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_query_serving_queries.yml b/.github/workflows/upgrade_downgrade_test_query_serving_queries.yml index 4a5d56d5210..00dab6edccc 100644 --- a/.github/workflows/upgrade_downgrade_test_query_serving_queries.yml +++ b/.github/workflows/upgrade_downgrade_test_query_serving_queries.yml @@ -52,7 +52,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_query_serving_queries_next_release.yml b/.github/workflows/upgrade_downgrade_test_query_serving_queries_next_release.yml index 76875d3b5d0..a29df51f57c 100644 --- a/.github/workflows/upgrade_downgrade_test_query_serving_queries_next_release.yml +++ b/.github/workflows/upgrade_downgrade_test_query_serving_queries_next_release.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_query_serving_schema.yml b/.github/workflows/upgrade_downgrade_test_query_serving_schema.yml index 6b1a7b4a55d..86a40081d56 100644 --- a/.github/workflows/upgrade_downgrade_test_query_serving_schema.yml +++ b/.github/workflows/upgrade_downgrade_test_query_serving_schema.yml @@ -52,7 +52,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_query_serving_schema_next_release.yml b/.github/workflows/upgrade_downgrade_test_query_serving_schema_next_release.yml index d6fb71f20e3..59fba0a3f9f 100644 --- a/.github/workflows/upgrade_downgrade_test_query_serving_schema_next_release.yml +++ b/.github/workflows/upgrade_downgrade_test_query_serving_schema_next_release.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_reparent_new_vtctl.yml b/.github/workflows/upgrade_downgrade_test_reparent_new_vtctl.yml index ca2caa3b723..c49b0b85fae 100644 --- a/.github/workflows/upgrade_downgrade_test_reparent_new_vtctl.yml +++ b/.github/workflows/upgrade_downgrade_test_reparent_new_vtctl.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_reparent_new_vttablet.yml b/.github/workflows/upgrade_downgrade_test_reparent_new_vttablet.yml index 6952ca08ca5..3f6fee94d7e 100644 --- a/.github/workflows/upgrade_downgrade_test_reparent_new_vttablet.yml +++ b/.github/workflows/upgrade_downgrade_test_reparent_new_vttablet.yml @@ -53,7 +53,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_reparent_old_vtctl.yml b/.github/workflows/upgrade_downgrade_test_reparent_old_vtctl.yml index f7dfe8df201..c2e0349f3fb 100644 --- a/.github/workflows/upgrade_downgrade_test_reparent_old_vtctl.yml +++ b/.github/workflows/upgrade_downgrade_test_reparent_old_vtctl.yml @@ -52,7 +52,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/.github/workflows/upgrade_downgrade_test_reparent_old_vttablet.yml b/.github/workflows/upgrade_downgrade_test_reparent_old_vttablet.yml index e63ec71fb22..2392d5842e3 100644 --- a/.github/workflows/upgrade_downgrade_test_reparent_old_vttablet.yml +++ b/.github/workflows/upgrade_downgrade_test_reparent_old_vttablet.yml @@ -52,7 +52,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/test/templates/cluster_endtoend_test.tpl b/test/templates/cluster_endtoend_test.tpl index 41b743db5da..ef1a991c169 100644 --- a/test/templates/cluster_endtoend_test.tpl +++ b/test/templates/cluster_endtoend_test.tpl @@ -47,7 +47,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/test/templates/cluster_endtoend_test_docker.tpl b/test/templates/cluster_endtoend_test_docker.tpl index 76267230108..9f06cb372c3 100644 --- a/test/templates/cluster_endtoend_test_docker.tpl +++ b/test/templates/cluster_endtoend_test_docker.tpl @@ -32,7 +32,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/test/templates/cluster_endtoend_test_mysql57.tpl b/test/templates/cluster_endtoend_test_mysql57.tpl index 5fcdc63723e..9f9e51fbc69 100644 --- a/test/templates/cluster_endtoend_test_mysql57.tpl +++ b/test/templates/cluster_endtoend_test_mysql57.tpl @@ -52,7 +52,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/test/templates/cluster_endtoend_test_self_hosted.tpl b/test/templates/cluster_endtoend_test_self_hosted.tpl index 020970bd93a..55c891ab95c 100644 --- a/test/templates/cluster_endtoend_test_self_hosted.tpl +++ b/test/templates/cluster_endtoend_test_self_hosted.tpl @@ -35,7 +35,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/test/templates/unit_test.tpl b/test/templates/unit_test.tpl index cf90b448547..bbd76dfa3a7 100644 --- a/test/templates/unit_test.tpl +++ b/test/templates/unit_test.tpl @@ -47,7 +47,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' diff --git a/test/templates/unit_test_self_hosted.tpl b/test/templates/unit_test_self_hosted.tpl index 45d88392b9b..0e8c97d4907 100644 --- a/test/templates/unit_test_self_hosted.tpl +++ b/test/templates/unit_test_self_hosted.tpl @@ -34,7 +34,7 @@ jobs: - name: Check for changes in relevant files if: steps.skip-workflow.outputs.skip-workflow == 'false' - uses: frouioui/paths-filter@main + uses: dorny/paths-filter@v3.0.1 id: changes with: token: '' From 1c9388e955f2fc1046ea342a940ab7febc263893 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Thu, 15 Feb 2024 16:46:28 -0500 Subject: [PATCH 23/79] VReplication: disable foreign_key_checks for bulk data cleanup (#15261) Signed-off-by: Matt Lord --- .../endtoend/vreplication/fk_config_test.go | 27 +- go/test/endtoend/vreplication/fk_test.go | 33 +- .../tabletmanagerdata/tabletmanagerdata.pb.go | 1006 +++++++++-------- .../tabletmanagerdata_vtproto.pb.go | 42 +- go/vt/vtctl/workflow/traffic_switcher.go | 16 +- go/vt/vttablet/grpctmclient/client.go | 11 +- go/vt/vttablet/tabletmanager/rpc_query.go | 24 +- .../tabletmanager/vdiff/stats_test.go | 2 +- go/vt/wrangler/traffic_switcher.go | 15 +- go/vt/wrangler/traffic_switcher_test.go | 2 + go/vt/wrangler/workflow_test.go | 2 + proto/tabletmanagerdata.proto | 1 + web/vtadmin/src/proto/vtadmin.d.ts | 6 + web/vtadmin/src/proto/vtadmin.js | 23 + 14 files changed, 687 insertions(+), 523 deletions(-) diff --git a/go/test/endtoend/vreplication/fk_config_test.go b/go/test/endtoend/vreplication/fk_config_test.go index deda1a1b296..97d868cb371 100644 --- a/go/test/endtoend/vreplication/fk_config_test.go +++ b/go/test/endtoend/vreplication/fk_config_test.go @@ -21,16 +21,23 @@ var ( create table parent(id int, name varchar(128), primary key(id)) engine=innodb; create table child(id int, parent_id int, name varchar(128), primary key(id), foreign key(parent_id) references parent(id) on delete cascade) engine=innodb; create view vparent as select * from parent; +create table t1(id int, name varchar(128), primary key(id)) engine=innodb; +create table t2(id int, t1id int, name varchar(128), primary key(id), foreign key(t1id) references t1(id) on delete cascade) engine=innodb; ` initialFKData = ` insert into parent values(1, 'parent1'), (2, 'parent2'); -insert into child values(1, 1, 'child11'), (2, 1, 'child21'), (3, 2, 'child32');` +insert into child values(1, 1, 'child11'), (2, 1, 'child21'), (3, 2, 'child32'); +insert into t1 values(1, 't11'), (2, 't12'); +insert into t2 values(1, 1, 't21'), (2, 1, 't22'), (3, 2, 't23'); +` initialFKSourceVSchema = ` { "tables": { "parent": {}, - "child": {} + "child": {}, + "t1": {}, + "t2": {} } } ` @@ -59,6 +66,22 @@ insert into child values(1, 1, 'child11'), (2, 1, 'child21'), (3, 2, 'child32'); "name": "reverse_bits" } ] + }, + "t1": { + "column_vindexes": [ + { + "column": "id", + "name": "reverse_bits" + } + ] + }, + "t2": { + "column_vindexes": [ + { + "column": "t1id", + "name": "reverse_bits" + } + ] } } } diff --git a/go/test/endtoend/vreplication/fk_test.go b/go/test/endtoend/vreplication/fk_test.go index a313de09488..5d6cbb7b94c 100644 --- a/go/test/endtoend/vreplication/fk_test.go +++ b/go/test/endtoend/vreplication/fk_test.go @@ -34,6 +34,8 @@ import ( binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" ) +const testWorkflowFlavor = workflowFlavorRandom + // TestFKWorkflow runs a MoveTables workflow with atomic copy for a db with foreign key constraints. // It inserts initial data, then simulates load. We insert both child rows with foreign keys and those without, // i.e. with foreign_key_checks=0. @@ -77,10 +79,13 @@ func TestFKWorkflow(t *testing.T) { }() go ls.simulateLoad() } + targetKeyspace := "fktarget" targetTabletId := 200 vc.AddKeyspace(t, []*Cell{cell}, targetKeyspace, shardName, initialFKTargetVSchema, "", 0, 0, targetTabletId, sourceKsOpts) + testFKCancel(t, vc) + workflowName := "fk" ksWorkflow := fmt.Sprintf("%s.%s", targetKeyspace, workflowName) @@ -92,7 +97,7 @@ func TestFKWorkflow(t *testing.T) { }, sourceKeyspace: sourceKeyspace, atomicCopy: true, - }, workflowFlavorRandom) + }, testWorkflowFlavor) mt.Create() waitForWorkflowState(t, vc, ksWorkflow, binlogdatapb.VReplicationWorkflowState_Running.String()) @@ -122,6 +127,7 @@ func TestFKWorkflow(t *testing.T) { cancel() <-ch } + mt.Complete() } func insertInitialFKData(t *testing.T) { @@ -136,6 +142,9 @@ func insertInitialFKData(t *testing.T) { log.Infof("Done inserting initial FK data") waitForRowCount(t, vtgateConn, db, "parent", 2) waitForRowCount(t, vtgateConn, db, "child", 3) + waitForRowCount(t, vtgateConn, db, "t1", 2) + waitForRowCount(t, vtgateConn, db, "t2", 3) + }) } @@ -269,3 +278,25 @@ func (ls *fkLoadSimulator) exec(query string) *sqltypes.Result { require.NotNil(t, qr) return qr } + +// testFKCancel confirms that a MoveTables workflow which includes tables with foreign key +// constraints, where the parent table is lexicographically sorted before the child table and +// thus may be dropped first, can be successfully cancelled. +func testFKCancel(t *testing.T, vc *VitessCluster) { + var targetKeyspace = "fktarget" + var sourceKeyspace = "fksource" + var workflowName = "wf2" + var ksWorkflow = fmt.Sprintf("%s.%s", targetKeyspace, workflowName) + mt := newMoveTables(vc, &moveTablesWorkflow{ + workflowInfo: &workflowInfo{ + vc: vc, + workflowName: workflowName, + targetKeyspace: targetKeyspace, + }, + sourceKeyspace: sourceKeyspace, + atomicCopy: true, + }, testWorkflowFlavor) + mt.Create() + waitForWorkflowState(t, vc, ksWorkflow, binlogdatapb.VReplicationWorkflowState_Running.String()) + mt.Cancel() +} diff --git a/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go b/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go index 3f6535c570c..446b44cdddc 100644 --- a/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go +++ b/go/vt/proto/tabletmanagerdata/tabletmanagerdata.pb.go @@ -2044,11 +2044,12 @@ type ExecuteFetchAsDbaRequest struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Query []byte `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` - DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"` - MaxRows uint64 `protobuf:"varint,3,opt,name=max_rows,json=maxRows,proto3" json:"max_rows,omitempty"` - DisableBinlogs bool `protobuf:"varint,4,opt,name=disable_binlogs,json=disableBinlogs,proto3" json:"disable_binlogs,omitempty"` - ReloadSchema bool `protobuf:"varint,5,opt,name=reload_schema,json=reloadSchema,proto3" json:"reload_schema,omitempty"` + Query []byte `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` + DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"` + MaxRows uint64 `protobuf:"varint,3,opt,name=max_rows,json=maxRows,proto3" json:"max_rows,omitempty"` + DisableBinlogs bool `protobuf:"varint,4,opt,name=disable_binlogs,json=disableBinlogs,proto3" json:"disable_binlogs,omitempty"` + ReloadSchema bool `protobuf:"varint,5,opt,name=reload_schema,json=reloadSchema,proto3" json:"reload_schema,omitempty"` + DisableForeignKeyChecks bool `protobuf:"varint,6,opt,name=disable_foreign_key_checks,json=disableForeignKeyChecks,proto3" json:"disable_foreign_key_checks,omitempty"` } func (x *ExecuteFetchAsDbaRequest) Reset() { @@ -2118,6 +2119,13 @@ func (x *ExecuteFetchAsDbaRequest) GetReloadSchema() bool { return false } +func (x *ExecuteFetchAsDbaRequest) GetDisableForeignKeyChecks() bool { + if x != nil { + return x.DisableForeignKeyChecks + } + return false +} + type ExecuteFetchAsDbaResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -6423,7 +6431,7 @@ var file_tabletmanagerdata_proto_rawDesc = []byte{ 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, - 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0xb2, 0x01, 0x0a, 0x18, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0xef, 0x01, 0x0a, 0x18, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x44, 0x62, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x62, 0x5f, 0x6e, @@ -6434,508 +6442,512 @@ var file_tabletmanagerdata_proto_rawDesc = []byte{ 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, - 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x47, 0x0a, 0x19, 0x45, 0x78, - 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x44, 0x62, 0x61, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, - 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x22, 0x8e, 0x01, 0x0a, 0x1d, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, - 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x41, 0x6c, 0x6c, 0x50, 0x72, 0x69, 0x76, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x64, - 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x62, - 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x6f, 0x77, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x52, 0x6f, 0x77, 0x73, 0x12, - 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x22, 0x4c, 0x0a, 0x1e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, - 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x41, 0x6c, 0x6c, 0x50, 0x72, 0x69, 0x76, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, - 0x6c, 0x74, 0x22, 0x4b, 0x0a, 0x18, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, - 0x63, 0x68, 0x41, 0x73, 0x41, 0x70, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, - 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x6f, 0x77, 0x73, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x52, 0x6f, 0x77, 0x73, 0x22, - 0x47, 0x0a, 0x19, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, - 0x73, 0x41, 0x70, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, - 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x1a, 0x0a, 0x18, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x22, 0x4c, 0x0a, 0x19, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x17, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x22, 0x16, 0x0a, 0x14, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x4f, 0x0a, 0x15, 0x50, 0x72, - 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x50, - 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x35, 0x0a, 0x17, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, - 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x34, 0x0a, 0x16, - 0x57, 0x61, 0x69, 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x22, 0x19, 0x0a, 0x17, 0x57, 0x61, 0x69, 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, 0x0a, - 0x16, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x19, 0x0a, 0x17, 0x53, 0x74, 0x6f, 0x70, 0x52, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x5e, 0x0a, 0x1d, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x21, 0x0a, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x77, 0x61, 0x69, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x6f, - 0x75, 0x74, 0x22, 0x3c, 0x0a, 0x1e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x22, 0x35, 0x0a, 0x17, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x73, - 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, - 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x1a, 0x0a, 0x18, 0x53, 0x74, 0x61, 0x72, 0x74, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x62, 0x0a, 0x21, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x74, 0x69, 0x6c, 0x41, 0x66, 0x74, 0x65, - 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x6f, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x77, 0x61, 0x69, 0x74, - 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x24, 0x0a, 0x22, 0x53, 0x74, 0x61, 0x72, 0x74, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x74, 0x69, 0x6c, - 0x41, 0x66, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x14, 0x0a, - 0x12, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x22, 0x2b, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x64, - 0x64, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x61, 0x64, 0x64, 0x72, 0x73, - 0x22, 0x19, 0x0a, 0x17, 0x52, 0x65, 0x73, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x1a, 0x0a, 0x18, 0x52, - 0x65, 0x73, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0x0a, 0x17, 0x56, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x22, 0x46, 0x0a, 0x18, 0x56, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x73, 0x70, + 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x3b, 0x0a, 0x1a, 0x64, 0x69, + 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6b, 0x65, + 0x79, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x17, + 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4b, 0x65, + 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x22, 0x47, 0x0a, 0x19, 0x45, 0x78, 0x65, 0x63, 0x75, + 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x44, 0x62, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x22, 0x4b, 0x0a, 0x1d, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x57, 0x61, 0x69, 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, - 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x20, 0x0a, - 0x1e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x61, 0x69, - 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x30, 0x0a, 0x12, 0x49, 0x6e, 0x69, 0x74, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, - 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, - 0x63, 0x22, 0x31, 0x0a, 0x13, 0x49, 0x6e, 0x69, 0x74, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xd8, 0x01, 0x0a, 0x1e, 0x50, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, - 0x65, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x5f, - 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, 0x12, - 0x1f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x3a, 0x0a, 0x0d, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x61, 0x6c, 0x69, 0x61, - 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0c, - 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x31, 0x0a, 0x14, - 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x72, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, - 0x21, 0x0a, 0x1f, 0x50, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70, 0x61, 0x72, - 0x65, 0x6e, 0x74, 0x4a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0xba, 0x01, 0x0a, 0x12, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x70, 0x61, 0x72, - 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, - 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x0f, 0x74, - 0x69, 0x6d, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x03, + 0x22, 0x8e, 0x01, 0x0a, 0x1d, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, + 0x68, 0x41, 0x73, 0x41, 0x6c, 0x6c, 0x50, 0x72, 0x69, 0x76, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x62, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x62, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x52, 0x6f, 0x77, 0x73, 0x12, 0x23, 0x0a, 0x0d, + 0x72, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x22, 0x4c, 0x0a, 0x1e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, + 0x68, 0x41, 0x73, 0x41, 0x6c, 0x6c, 0x50, 0x72, 0x69, 0x76, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, + 0x4b, 0x0a, 0x18, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, + 0x73, 0x41, 0x70, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x52, 0x6f, 0x77, 0x73, 0x22, 0x47, 0x0a, 0x19, + 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x46, 0x65, 0x74, 0x63, 0x68, 0x41, 0x73, 0x41, 0x70, + 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x1a, 0x0a, 0x18, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x22, 0x4c, 0x0a, 0x19, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, + 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, + 0x16, 0x0a, 0x14, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x4f, 0x0a, 0x15, 0x50, 0x72, 0x69, 0x6d, 0x61, + 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x36, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x50, 0x72, 0x69, 0x6d, + 0x61, 0x72, 0x79, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x22, 0x35, 0x0a, 0x17, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, + 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x34, 0x0a, 0x16, 0x57, 0x61, 0x69, + 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0x19, 0x0a, 0x17, 0x57, 0x61, 0x69, 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x18, 0x0a, 0x16, 0x53, 0x74, + 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x22, 0x19, 0x0a, 0x17, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x5e, 0x0a, 0x1d, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, + 0x77, 0x61, 0x69, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0b, 0x77, 0x61, 0x69, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, + 0x3c, 0x0a, 0x1e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x35, 0x0a, + 0x17, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, + 0x53, 0x79, 0x6e, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, + 0x53, 0x79, 0x6e, 0x63, 0x22, 0x1a, 0x0a, 0x18, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x62, 0x0a, 0x21, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x74, 0x69, 0x6c, 0x41, 0x66, 0x74, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, + 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x77, 0x61, 0x69, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x6f, 0x75, 0x74, 0x22, 0x24, 0x0a, 0x22, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x74, 0x69, 0x6c, 0x41, 0x66, 0x74, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x14, 0x0a, 0x12, 0x47, 0x65, + 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x22, 0x2b, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x64, 0x64, 0x72, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x61, 0x64, 0x64, 0x72, 0x73, 0x22, 0x19, 0x0a, + 0x17, 0x52, 0x65, 0x73, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x1a, 0x0a, 0x18, 0x52, 0x65, 0x73, 0x65, + 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0x0a, 0x17, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x22, 0x46, 0x0a, 0x18, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x4b, 0x0a, + 0x1d, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x61, 0x69, + 0x74, 0x46, 0x6f, 0x72, 0x50, 0x6f, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, + 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x20, 0x0a, 0x1e, 0x56, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x61, 0x69, 0x74, 0x46, 0x6f, + 0x72, 0x50, 0x6f, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x0a, 0x12, + 0x49, 0x6e, 0x69, 0x74, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x31, + 0x0a, 0x13, 0x49, 0x6e, 0x69, 0x74, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0xd8, 0x01, 0x0a, 0x1e, 0x50, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x65, + 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x4a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, + 0x69, 0x6d, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, 0x12, 0x1f, 0x0a, 0x0b, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3a, 0x0a, + 0x0d, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0c, 0x70, 0x72, 0x69, + 0x6d, 0x61, 0x72, 0x79, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x21, 0x0a, 0x1f, + 0x50, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, + 0x4a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0xba, 0x01, 0x0a, 0x12, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, + 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, + 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x15, 0x0a, 0x13, + 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x72, 0x69, + 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x64, 0x0a, 0x15, 0x44, + 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0e, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, + 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0d, 0x70, 0x72, + 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4a, 0x04, 0x08, 0x01, 0x10, + 0x02, 0x22, 0x36, 0x0a, 0x18, 0x55, 0x6e, 0x64, 0x6f, 0x44, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, + 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x1b, 0x0a, 0x19, 0x55, 0x6e, 0x64, + 0x6f, 0x44, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x0a, 0x19, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x57, 0x61, 0x73, 0x50, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x22, 0x1c, 0x0a, 0x1a, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x57, 0x61, + 0x73, 0x50, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x23, 0x0a, 0x21, 0x52, 0x65, 0x73, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x24, 0x0a, 0x22, 0x52, 0x65, 0x73, 0x65, 0x74, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, + 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x13, 0x0a, 0x11, + 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x22, 0x49, 0x0a, 0x12, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xed, 0x01, 0x0a, + 0x1b, 0x53, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, + 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, + 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, + 0x69, 0x61, 0x73, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x74, + 0x69, 0x6d, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x64, 0x4e, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, - 0x15, 0x0a, 0x13, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x65, 0x6d, 0x6f, 0x74, 0x65, - 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x64, - 0x0a, 0x15, 0x44, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0e, 0x70, 0x72, 0x69, 0x6d, 0x61, - 0x72, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1e, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, - 0x0d, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4a, 0x04, - 0x08, 0x01, 0x10, 0x02, 0x22, 0x36, 0x0a, 0x18, 0x55, 0x6e, 0x64, 0x6f, 0x44, 0x65, 0x6d, 0x6f, - 0x74, 0x65, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x1b, 0x0a, 0x19, - 0x55, 0x6e, 0x64, 0x6f, 0x44, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, - 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x0a, 0x19, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x57, 0x61, 0x73, 0x50, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x1c, 0x0a, 0x1a, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x57, 0x61, 0x73, 0x50, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0x0a, 0x21, 0x52, 0x65, 0x73, 0x65, 0x74, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, - 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x24, 0x0a, 0x22, 0x52, 0x65, 0x73, - 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x61, 0x72, - 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x13, 0x0a, 0x11, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x22, 0x49, 0x0a, 0x12, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x46, 0x75, 0x6c, - 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, - 0xed, 0x01, 0x0a, 0x1b, 0x53, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x2d, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x26, - 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, - 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x43, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x5f, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x53, 0x74, - 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, - 0x0a, 0x0d, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, - 0x1e, 0x0a, 0x1c, 0x53, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x4b, 0x0a, 0x1a, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x57, 0x61, 0x73, 0x52, 0x65, 0x73, - 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, - 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, - 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, - 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x22, 0x1d, 0x0a, 0x1b, + 0x64, 0x4e, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x77, + 0x61, 0x69, 0x74, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x1e, 0x0a, 0x1c, + 0x53, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4b, 0x0a, 0x1a, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x57, 0x61, 0x73, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7e, 0x0a, 0x22, 0x53, - 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6e, - 0x64, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x58, 0x0a, 0x15, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x24, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x13, 0x73, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x6b, 0x0a, 0x23, 0x53, - 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6e, - 0x64, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0x33, 0x0a, 0x15, 0x50, 0x72, 0x6f, 0x6d, - 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x34, 0x0a, - 0x16, 0x50, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x22, 0xab, 0x01, 0x0a, 0x0d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, - 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, - 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, - 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x30, 0x0a, 0x14, - 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x5f, 0x66, 0x72, 0x6f, 0x6d, - 0x5f, 0x70, 0x6f, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x69, 0x6e, 0x63, 0x72, - 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x6f, 0x73, 0x12, 0x21, - 0x0a, 0x0c, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x73, 0x61, 0x66, 0x65, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x53, 0x61, 0x66, - 0x65, 0x22, 0x36, 0x0a, 0x0e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0xc8, 0x01, 0x0a, 0x18, 0x52, 0x65, - 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x0b, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, - 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, - 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x75, - 0x70, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, - 0x5f, 0x74, 0x6f, 0x5f, 0x70, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, - 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x54, 0x6f, 0x50, 0x6f, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x64, - 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, - 0x79, 0x52, 0x75, 0x6e, 0x12, 0x3e, 0x0a, 0x14, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, - 0x74, 0x6f, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, - 0x52, 0x12, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x54, 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x22, 0x41, 0x0a, 0x19, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, - 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x24, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, - 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0xd4, 0x04, 0x0a, 0x21, 0x43, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, - 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x3d, 0x0a, 0x0d, 0x62, 0x69, 0x6e, - 0x6c, 0x6f, 0x67, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x18, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x42, 0x69, - 0x6e, 0x6c, 0x6f, 0x67, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0c, 0x62, 0x69, 0x6e, 0x6c, - 0x6f, 0x67, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, - 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x04, - 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, - 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, - 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x49, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, - 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x53, 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x75, 0x62, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x62, 0x69, - 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x75, 0x62, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x75, - 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x65, 0x72, 0x5f, 0x73, - 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x08, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, - 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, - 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, - 0x6f, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x61, - 0x66, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x41, 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x22, 0x50, - 0x0a, 0x22, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x70, 0x61, + 0x72, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, + 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, + 0x73, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x22, 0x1d, 0x0a, 0x1b, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x57, 0x61, 0x73, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7e, 0x0a, 0x22, 0x53, 0x74, 0x6f, 0x70, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6e, 0x64, 0x47, 0x65, + 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x58, + 0x0a, 0x15, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, + 0x6f, 0x64, 0x65, 0x52, 0x13, 0x73, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x6b, 0x0a, 0x23, 0x53, 0x74, 0x6f, 0x70, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6e, 0x64, 0x47, 0x65, + 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x3e, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x26, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4a, + 0x04, 0x08, 0x01, 0x10, 0x02, 0x22, 0x33, 0x0a, 0x15, 0x50, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x0a, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x08, 0x73, 0x65, 0x6d, 0x69, 0x53, 0x79, 0x6e, 0x63, 0x22, 0x34, 0x0a, 0x16, 0x50, 0x72, + 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x22, 0xab, 0x01, 0x0a, 0x0d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, + 0x65, 0x6e, 0x63, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x70, 0x72, + 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x69, 0x6e, 0x63, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x70, 0x6f, + 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65, + 0x6e, 0x74, 0x61, 0x6c, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x6f, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x75, + 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x73, 0x61, 0x66, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0b, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x53, 0x61, 0x66, 0x65, 0x22, 0x36, + 0x0a, 0x0e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x24, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, + 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0xc8, 0x01, 0x0a, 0x18, 0x52, 0x65, 0x73, 0x74, 0x6f, + 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x0b, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x54, 0x69, + 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x6f, + 0x5f, 0x70, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x74, + 0x6f, 0x72, 0x65, 0x54, 0x6f, 0x50, 0x6f, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, 0x5f, + 0x72, 0x75, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, 0x75, + 0x6e, 0x12, 0x3e, 0x0a, 0x14, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x6f, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x12, 0x72, + 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x54, 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x22, 0x41, 0x0a, 0x19, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, + 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x24, + 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, + 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x05, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x22, 0xd4, 0x04, 0x0a, 0x21, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x3d, 0x0a, 0x0d, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, + 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, + 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x42, 0x69, 0x6e, 0x6c, 0x6f, + 0x67, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0c, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x53, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, + 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x63, 0x65, 0x12, 0x49, 0x0a, 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x69, 0x6e, 0x6c, + 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, 0x12, 0x53, 0x0a, + 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x75, 0x62, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, + 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x75, 0x62, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x75, 0x62, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, + 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, 0x6f, 0x53, 0x74, + 0x61, 0x72, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x61, 0x66, 0x74, 0x65, + 0x72, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x74, + 0x6f, 0x70, 0x41, 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x22, 0x50, 0x0a, 0x22, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3f, 0x0a, + 0x21, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x22, 0x50, + 0x0a, 0x22, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x22, 0x3f, 0x0a, 0x21, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x22, 0x50, 0x0a, 0x22, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, - 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x22, 0x3d, 0x0a, 0x1f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, - 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, - 0x6f, 0x77, 0x22, 0x94, 0x09, 0x0a, 0x20, 0x52, 0x65, 0x61, 0x64, 0x56, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0e, 0x32, - 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, - 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, - 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, - 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, + 0x22, 0x3d, 0x0a, 0x1f, 0x52, 0x65, 0x61, 0x64, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x22, + 0x94, 0x09, 0x0a, 0x20, 0x52, 0x65, 0x61, 0x64, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, + 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, + 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, + 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, + 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x17, 0x0a, + 0x07, 0x64, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x64, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, 0x49, 0x0a, 0x0d, 0x77, 0x6f, + 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x54, 0x79, 0x70, 0x65, 0x12, 0x53, 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x5f, 0x73, 0x75, 0x62, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x27, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x53, 0x75, 0x62, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0f, 0x77, 0x6f, 0x72, 0x6b, 0x66, + 0x6c, 0x6f, 0x77, 0x53, 0x75, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, + 0x66, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, + 0x79, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x54, 0x0a, 0x07, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x07, 0x73, 0x74, 0x72, 0x65, 0x61, + 0x6d, 0x73, 0x1a, 0xc1, 0x04, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2a, 0x0a, + 0x03, 0x62, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x62, 0x69, 0x6e, + 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x52, 0x03, 0x62, 0x6c, 0x73, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x6f, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x70, 0x6f, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x73, + 0x74, 0x6f, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, + 0x74, 0x6f, 0x70, 0x50, 0x6f, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x61, 0x78, 0x5f, 0x74, 0x70, + 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6d, 0x61, 0x78, 0x54, 0x70, 0x73, 0x12, + 0x2e, 0x0a, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x6d, 0x61, + 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x61, 0x67, 0x12, + 0x2f, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, + 0x12, 0x41, 0x0a, 0x15, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x14, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x12, 0x3b, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x6f, + 0x77, 0x73, 0x5f, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0a, 0x72, 0x6f, 0x77, 0x73, 0x43, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x12, 0x33, 0x0a, 0x0e, 0x74, + 0x69, 0x6d, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x18, 0x0c, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, + 0x12, 0x33, 0x0a, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, + 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x68, 0x72, 0x6f, + 0x74, 0x74, 0x6c, 0x65, 0x64, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, + 0x6e, 0x74, 0x5f, 0x74, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x18, 0x0e, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x12, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x54, 0x68, 0x72, + 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x22, 0xd7, 0x01, 0x0a, 0x0c, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, + 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x61, 0x72, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x41, 0x72, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x64, 0x69, 0x66, 0x66, 0x5f, + 0x75, 0x75, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x76, 0x64, 0x69, 0x66, + 0x66, 0x55, 0x75, 0x69, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, + 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x22, 0x6a, 0x0a, 0x0d, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x2a, 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x1d, 0x0a, + 0x0a, 0x76, 0x64, 0x69, 0x66, 0x66, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x09, 0x76, 0x64, 0x69, 0x66, 0x66, 0x55, 0x75, 0x69, 0x64, 0x22, 0x79, 0x0a, 0x12, + 0x56, 0x44, 0x69, 0x66, 0x66, 0x50, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x22, 0x90, 0x01, 0x0a, 0x12, 0x56, 0x44, 0x69, 0x66, + 0x66, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x19, + 0x0a, 0x08, 0x6f, 0x6e, 0x6c, 0x79, 0x5f, 0x70, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x6f, 0x6e, 0x6c, 0x79, 0x50, 0x6b, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, + 0x64, 0x65, 0x62, 0x75, 0x67, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6d, 0x61, 0x78, + 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x6f, 0x77, 0x73, 0x22, 0xda, 0x02, 0x0a, 0x10, 0x56, + 0x44, 0x69, 0x66, 0x66, 0x43, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x16, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, + 0x72, 0x65, 0x74, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, + 0x6f, 0x52, 0x65, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x6f, + 0x77, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x52, 0x6f, 0x77, + 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x08, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x12, 0x1d, 0x0a, + 0x0a, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x70, 0x63, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x09, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x63, 0x74, 0x12, 0x27, 0x0a, 0x0f, + 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x53, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x38, 0x0a, 0x19, 0x6d, 0x61, 0x78, 0x5f, 0x65, 0x78, 0x74, + 0x72, 0x61, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, + 0x72, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x6d, 0x61, 0x78, 0x45, 0x78, 0x74, + 0x72, 0x61, 0x52, 0x6f, 0x77, 0x73, 0x54, 0x6f, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x12, + 0x2c, 0x0a, 0x12, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x28, 0x0a, + 0x10, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x69, 0x66, 0x66, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x44, 0x69, 0x66, 0x66, + 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0xf2, 0x01, 0x0a, 0x0c, 0x56, 0x44, 0x69, 0x66, + 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x4c, 0x0a, 0x0e, 0x70, 0x69, 0x63, 0x6b, + 0x65, 0x72, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x25, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x50, 0x69, 0x63, 0x6b, 0x65, 0x72, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0d, 0x70, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x46, 0x0a, 0x0c, 0x63, 0x6f, 0x72, 0x65, 0x5f, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x52, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x4c, + 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, + 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0d, 0x72, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x81, 0x03, 0x0a, + 0x21, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, + 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, + 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, + 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, + 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, - 0x12, 0x17, 0x0a, 0x07, 0x64, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x06, 0x64, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, - 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x12, 0x49, 0x0a, - 0x0d, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, - 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, - 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x79, 0x70, 0x65, 0x12, 0x53, 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, - 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x75, 0x62, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, - 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x75, 0x62, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0f, 0x77, 0x6f, - 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x75, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x30, 0x0a, - 0x14, 0x64, 0x65, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, - 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, 0x66, - 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, - 0x54, 0x0a, 0x07, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x3a, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x07, 0x73, 0x74, - 0x72, 0x65, 0x61, 0x6d, 0x73, 0x1a, 0xc1, 0x04, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, - 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, - 0x12, 0x2a, 0x0a, 0x03, 0x62, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, - 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x42, 0x69, 0x6e, 0x6c, 0x6f, - 0x67, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x03, 0x62, 0x6c, 0x73, 0x12, 0x10, 0x0a, 0x03, - 0x70, 0x6f, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x70, 0x6f, 0x73, 0x12, 0x19, - 0x0a, 0x08, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x07, 0x73, 0x74, 0x6f, 0x70, 0x50, 0x6f, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x61, 0x78, - 0x5f, 0x74, 0x70, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6d, 0x61, 0x78, 0x54, - 0x70, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x11, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, - 0x61, 0x67, 0x12, 0x2f, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, - 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x64, 0x12, 0x41, 0x0a, 0x15, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, - 0x52, 0x14, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x3b, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, - 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, - 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x0a, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x0a, - 0x0b, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x18, 0x0b, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x0a, 0x72, 0x6f, 0x77, 0x73, 0x43, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x12, 0x33, - 0x0a, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, - 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, - 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, - 0x65, 0x61, 0x74, 0x12, 0x33, 0x0a, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x6f, - 0x74, 0x74, 0x6c, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, - 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x54, - 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x70, - 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x18, - 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, - 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x22, 0xd7, 0x01, 0x0a, 0x0c, 0x56, 0x44, - 0x69, 0x66, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, - 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, - 0x6f, 0x77, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x72, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x72, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x64, 0x69, - 0x66, 0x66, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x76, - 0x64, 0x69, 0x66, 0x66, 0x55, 0x75, 0x69, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, - 0x69, 0x66, 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x22, 0x6a, 0x0a, 0x0d, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x02, 0x69, 0x64, 0x12, 0x2a, 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, - 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x64, 0x69, 0x66, 0x66, 0x5f, 0x75, 0x75, 0x69, 0x64, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x76, 0x64, 0x69, 0x66, 0x66, 0x55, 0x75, 0x69, 0x64, 0x22, - 0x79, 0x0a, 0x12, 0x56, 0x44, 0x69, 0x66, 0x66, 0x50, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x4f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, - 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x22, 0x90, 0x01, 0x0a, 0x12, 0x56, - 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x6e, 0x6c, 0x79, 0x5f, 0x70, 0x6b, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x07, 0x6f, 0x6e, 0x6c, 0x79, 0x50, 0x6b, 0x73, 0x12, 0x1f, 0x0a, 0x0b, - 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0a, 0x64, 0x65, 0x62, 0x75, 0x67, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x16, 0x0a, - 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, - 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x61, 0x6d, - 0x70, 0x6c, 0x65, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, - 0x6d, 0x61, 0x78, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x6f, 0x77, 0x73, 0x22, 0xda, 0x02, - 0x0a, 0x10, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, - 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, - 0x61, 0x75, 0x74, 0x6f, 0x52, 0x65, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, - 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, - 0x52, 0x6f, 0x77, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, - 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x70, 0x63, 0x74, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x63, 0x74, 0x12, - 0x27, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, - 0x64, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, - 0x74, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x38, 0x0a, 0x19, 0x6d, 0x61, 0x78, 0x5f, - 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x6f, - 0x6d, 0x70, 0x61, 0x72, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x6d, 0x61, 0x78, - 0x45, 0x78, 0x74, 0x72, 0x61, 0x52, 0x6f, 0x77, 0x73, 0x54, 0x6f, 0x43, 0x6f, 0x6d, 0x70, 0x61, - 0x72, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, - 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x69, 0x66, 0x66, 0x5f, 0x73, 0x65, 0x63, - 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x44, - 0x69, 0x66, 0x66, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0xf2, 0x01, 0x0a, 0x0c, 0x56, - 0x44, 0x69, 0x66, 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x4c, 0x0a, 0x0e, 0x70, - 0x69, 0x63, 0x6b, 0x65, 0x72, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, - 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x50, 0x69, 0x63, - 0x6b, 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0d, 0x70, 0x69, 0x63, 0x6b, - 0x65, 0x72, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x46, 0x0a, 0x0c, 0x63, 0x6f, 0x72, - 0x65, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x23, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0b, 0x63, 0x6f, 0x72, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x4c, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, - 0x69, 0x66, 0x66, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x52, 0x0d, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, - 0x81, 0x03, 0x0a, 0x21, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x6f, + 0x6e, 0x5f, 0x64, 0x64, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x62, 0x69, + 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4f, 0x6e, 0x44, 0x44, 0x4c, 0x41, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x6f, 0x6e, 0x44, 0x64, 0x6c, 0x12, 0x3b, 0x0a, 0x05, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x62, 0x69, 0x6e, + 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, + 0x64, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, + 0x22, 0x50, 0x0a, 0x22, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, - 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, - 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, - 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, - 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, - 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x2e, - 0x0a, 0x06, 0x6f, 0x6e, 0x5f, 0x64, 0x64, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, - 0x2e, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4f, 0x6e, 0x44, 0x44, - 0x4c, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x6f, 0x6e, 0x44, 0x64, 0x6c, 0x12, 0x3b, - 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, - 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, - 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x73, 0x22, 0x50, 0x0a, 0x22, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x52, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, - 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x2f, 0x0a, 0x15, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x65, - 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, - 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, - 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x32, 0x0a, 0x15, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, - 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x70, 0x70, - 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x70, 0x70, - 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xc8, 0x01, 0x0a, 0x16, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x54, 0x68, - 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, - 0x6f, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, - 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, - 0x73, 0x61, 0x67, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x6c, 0x79, - 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, - 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x64, 0x2a, - 0x3e, 0x0a, 0x19, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x07, 0x0a, 0x03, - 0x41, 0x4e, 0x59, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x4f, 0x52, 0x44, 0x45, 0x52, - 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x03, 0x42, - 0x30, 0x5a, 0x2e, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x69, 0x74, - 0x65, 0x73, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, - 0x61, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x22, 0x2f, 0x0a, 0x15, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, + 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, + 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x65, 0x71, 0x75, + 0x65, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x32, 0x0a, + 0x15, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x70, 0x70, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x70, 0x70, 0x4e, 0x61, 0x6d, + 0x65, 0x22, 0xc8, 0x01, 0x0a, 0x16, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x54, 0x68, 0x72, 0x6f, 0x74, + 0x74, 0x6c, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, + 0x64, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x5f, 0x63, 0x68, + 0x65, 0x63, 0x6b, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x72, 0x65, 0x63, + 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x64, 0x2a, 0x3e, 0x0a, 0x19, + 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, + 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x4e, 0x59, + 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x4e, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x10, 0x01, 0x12, + 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x03, 0x42, 0x30, 0x5a, 0x2e, + 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, + 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( diff --git a/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go b/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go index d62eeafac47..4d5b4188e5e 100644 --- a/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go +++ b/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go @@ -792,10 +792,11 @@ func (m *ExecuteFetchAsDbaRequest) CloneVT() *ExecuteFetchAsDbaRequest { return (*ExecuteFetchAsDbaRequest)(nil) } r := &ExecuteFetchAsDbaRequest{ - DbName: m.DbName, - MaxRows: m.MaxRows, - DisableBinlogs: m.DisableBinlogs, - ReloadSchema: m.ReloadSchema, + DbName: m.DbName, + MaxRows: m.MaxRows, + DisableBinlogs: m.DisableBinlogs, + ReloadSchema: m.ReloadSchema, + DisableForeignKeyChecks: m.DisableForeignKeyChecks, } if rhs := m.Query; rhs != nil { tmpBytes := make([]byte, len(rhs)) @@ -4048,6 +4049,16 @@ func (m *ExecuteFetchAsDbaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, err i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } + if m.DisableForeignKeyChecks { + i-- + if m.DisableForeignKeyChecks { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } if m.ReloadSchema { i-- if m.ReloadSchema { @@ -8379,6 +8390,9 @@ func (m *ExecuteFetchAsDbaRequest) SizeVT() (n int) { if m.ReloadSchema { n += 2 } + if m.DisableForeignKeyChecks { + n += 2 + } n += len(m.unknownFields) return n } @@ -13730,6 +13744,26 @@ func (m *ExecuteFetchAsDbaRequest) UnmarshalVT(dAtA []byte) error { } } m.ReloadSchema = bool(v != 0) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisableForeignKeyChecks", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DisableForeignKeyChecks = bool(v != 0) default: iNdEx = preIndex skippy, err := skip(dAtA[iNdEx:]) diff --git a/go/vt/vtctl/workflow/traffic_switcher.go b/go/vt/vtctl/workflow/traffic_switcher.go index 890ffd098a0..2a593cfb1db 100644 --- a/go/vt/vtctl/workflow/traffic_switcher.go +++ b/go/vt/vtctl/workflow/traffic_switcher.go @@ -510,9 +510,10 @@ func (ts *trafficSwitcher) removeSourceTables(ctx context.Context, removalType T query = fmt.Sprintf("rename table %s.%s TO %s.%s", primaryDbName, tableNameEscaped, primaryDbName, renameName) } _, err = ts.ws.tmc.ExecuteFetchAsDba(ctx, source.GetPrimary().Tablet, false, &tabletmanagerdatapb.ExecuteFetchAsDbaRequest{ - Query: []byte(query), - MaxRows: 1, - ReloadSchema: true, + Query: []byte(query), + MaxRows: 1, + ReloadSchema: true, + DisableForeignKeyChecks: true, }) if err != nil { ts.Logger().Errorf("%s: Error removing table %s: %v", source.GetPrimary().String(), tableName, err) @@ -1067,7 +1068,6 @@ func (ts *trafficSwitcher) dropSourceReverseVReplicationStreams(ctx context.Cont } func (ts *trafficSwitcher) removeTargetTables(ctx context.Context) error { - log.Flush() err := ts.ForAllTargets(func(target *MigrationTarget) error { log.Infof("ForAllTargets: %+v", target) for _, tableName := range ts.Tables() { @@ -1083,12 +1083,12 @@ func (ts *trafficSwitcher) removeTargetTables(ctx context.Context) error { ts.Logger().Infof("%s: Dropping table %s.%s\n", target.GetPrimary().String(), target.GetPrimary().DbName(), tableName) res, err := ts.ws.tmc.ExecuteFetchAsDba(ctx, target.GetPrimary().Tablet, false, &tabletmanagerdatapb.ExecuteFetchAsDbaRequest{ - Query: []byte(query), - MaxRows: 1, - ReloadSchema: true, + Query: []byte(query), + MaxRows: 1, + ReloadSchema: true, + DisableForeignKeyChecks: true, }) log.Infof("Removed target table with result: %+v", res) - log.Flush() if err != nil { ts.Logger().Errorf("%s: Error removing table %s: %v", target.GetPrimary().String(), tableName, err) diff --git a/go/vt/vttablet/grpctmclient/client.go b/go/vt/vttablet/grpctmclient/client.go index 8759835c7d6..089b7c014dd 100644 --- a/go/vt/vttablet/grpctmclient/client.go +++ b/go/vt/vttablet/grpctmclient/client.go @@ -488,11 +488,12 @@ func (client *Client) ExecuteFetchAsDba(ctx context.Context, tablet *topodatapb. } response, err := c.ExecuteFetchAsDba(ctx, &tabletmanagerdatapb.ExecuteFetchAsDbaRequest{ - Query: req.Query, - DbName: topoproto.TabletDbName(tablet), - MaxRows: req.MaxRows, - DisableBinlogs: req.DisableBinlogs, - ReloadSchema: req.DisableBinlogs, + Query: req.Query, + DbName: topoproto.TabletDbName(tablet), + MaxRows: req.MaxRows, + DisableBinlogs: req.DisableBinlogs, + ReloadSchema: req.DisableBinlogs, + DisableForeignKeyChecks: req.DisableForeignKeyChecks, }) if err != nil { return nil, err diff --git a/go/vt/vttablet/tabletmanager/rpc_query.go b/go/vt/vttablet/tabletmanager/rpc_query.go index b4c84afec91..00e2ef3f325 100644 --- a/go/vt/vttablet/tabletmanager/rpc_query.go +++ b/go/vt/vttablet/tabletmanager/rpc_query.go @@ -73,14 +73,14 @@ func (tm *TabletManager) ExecuteFetchAsDba(ctx context.Context, req *tabletmanag if err := tm.waitForGrantsToHaveApplied(ctx); err != nil { return nil, err } - // get a connection + // Get a connection. conn, err := tm.MysqlDaemon.GetDbaConnection(ctx) if err != nil { return nil, err } defer conn.Close() - // disable binlogs if necessary + // Disable binlogs if necessary. if req.DisableBinlogs { _, err := conn.ExecuteFetch("SET sql_log_bin = OFF", 0, false) if err != nil { @@ -88,6 +88,14 @@ func (tm *TabletManager) ExecuteFetchAsDba(ctx context.Context, req *tabletmanag } } + // Disable FK checks if requested. + if req.DisableForeignKeyChecks { + _, err := conn.ExecuteFetch("SET SESSION foreign_key_checks = OFF", 0, false) + if err != nil { + return nil, err + } + } + if req.DbName != "" { // This execute might fail if db does not exist. // Error is ignored because given query might create this database. @@ -130,7 +138,17 @@ func (tm *TabletManager) ExecuteFetchAsDba(ctx context.Context, req *tabletmanag } } - // re-enable binlogs if necessary + // Re-enable FK checks if necessary. + if req.DisableForeignKeyChecks && !conn.IsClosed() { + _, err := conn.ExecuteFetch("SET SESSION foreign_key_checks = ON", 0, false) + if err != nil { + // If we can't reset the FK checks flag, + // let's just close the connection. + conn.Close() + } + } + + // Re-enable binlogs if necessary. if req.DisableBinlogs && !conn.IsClosed() { _, err := conn.ExecuteFetch("SET sql_log_bin = ON", 0, false) if err != nil { diff --git a/go/vt/vttablet/tabletmanager/vdiff/stats_test.go b/go/vt/vttablet/tabletmanager/vdiff/stats_test.go index 8b1a174466f..b4f02d7b192 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/stats_test.go +++ b/go/vt/vttablet/tabletmanager/vdiff/stats_test.go @@ -54,7 +54,7 @@ func TestVDiffStats(t *testing.T) { defer testStats.controllers[id].TableDiffPhaseTimings.Record(phase, time.Now()) time.Sleep(sleepTime) } - want := int64(1.2 * float64(sleepTime)) // Allow 20% overhead for recording timing + want := 10 * sleepTime // Allow 10x overhead for recording timing on flaky test hosts record(string(initializing)) require.Greater(t, want, testStats.controllers[id].TableDiffPhaseTimings.Histograms()[string(initializing)].Total()) record(string(pickingTablets)) diff --git a/go/vt/wrangler/traffic_switcher.go b/go/vt/wrangler/traffic_switcher.go index d2204c09cab..9e7e133cd1f 100644 --- a/go/vt/wrangler/traffic_switcher.go +++ b/go/vt/wrangler/traffic_switcher.go @@ -49,6 +49,7 @@ import ( binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" querypb "vitess.io/vitess/go/vt/proto/query" + tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata" topodatapb "vitess.io/vitess/go/vt/proto/topodata" vschemapb "vitess.io/vitess/go/vt/proto/vschema" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" @@ -1790,7 +1791,12 @@ func (ts *trafficSwitcher) removeSourceTables(ctx context.Context, removalType w source.GetPrimary().String(), source.GetPrimary().DbName(), tableName, source.GetPrimary().DbName(), renameName) query = fmt.Sprintf("rename table %s.%s TO %s.%s", primaryDbName, tableNameEscaped, primaryDbName, renameName) } - _, err = ts.wr.ExecuteFetchAsDba(ctx, source.GetPrimary().Alias, query, 1, false, true) + _, err = ts.wr.tmc.ExecuteFetchAsDba(ctx, source.GetPrimary().Tablet, false, &tabletmanagerdatapb.ExecuteFetchAsDbaRequest{ + Query: []byte(query), + MaxRows: 1, + ReloadSchema: true, + DisableForeignKeyChecks: true, + }) if err != nil { ts.Logger().Errorf("%s: Error removing table %s: %v", source.GetPrimary().String(), tableName, err) return err @@ -1896,7 +1902,12 @@ func (ts *trafficSwitcher) removeTargetTables(ctx context.Context) error { query := fmt.Sprintf("drop table %s.%s", primaryDbName, tableName) ts.Logger().Infof("%s: Dropping table %s.%s\n", target.GetPrimary().String(), target.GetPrimary().DbName(), tableName) - _, err = ts.wr.ExecuteFetchAsDba(ctx, target.GetPrimary().Alias, query, 1, false, true) + _, err = ts.wr.tmc.ExecuteFetchAsDba(ctx, target.GetPrimary().Tablet, false, &tabletmanagerdatapb.ExecuteFetchAsDbaRequest{ + Query: []byte(query), + MaxRows: 1, + ReloadSchema: true, + DisableForeignKeyChecks: true, + }) if err != nil { ts.Logger().Errorf("%s: Error removing table %s: %v", target.GetPrimary().String(), tableName, err) diff --git a/go/vt/wrangler/traffic_switcher_test.go b/go/vt/wrangler/traffic_switcher_test.go index e9e6ce7bf0e..df1eebc013a 100644 --- a/go/vt/wrangler/traffic_switcher_test.go +++ b/go/vt/wrangler/traffic_switcher_test.go @@ -949,8 +949,10 @@ func testTableMigrateOneToMany(t *testing.T, keepData, keepRoutingRules bool) { tme.dbTargetClients[0].addQuery("select 1 from _vt.vreplication where db_name='vt_ks2' and workflow='test' and message!='FROZEN'", &sqltypes.Result{}, nil) tme.dbTargetClients[1].addQuery("select 1 from _vt.vreplication where db_name='vt_ks2' and workflow='test' and message!='FROZEN'", &sqltypes.Result{}, nil) tme.dbSourceClients[0].addQuery("select id from _vt.vreplication where db_name = 'vt_ks1' and workflow = 'test_reverse'", &sqltypes.Result{}, nil) + tme.tmeDB.AddQuery("SET SESSION foreign_key_checks = OFF", &sqltypes.Result{}) tme.tmeDB.AddQuery(fmt.Sprintf("rename table `vt_ks1`.`t1` TO `vt_ks1`.`%s`", getRenameFileName("t1")), &sqltypes.Result{}) tme.tmeDB.AddQuery(fmt.Sprintf("rename table `vt_ks1`.`t2` TO `vt_ks1`.`%s`", getRenameFileName("t2")), &sqltypes.Result{}) + tme.tmeDB.AddQuery("SET SESSION foreign_key_checks = ON", &sqltypes.Result{}) tme.dbTargetClients[0].addQuery("select id from _vt.vreplication where db_name = 'vt_ks2' and workflow = 'test'", &sqltypes.Result{}, nil) // tme.dbTargetClients[1].addQuery("select id from _vt.vreplication where db_name = 'vt_ks2' and workflow = 'test'", &sqltypes.Result{}, nil) } diff --git a/go/vt/wrangler/workflow_test.go b/go/vt/wrangler/workflow_test.go index dcad9cce038..978883d5457 100644 --- a/go/vt/wrangler/workflow_test.go +++ b/go/vt/wrangler/workflow_test.go @@ -871,12 +871,14 @@ func expectMoveTablesQueries(t *testing.T, tme *testMigraterEnv, params *VReplic tme.dbSourceClients[0].addInvariant("select pos, state, message from _vt.vreplication where id=2", state) tme.dbSourceClients[1].addInvariant("select pos, state, message from _vt.vreplication where id=1", state) tme.dbSourceClients[1].addInvariant("select pos, state, message from _vt.vreplication where id=2", state) + tme.tmeDB.AddQuery("SET SESSION foreign_key_checks = OFF", &sqltypes.Result{}) tme.tmeDB.AddQuery("USE `vt_ks1`", noResult) tme.tmeDB.AddQuery("USE `vt_ks2`", noResult) tme.tmeDB.AddQuery("drop table `vt_ks1`.`t1`", noResult) tme.tmeDB.AddQuery("drop table `vt_ks1`.`t2`", noResult) tme.tmeDB.AddQuery("drop table `vt_ks2`.`t1`", noResult) tme.tmeDB.AddQuery("drop table `vt_ks2`.`t2`", noResult) + tme.tmeDB.AddQuery("SET SESSION foreign_key_checks = ON", &sqltypes.Result{}) tme.tmeDB.AddQuery("update _vt.vreplication set message='Picked source tablet: cell:\"cell1\" uid:10 ' where id=1", noResult) tme.tmeDB.AddQuery("lock tables `t1` read,`t2` read", &sqltypes.Result{}) tme.tmeDB.AddQuery("select distinct table_name from _vt.copy_state cs, _vt.vreplication vr where vr.id = cs.vrepl_id and vr.id = 1", noResult) diff --git a/proto/tabletmanagerdata.proto b/proto/tabletmanagerdata.proto index 6c3d730cd25..e1a0e97f03e 100644 --- a/proto/tabletmanagerdata.proto +++ b/proto/tabletmanagerdata.proto @@ -259,6 +259,7 @@ message ExecuteFetchAsDbaRequest { uint64 max_rows = 3; bool disable_binlogs = 4; bool reload_schema = 5; + bool disable_foreign_key_checks = 6; } message ExecuteFetchAsDbaResponse { diff --git a/web/vtadmin/src/proto/vtadmin.d.ts b/web/vtadmin/src/proto/vtadmin.d.ts index 03f7bbcbcd8..20c1cbab8b8 100644 --- a/web/vtadmin/src/proto/vtadmin.d.ts +++ b/web/vtadmin/src/proto/vtadmin.d.ts @@ -21686,6 +21686,9 @@ export namespace tabletmanagerdata { /** ExecuteFetchAsDbaRequest reload_schema */ reload_schema?: (boolean|null); + + /** ExecuteFetchAsDbaRequest disable_foreign_key_checks */ + disable_foreign_key_checks?: (boolean|null); } /** Represents an ExecuteFetchAsDbaRequest. */ @@ -21712,6 +21715,9 @@ export namespace tabletmanagerdata { /** ExecuteFetchAsDbaRequest reload_schema. */ public reload_schema: boolean; + /** ExecuteFetchAsDbaRequest disable_foreign_key_checks. */ + public disable_foreign_key_checks: boolean; + /** * Creates a new ExecuteFetchAsDbaRequest instance using the specified properties. * @param [properties] Properties to set diff --git a/web/vtadmin/src/proto/vtadmin.js b/web/vtadmin/src/proto/vtadmin.js index 498f6f30cd9..957efd73ed0 100644 --- a/web/vtadmin/src/proto/vtadmin.js +++ b/web/vtadmin/src/proto/vtadmin.js @@ -50119,6 +50119,7 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { * @property {number|Long|null} [max_rows] ExecuteFetchAsDbaRequest max_rows * @property {boolean|null} [disable_binlogs] ExecuteFetchAsDbaRequest disable_binlogs * @property {boolean|null} [reload_schema] ExecuteFetchAsDbaRequest reload_schema + * @property {boolean|null} [disable_foreign_key_checks] ExecuteFetchAsDbaRequest disable_foreign_key_checks */ /** @@ -50176,6 +50177,14 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { */ ExecuteFetchAsDbaRequest.prototype.reload_schema = false; + /** + * ExecuteFetchAsDbaRequest disable_foreign_key_checks. + * @member {boolean} disable_foreign_key_checks + * @memberof tabletmanagerdata.ExecuteFetchAsDbaRequest + * @instance + */ + ExecuteFetchAsDbaRequest.prototype.disable_foreign_key_checks = false; + /** * Creates a new ExecuteFetchAsDbaRequest instance using the specified properties. * @function create @@ -50210,6 +50219,8 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { writer.uint32(/* id 4, wireType 0 =*/32).bool(message.disable_binlogs); if (message.reload_schema != null && Object.hasOwnProperty.call(message, "reload_schema")) writer.uint32(/* id 5, wireType 0 =*/40).bool(message.reload_schema); + if (message.disable_foreign_key_checks != null && Object.hasOwnProperty.call(message, "disable_foreign_key_checks")) + writer.uint32(/* id 6, wireType 0 =*/48).bool(message.disable_foreign_key_checks); return writer; }; @@ -50264,6 +50275,10 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { message.reload_schema = reader.bool(); break; } + case 6: { + message.disable_foreign_key_checks = reader.bool(); + break; + } default: reader.skipType(tag & 7); break; @@ -50314,6 +50329,9 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { if (message.reload_schema != null && message.hasOwnProperty("reload_schema")) if (typeof message.reload_schema !== "boolean") return "reload_schema: boolean expected"; + if (message.disable_foreign_key_checks != null && message.hasOwnProperty("disable_foreign_key_checks")) + if (typeof message.disable_foreign_key_checks !== "boolean") + return "disable_foreign_key_checks: boolean expected"; return null; }; @@ -50349,6 +50367,8 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { message.disable_binlogs = Boolean(object.disable_binlogs); if (object.reload_schema != null) message.reload_schema = Boolean(object.reload_schema); + if (object.disable_foreign_key_checks != null) + message.disable_foreign_key_checks = Boolean(object.disable_foreign_key_checks); return message; }; @@ -50381,6 +50401,7 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { object.max_rows = options.longs === String ? "0" : 0; object.disable_binlogs = false; object.reload_schema = false; + object.disable_foreign_key_checks = false; } if (message.query != null && message.hasOwnProperty("query")) object.query = options.bytes === String ? $util.base64.encode(message.query, 0, message.query.length) : options.bytes === Array ? Array.prototype.slice.call(message.query) : message.query; @@ -50395,6 +50416,8 @@ export const tabletmanagerdata = $root.tabletmanagerdata = (() => { object.disable_binlogs = message.disable_binlogs; if (message.reload_schema != null && message.hasOwnProperty("reload_schema")) object.reload_schema = message.reload_schema; + if (message.disable_foreign_key_checks != null && message.hasOwnProperty("disable_foreign_key_checks")) + object.disable_foreign_key_checks = message.disable_foreign_key_checks; return object; }; From f82fb7cbd03db4fb93ba49c49b9ff5e43eb77608 Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Thu, 15 Feb 2024 17:03:34 -0500 Subject: [PATCH 24/79] Make `--pprof-http` default to false (#15260) Signed-off-by: Andrew Mason --- changelog/20.0/20.0.0/summary.md | 10 ++++++++++ go/flags/endtoend/mysqlctl.txt | 2 +- go/flags/endtoend/mysqlctld.txt | 2 +- go/flags/endtoend/topo2topo.txt | 2 +- go/flags/endtoend/vtaclcheck.txt | 2 +- go/flags/endtoend/vtbackup.txt | 2 +- go/flags/endtoend/vtbench.txt | 2 +- go/flags/endtoend/vtclient.txt | 2 +- go/flags/endtoend/vtcombo.txt | 2 +- go/flags/endtoend/vtctlclient.txt | 2 +- go/flags/endtoend/vtctld.txt | 2 +- go/flags/endtoend/vtexplain.txt | 2 +- go/flags/endtoend/vtgate.txt | 2 +- go/flags/endtoend/vtgateclienttest.txt | 2 +- go/flags/endtoend/vtorc.txt | 2 +- go/flags/endtoend/vttablet.txt | 2 +- go/flags/endtoend/vttestserver.txt | 2 +- go/flags/endtoend/zkctl.txt | 2 +- go/vt/servenv/http.go | 7 ------- go/vt/servenv/pprof.go | 2 +- 20 files changed, 28 insertions(+), 25 deletions(-) diff --git a/changelog/20.0/20.0.0/summary.md b/changelog/20.0/20.0.0/summary.md index f1280ba7e76..b30ec93d400 100644 --- a/changelog/20.0/20.0.0/summary.md +++ b/changelog/20.0/20.0.0/summary.md @@ -7,6 +7,8 @@ - [Vindex Hints](#vindex-hints) - [Update with Limit Support](#update-limit) - [Update with Multi Table Support](#multi-table-update) + - **[Flag changes](#flag-changes)** + - [`pprof-http` default change](#pprof-http-default) - **[Minor Changes](#minor-changes)** @@ -43,6 +45,14 @@ Example: `update t1 join t2 on t1.id = t2.id join t3 on t1.col = t3.col set t1.b More details about how it works is available in [MySQL Docs](https://dev.mysql.com/doc/refman/8.0/en/update.html) +### Flag Changes + +#### `pprof-http` Default Change + +The `--pprof-http` flag, which was introduced in v19 with a default of `true`, has now been changed to default to `false`. +This makes HTTP `pprof` endpoints now an *opt-in* feature, rather than opt-out. +To continue enabling these endpoints, explicitly set `--pprof-http` when starting up Vitess components. + ## Minor Changes diff --git a/go/flags/endtoend/mysqlctl.txt b/go/flags/endtoend/mysqlctl.txt index d729a44826d..044d12981d5 100644 --- a/go/flags/endtoend/mysqlctl.txt +++ b/go/flags/endtoend/mysqlctl.txt @@ -81,7 +81,7 @@ Flags: --pid_file string If set, the process will write its pid to the named file, and delete it on graceful shutdown. --pool_hostname_resolve_interval duration if set force an update to all hostnames and reconnect if changed, defaults to 0 (disabled) --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --replication_connect_retry duration how long to wait in between replica reconnect attempts. Only precise to the second. (default 10s) --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) diff --git a/go/flags/endtoend/mysqlctld.txt b/go/flags/endtoend/mysqlctld.txt index 1849519d4b8..0dde59e0d7d 100644 --- a/go/flags/endtoend/mysqlctld.txt +++ b/go/flags/endtoend/mysqlctld.txt @@ -108,7 +108,7 @@ Flags: --pool_hostname_resolve_interval duration if set force an update to all hostnames and reconnect if changed, defaults to 0 (disabled) --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --replication_connect_retry duration how long to wait in between replica reconnect attempts. Only precise to the second. (default 10s) --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) diff --git a/go/flags/endtoend/topo2topo.txt b/go/flags/endtoend/topo2topo.txt index 49f24583668..c003c3584f3 100644 --- a/go/flags/endtoend/topo2topo.txt +++ b/go/flags/endtoend/topo2topo.txt @@ -33,7 +33,7 @@ Flags: --log_rotate_max_size uint size in bytes at which logs are rotated (glog.MaxSize) (default 1887436800) --logtostderr log to standard error instead of files --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) --stderrthreshold severityFlag logs at or above this threshold go to stderr (default 1) diff --git a/go/flags/endtoend/vtaclcheck.txt b/go/flags/endtoend/vtaclcheck.txt index 29bdc63f835..8917df63c66 100644 --- a/go/flags/endtoend/vtaclcheck.txt +++ b/go/flags/endtoend/vtaclcheck.txt @@ -21,7 +21,7 @@ Flags: --log_rotate_max_size uint size in bytes at which logs are rotated (glog.MaxSize) (default 1887436800) --logtostderr log to standard error instead of files --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) --static-auth-file string The path of the auth_server_static JSON file to check diff --git a/go/flags/endtoend/vtbackup.txt b/go/flags/endtoend/vtbackup.txt index ea98ad70b88..d0c5a328052 100644 --- a/go/flags/endtoend/vtbackup.txt +++ b/go/flags/endtoend/vtbackup.txt @@ -182,7 +182,7 @@ Flags: --opentsdb_uri string URI of opentsdb /api/put method --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --remote_operation_timeout duration time to wait for a remote operation (default 15s) --restart_before_backup Perform a mysqld clean/full restart after applying binlogs, but before taking the backup. Only makes sense to work around xtrabackup bugs. diff --git a/go/flags/endtoend/vtbench.txt b/go/flags/endtoend/vtbench.txt index 4375f4ecdef..260451f6b03 100644 --- a/go/flags/endtoend/vtbench.txt +++ b/go/flags/endtoend/vtbench.txt @@ -72,7 +72,7 @@ Flags: --mysql_server_version string MySQL server version to advertise. (default "8.0.30-Vitess") --port int VTGate port --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --protocol string Client protocol, either mysql (default), grpc-vtgate, or grpc-vttablet (default "mysql") --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) diff --git a/go/flags/endtoend/vtclient.txt b/go/flags/endtoend/vtclient.txt index daab2b5683f..57ddf892ac8 100644 --- a/go/flags/endtoend/vtclient.txt +++ b/go/flags/endtoend/vtclient.txt @@ -38,7 +38,7 @@ Flags: --mysql_server_version string MySQL server version to advertise. (default "8.0.30-Vitess") --parallel int DMLs only: Number of threads executing the same query in parallel. Useful for simple load testing. (default 1) --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --qps int queries per second to throttle each thread at. --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) diff --git a/go/flags/endtoend/vtcombo.txt b/go/flags/endtoend/vtcombo.txt index 1712f2181f1..19bef034b10 100644 --- a/go/flags/endtoend/vtcombo.txt +++ b/go/flags/endtoend/vtcombo.txt @@ -258,7 +258,7 @@ Flags: --pool_hostname_resolve_interval duration if set force an update to all hostnames and reconnect if changed, defaults to 0 (disabled) --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --proto_topo vttest.TopoData vttest proto definition of the topology, encoded in compact text format. See vttest.proto for more information. --proxy_protocol Enable HAProxy PROXY protocol on MySQL listener socket --proxy_tablets Setting this true will make vtctld proxy the tablet status instead of redirecting to them diff --git a/go/flags/endtoend/vtctlclient.txt b/go/flags/endtoend/vtctlclient.txt index 61185dec18b..3c9c0a3cbb0 100644 --- a/go/flags/endtoend/vtctlclient.txt +++ b/go/flags/endtoend/vtctlclient.txt @@ -30,7 +30,7 @@ Usage of vtctlclient: --logbuflevel int Buffer log messages logged at this level or lower (-1 means don't buffer; 0 means buffer INFO only; ...). Has limited applicability on non-prod platforms. --logtostderr log to standard error instead of files --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) --server string server to use for connection diff --git a/go/flags/endtoend/vtctld.txt b/go/flags/endtoend/vtctld.txt index 32102ed8e4f..62d819fb759 100644 --- a/go/flags/endtoend/vtctld.txt +++ b/go/flags/endtoend/vtctld.txt @@ -103,7 +103,7 @@ Flags: --pid_file string If set, the process will write its pid to the named file, and delete it on graceful shutdown. --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --proxy_tablets Setting this true will make vtctld proxy the tablet status instead of redirecting to them --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --remote_operation_timeout duration time to wait for a remote operation (default 15s) diff --git a/go/flags/endtoend/vtexplain.txt b/go/flags/endtoend/vtexplain.txt index bdbe1da8768..fdd289e63c7 100644 --- a/go/flags/endtoend/vtexplain.txt +++ b/go/flags/endtoend/vtexplain.txt @@ -64,7 +64,7 @@ Flags: --output-mode string Output in human-friendly text or json (default "text") --planner-version string Sets the default planner to use. Valid values are: Gen4, Gen4Greedy, Gen4Left2Right --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --replication-mode string The replication mode to simulate -- must be set to either ROW or STATEMENT (default "ROW") --schema string The SQL table schema diff --git a/go/flags/endtoend/vtgate.txt b/go/flags/endtoend/vtgate.txt index 7585c71be6f..bd9849cfd71 100644 --- a/go/flags/endtoend/vtgate.txt +++ b/go/flags/endtoend/vtgate.txt @@ -165,7 +165,7 @@ Flags: --planner-version string Sets the default planner to use when the session has not changed it. Valid values are: Gen4, Gen4Greedy, Gen4Left2Right --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --proxy_protocol Enable HAProxy PROXY protocol on MySQL listener socket --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --query-timeout int Sets the default query timeout (in ms). Can be overridden by session variable (query_timeout) or comment directive (QUERY_TIMEOUT_MS) diff --git a/go/flags/endtoend/vtgateclienttest.txt b/go/flags/endtoend/vtgateclienttest.txt index 61146b17ffd..e7d8fc5e177 100644 --- a/go/flags/endtoend/vtgateclienttest.txt +++ b/go/flags/endtoend/vtgateclienttest.txt @@ -58,7 +58,7 @@ Flags: --pid_file string If set, the process will write its pid to the named file, and delete it on graceful shutdown. --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --security_policy string the name of a registered security policy to use for controlling access to URLs - empty means allow all for anyone (built-in policies: deny-all, read-only) --service_map strings comma separated list of services to enable (or disable if prefixed with '-') Example: grpc-queryservice diff --git a/go/flags/endtoend/vtorc.txt b/go/flags/endtoend/vtorc.txt index 116c815f09f..8073323ec1c 100644 --- a/go/flags/endtoend/vtorc.txt +++ b/go/flags/endtoend/vtorc.txt @@ -61,7 +61,7 @@ Flags: --pid_file string If set, the process will write its pid to the named file, and delete it on graceful shutdown. --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --prevent-cross-cell-failover Prevent VTOrc from promoting a primary in a different cell than the current primary in case of a failover --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --reasonable-replication-lag duration Maximum replication lag on replicas which is deemed to be acceptable (default 10s) diff --git a/go/flags/endtoend/vttablet.txt b/go/flags/endtoend/vttablet.txt index f0e69db12fc..ac25179db9b 100644 --- a/go/flags/endtoend/vttablet.txt +++ b/go/flags/endtoend/vttablet.txt @@ -256,7 +256,7 @@ Flags: --pool_hostname_resolve_interval duration if set force an update to all hostnames and reconnect if changed, defaults to 0 (disabled) --port int port for the server --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --pt-osc-path string override default pt-online-schema-change binary full path --publish_retry_interval duration how long vttablet waits to retry publishing the tablet record (default 30s) --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) diff --git a/go/flags/endtoend/vttestserver.txt b/go/flags/endtoend/vttestserver.txt index abcec6269f1..d3af635e353 100644 --- a/go/flags/endtoend/vttestserver.txt +++ b/go/flags/endtoend/vttestserver.txt @@ -101,7 +101,7 @@ Flags: --pool_hostname_resolve_interval duration if set force an update to all hostnames and reconnect if changed, defaults to 0 (disabled) --port int Port to use for vtcombo. If this is 0, a random port will be chosen. --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --proto_topo string Define the fake cluster topology as a compact text format encoded vttest proto. See vttest.proto for more information. --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --queryserver-config-transaction-timeout float query server transaction timeout (in seconds), a transaction will be killed if it takes longer than this value diff --git a/go/flags/endtoend/zkctl.txt b/go/flags/endtoend/zkctl.txt index 18c47d7c2d2..b89528766d8 100644 --- a/go/flags/endtoend/zkctl.txt +++ b/go/flags/endtoend/zkctl.txt @@ -28,7 +28,7 @@ Flags: --log_rotate_max_size uint size in bytes at which logs are rotated (glog.MaxSize) (default 1887436800) --logtostderr log to standard error instead of files --pprof strings enable profiling - --pprof-http enable pprof http endpoints (default true) + --pprof-http enable pprof http endpoints --purge_logs_interval duration how often try to remove old logs (default 1h0m0s) --stderrthreshold severityFlag logs at or above this threshold go to stderr (default 1) --v Level log level for V logs diff --git a/go/vt/servenv/http.go b/go/vt/servenv/http.go index 57cf19673ad..c4b14e9b4e6 100644 --- a/go/vt/servenv/http.go +++ b/go/vt/servenv/http.go @@ -22,9 +22,6 @@ import ( "net/http" "net/http/pprof" - "github.com/spf13/pflag" - - "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/servenv/internal/mux" ) @@ -53,10 +50,6 @@ func HTTPRegisterProfile() { return } - if !pflag.Lookup("pprof-http").Changed { - log.Warning("Beginning in v20, pprof-http will default to `false`; to continue enabling pprof endpoints, please manually set this flag before upgrading.") - } - HTTPHandleFunc("/debug/pprof/", pprof.Index) HTTPHandleFunc("/debug/pprof/cmdline", pprof.Cmdline) HTTPHandleFunc("/debug/pprof/profile", pprof.Profile) diff --git a/go/vt/servenv/pprof.go b/go/vt/servenv/pprof.go index 66d2dd4ed22..957c0504c00 100644 --- a/go/vt/servenv/pprof.go +++ b/go/vt/servenv/pprof.go @@ -35,7 +35,7 @@ import ( var ( pprofFlag []string - httpPprof = true + httpPprof bool ) type profmode string From b539ce927ee86b723a94a627cdec1403dd4020f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <42793+vmg@users.noreply.github.com> Date: Fri, 16 Feb 2024 11:21:40 +0100 Subject: [PATCH 25/79] sqlparser: use integers instead of literals for Length/Precision (#15256) Signed-off-by: Vicent Marti --- go/ptr/ptr.go | 31 + .../queries/aggregation/aggregation_test.go | 21 + .../vtgate/queries/aggregation/schema.sql | 10 +- .../vtgate/queries/aggregation/vschema.json | 8 + go/vt/schemadiff/table.go | 26 +- go/vt/sqlparser/ast.go | 8 +- go/vt/sqlparser/ast_clone.go | 28 +- go/vt/sqlparser/ast_copy_on_rewrite.go | 24 - go/vt/sqlparser/ast_equals.go | 32 +- go/vt/sqlparser/ast_format.go | 10 +- go/vt/sqlparser/ast_format_fast.go | 12 +- go/vt/sqlparser/ast_funcs.go | 6 +- go/vt/sqlparser/ast_rewrite.go | 36 +- go/vt/sqlparser/ast_visit.go | 12 - go/vt/sqlparser/cached_size.go | 20 +- go/vt/sqlparser/goyacc/goyacc.go | 17 +- go/vt/sqlparser/sql.go | 3227 ++++++++--------- go/vt/sqlparser/sql.y | 66 +- go/vt/vtgate/evalengine/cached_size.go | 8 +- go/vt/vtgate/evalengine/compiler.go | 2 +- go/vt/vtgate/evalengine/compiler_asm.go | 18 +- go/vt/vtgate/evalengine/compiler_fn.go | 2 +- go/vt/vtgate/evalengine/expr_collate.go | 2 +- go/vt/vtgate/evalengine/expr_compare.go | 4 +- go/vt/vtgate/evalengine/expr_convert.go | 78 +- go/vt/vtgate/evalengine/fn_base64.go | 4 +- go/vt/vtgate/evalengine/fn_crypto.go | 6 +- go/vt/vtgate/evalengine/fn_hex.go | 4 +- go/vt/vtgate/evalengine/fn_misc.go | 14 +- go/vt/vtgate/evalengine/fn_numeric.go | 4 +- go/vt/vtgate/evalengine/fn_regexp.go | 6 +- go/vt/vtgate/evalengine/fn_string.go | 31 +- go/vt/vtgate/evalengine/fn_time.go | 8 +- go/vt/vtgate/evalengine/format.go | 10 +- go/vt/vtgate/evalengine/translate_builtin.go | 5 +- go/vt/vtgate/evalengine/translate_convert.go | 46 +- go/vt/vtgate/schema/tracker.go | 33 +- 37 files changed, 1921 insertions(+), 1958 deletions(-) create mode 100644 go/ptr/ptr.go diff --git a/go/ptr/ptr.go b/go/ptr/ptr.go new file mode 100644 index 00000000000..8fd7f6c0bf9 --- /dev/null +++ b/go/ptr/ptr.go @@ -0,0 +1,31 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package ptr + +// Of returns a pointer to the given value +func Of[T any](x T) *T { + return &x +} + +// Unwrap dereferences the given pointer if it's not nil. +// Otherwise, it returns default_ +func Unwrap[T any](x *T, default_ T) T { + if x != nil { + return *x + } + return default_ +} diff --git a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go index 310abedd09a..89b3d0c8c85 100644 --- a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go +++ b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go @@ -557,6 +557,27 @@ func TestComplexAggregation(t *testing.T) { }) } +func TestJoinAggregation(t *testing.T) { + // This is new functionality in Vitess 20 + utils.SkipIfBinaryIsBelowVersion(t, 20, "vtgate") + + mcmp, closer := start(t) + defer closer() + + mcmp.Exec("insert into t1(t1_id, `name`, `value`, shardkey) values(1,'a1','foo',100), (2,'b1','foo',200), (3,'c1','foo',300), (4,'a1','foo',100), (5,'d1','toto',200), (6,'c1','tata',893), (7,'a1','titi',2380), (8,'b1','tete',12833), (9,'e1','yoyo',783493)") + + mcmp.Exec(`insert into bet_logs(id, merchant_game_id, bet_amount, game_id) values + (1, 1, 22.5, 40), (2, 1, 15.3, 40), + (3, 2, 22.5, 40), (4, 2, 15.3, 40), + (5, 3, 22.5, 40), (6, 3, 15.3, 40), + (7, 3, 22.5, 40), (8, 4, 15.3, 40) +`) + + mcmp.Exec("set @@sql_mode = ' '") + mcmp.Exec(`SELECT t1.name, SUM(b.bet_amount) AS bet_amount FROM bet_logs as b LEFT JOIN t1 ON b.merchant_game_id = t1.t1_id GROUP BY b.merchant_game_id`) + mcmp.Exec(`SELECT t1.name, CAST(SUM(b.bet_amount) AS DECIMAL(20,6)) AS bet_amount FROM bet_logs as b LEFT JOIN t1 ON b.merchant_game_id = t1.t1_id GROUP BY b.merchant_game_id`) +} + // TestGroupConcatAggregation tests the group_concat function with vitess doing the aggregation. func TestGroupConcatAggregation(t *testing.T) { mcmp, closer := start(t) diff --git a/go/test/endtoend/vtgate/queries/aggregation/schema.sql b/go/test/endtoend/vtgate/queries/aggregation/schema.sql index e1489b4bd21..49956b98302 100644 --- a/go/test/endtoend/vtgate/queries/aggregation/schema.sql +++ b/go/test/endtoend/vtgate/queries/aggregation/schema.sql @@ -96,4 +96,12 @@ CREATE TABLE dept ( loc VARCHAR(13), PRIMARY KEY (deptno) ) Engine = InnoDB - COLLATE = utf8mb4_general_ci; \ No newline at end of file + COLLATE = utf8mb4_general_ci; + +CREATE TABLE bet_logs ( + id bigint unsigned NOT NULL, + merchant_game_id bigint unsigned NOT NULL, + bet_amount DECIMAL(20, 8), + game_id bigint, + PRIMARY KEY (id) +) ENGINE InnoDB; diff --git a/go/test/endtoend/vtgate/queries/aggregation/vschema.json b/go/test/endtoend/vtgate/queries/aggregation/vschema.json index 050202aed81..6c3cddf4436 100644 --- a/go/test/endtoend/vtgate/queries/aggregation/vschema.json +++ b/go/test/endtoend/vtgate/queries/aggregation/vschema.json @@ -147,6 +147,14 @@ "name": "hash" } ] + }, + "bet_logs": { + "column_vindexes": [ + { + "column": "id", + "name": "hash" + } + ] } } } \ No newline at end of file diff --git a/go/vt/schemadiff/table.go b/go/vt/schemadiff/table.go index 79f9f535836..aab697c2bf0 100644 --- a/go/vt/schemadiff/table.go +++ b/go/vt/schemadiff/table.go @@ -25,6 +25,7 @@ import ( golcs "github.com/yudai/golcs" + "vitess.io/vitess/go/ptr" "vitess.io/vitess/go/vt/sqlparser" ) @@ -530,10 +531,7 @@ func (c *CreateTableEntity) normalizeColumnOptions() { // "show create table" reports it as a tinyint(1). if col.Type.Type == "boolean" { col.Type.Type = "tinyint" - col.Type.Length = &sqlparser.Literal{ - Type: sqlparser.IntVal, - Val: "1", - } + col.Type.Length = ptr.Of(1) if col.Type.Options.Default != nil { val, ok := col.Type.Options.Default.(sqlparser.BoolVal) @@ -562,16 +560,14 @@ func (c *CreateTableEntity) normalizeColumnOptions() { col.Type.Type = "double" } - if col.Type.Length != nil && col.Type.Scale == nil && col.Type.Length.Type == sqlparser.IntVal { - if l, err := strconv.ParseInt(col.Type.Length.Val, 10, 64); err == nil { - // See https://dev.mysql.com/doc/refman/8.0/en/floating-point-types.html, but the docs are - // subtly wrong. We use a float for a precision of 24, not a double as the documentation - // mentioned. Validated against the actual behavior of MySQL. - if l <= 24 { - col.Type.Type = "float" - } else { - col.Type.Type = "double" - } + if col.Type.Length != nil && col.Type.Scale == nil { + // See https://dev.mysql.com/doc/refman/8.0/en/floating-point-types.html, but the docs are + // subtly wrong. We use a float for a precision of 24, not a double as the documentation + // mentioned. Validated against the actual behavior of MySQL. + if *col.Type.Length <= 24 { + col.Type.Type = "float" + } else { + col.Type.Type = "double" } col.Type.Length = nil } @@ -627,7 +623,7 @@ func (c *CreateTableEntity) normalizeIndexOptions() { } func isBool(colType *sqlparser.ColumnType) bool { - return colType.Type == sqlparser.KeywordString(sqlparser.TINYINT) && colType.Length != nil && sqlparser.CanonicalString(colType.Length) == "1" + return colType.Type == sqlparser.KeywordString(sqlparser.TINYINT) && colType.Length != nil && *colType.Length == 1 } func (c *CreateTableEntity) normalizePartitionOptions() { diff --git a/go/vt/sqlparser/ast.go b/go/vt/sqlparser/ast.go index 0e50d71b77c..569148a224a 100644 --- a/go/vt/sqlparser/ast.go +++ b/go/vt/sqlparser/ast.go @@ -1815,10 +1815,10 @@ type ColumnType struct { Options *ColumnTypeOptions // Numeric field options - Length *Literal + Length *int Unsigned bool Zerofill bool - Scale *Literal + Scale *int // Text field options Charset ColumnCharset @@ -3427,8 +3427,8 @@ func (ListArg) iColTuple() {} // ConvertType represents the type in call to CONVERT(expr, type) type ConvertType struct { Type string - Length *Literal - Scale *Literal + Length *int + Scale *int Charset ColumnCharset } diff --git a/go/vt/sqlparser/ast_clone.go b/go/vt/sqlparser/ast_clone.go index ef46a348df1..9b1128c3cbf 100644 --- a/go/vt/sqlparser/ast_clone.go +++ b/go/vt/sqlparser/ast_clone.go @@ -964,8 +964,8 @@ func CloneRefOfColumnType(n *ColumnType) *ColumnType { } out := *n out.Options = CloneRefOfColumnTypeOptions(n.Options) - out.Length = CloneRefOfLiteral(n.Length) - out.Scale = CloneRefOfLiteral(n.Scale) + out.Length = CloneRefOfInt(n.Length) + out.Scale = CloneRefOfInt(n.Scale) out.Charset = CloneColumnCharset(n.Charset) out.EnumValues = CloneSliceOfString(n.EnumValues) return &out @@ -1054,8 +1054,8 @@ func CloneRefOfConvertType(n *ConvertType) *ConvertType { return nil } out := *n - out.Length = CloneRefOfLiteral(n.Length) - out.Scale = CloneRefOfLiteral(n.Scale) + out.Length = CloneRefOfInt(n.Length) + out.Scale = CloneRefOfInt(n.Scale) out.Charset = CloneColumnCharset(n.Charset) return &out } @@ -4334,6 +4334,15 @@ func CloneRefOfColumnTypeOptions(n *ColumnTypeOptions) *ColumnTypeOptions { return &out } +// CloneRefOfInt creates a deep clone of the input. +func CloneRefOfInt(n *int) *int { + if n == nil { + return nil + } + out := *n + return &out +} + // CloneColumnCharset creates a deep clone of the input. func CloneColumnCharset(n ColumnCharset) ColumnCharset { return *CloneRefOfColumnCharset(&n) @@ -4522,15 +4531,6 @@ func CloneComments(n Comments) Comments { return res } -// CloneRefOfInt creates a deep clone of the input. -func CloneRefOfInt(n *int) *int { - if n == nil { - return nil - } - out := *n - return &out -} - // CloneSliceOfRefOfPartitionDefinition creates a deep clone of the input. func CloneSliceOfRefOfPartitionDefinition(n []*PartitionDefinition) []*PartitionDefinition { if n == nil { @@ -4666,7 +4666,7 @@ func CloneRefOfIndexColumn(n *IndexColumn) *IndexColumn { } out := *n out.Column = CloneIdentifierCI(n.Column) - out.Length = CloneRefOfLiteral(n.Length) + out.Length = CloneRefOfInt(n.Length) out.Expression = CloneExpr(n.Expression) return &out } diff --git a/go/vt/sqlparser/ast_copy_on_rewrite.go b/go/vt/sqlparser/ast_copy_on_rewrite.go index fa90169355a..1ce13a61b0a 100644 --- a/go/vt/sqlparser/ast_copy_on_rewrite.go +++ b/go/vt/sqlparser/ast_copy_on_rewrite.go @@ -1445,18 +1445,6 @@ func (c *cow) copyOnRewriteRefOfColumnType(n *ColumnType, parent SQLNode) (out S } out = n if c.pre == nil || c.pre(n, parent) { - _Length, changedLength := c.copyOnRewriteRefOfLiteral(n.Length, n) - _Scale, changedScale := c.copyOnRewriteRefOfLiteral(n.Scale, n) - if changedLength || changedScale { - res := *n - res.Length, _ = _Length.(*Literal) - res.Scale, _ = _Scale.(*Literal) - out = &res - if c.cloned != nil { - c.cloned(n, out) - } - changed = true - } } if c.post != nil { out, changed = c.postVisit(out, parent, changed) @@ -1616,18 +1604,6 @@ func (c *cow) copyOnRewriteRefOfConvertType(n *ConvertType, parent SQLNode) (out } out = n if c.pre == nil || c.pre(n, parent) { - _Length, changedLength := c.copyOnRewriteRefOfLiteral(n.Length, n) - _Scale, changedScale := c.copyOnRewriteRefOfLiteral(n.Scale, n) - if changedLength || changedScale { - res := *n - res.Length, _ = _Length.(*Literal) - res.Scale, _ = _Scale.(*Literal) - out = &res - if c.cloned != nil { - c.cloned(n, out) - } - changed = true - } } if c.post != nil { out, changed = c.postVisit(out, parent, changed) diff --git a/go/vt/sqlparser/ast_equals.go b/go/vt/sqlparser/ast_equals.go index c3cc5dad18d..47ba31fcd20 100644 --- a/go/vt/sqlparser/ast_equals.go +++ b/go/vt/sqlparser/ast_equals.go @@ -2112,8 +2112,8 @@ func (cmp *Comparator) RefOfColumnType(a, b *ColumnType) bool { a.Unsigned == b.Unsigned && a.Zerofill == b.Zerofill && cmp.RefOfColumnTypeOptions(a.Options, b.Options) && - cmp.RefOfLiteral(a.Length, b.Length) && - cmp.RefOfLiteral(a.Scale, b.Scale) && + cmp.RefOfInt(a.Length, b.Length) && + cmp.RefOfInt(a.Scale, b.Scale) && cmp.ColumnCharset(a.Charset, b.Charset) && cmp.SliceOfString(a.EnumValues, b.EnumValues) } @@ -2213,8 +2213,8 @@ func (cmp *Comparator) RefOfConvertType(a, b *ConvertType) bool { return false } return a.Type == b.Type && - cmp.RefOfLiteral(a.Length, b.Length) && - cmp.RefOfLiteral(a.Scale, b.Scale) && + cmp.RefOfInt(a.Length, b.Length) && + cmp.RefOfInt(a.Scale, b.Scale) && cmp.ColumnCharset(a.Charset, b.Charset) } @@ -7173,6 +7173,17 @@ func (cmp *Comparator) RefOfColumnTypeOptions(a, b *ColumnTypeOptions) bool { cmp.RefOfLiteral(a.SRID, b.SRID) } +// RefOfInt does deep equals between the two objects. +func (cmp *Comparator) RefOfInt(a, b *int) bool { + if a == b { + return true + } + if a == nil || b == nil { + return false + } + return *a == *b +} + // ColumnCharset does deep equals between the two objects. func (cmp *Comparator) ColumnCharset(a, b ColumnCharset) bool { return a.Name == b.Name && @@ -7384,17 +7395,6 @@ func (cmp *Comparator) Comments(a, b Comments) bool { return true } -// RefOfInt does deep equals between the two objects. -func (cmp *Comparator) RefOfInt(a, b *int) bool { - if a == b { - return true - } - if a == nil || b == nil { - return false - } - return *a == *b -} - // SliceOfRefOfPartitionDefinition does deep equals between the two objects. func (cmp *Comparator) SliceOfRefOfPartitionDefinition(a, b []*PartitionDefinition) bool { if len(a) != len(b) { @@ -7551,7 +7551,7 @@ func (cmp *Comparator) RefOfIndexColumn(a, b *IndexColumn) bool { return false } return cmp.IdentifierCI(a.Column, b.Column) && - cmp.RefOfLiteral(a.Length, b.Length) && + cmp.RefOfInt(a.Length, b.Length) && cmp.Expr(a.Expression, b.Expression) && a.Direction == b.Direction } diff --git a/go/vt/sqlparser/ast_format.go b/go/vt/sqlparser/ast_format.go index 33ea8666c9d..0e7ca0a8231 100644 --- a/go/vt/sqlparser/ast_format.go +++ b/go/vt/sqlparser/ast_format.go @@ -696,10 +696,10 @@ func (ct *ColumnType) Format(buf *TrackedBuffer) { buf.astPrintf(ct, "%#s", ct.Type) if ct.Length != nil && ct.Scale != nil { - buf.astPrintf(ct, "(%v,%v)", ct.Length, ct.Scale) + buf.astPrintf(ct, "(%d,%d)", *ct.Length, *ct.Scale) } else if ct.Length != nil { - buf.astPrintf(ct, "(%v)", ct.Length) + buf.astPrintf(ct, "(%d)", *ct.Length) } if ct.EnumValues != nil { @@ -824,7 +824,7 @@ func (idx *IndexDefinition) Format(buf *TrackedBuffer) { } else { buf.astPrintf(idx, "%v", col.Column) if col.Length != nil { - buf.astPrintf(idx, "(%v)", col.Length) + buf.astPrintf(idx, "(%d)", *col.Length) } } if col.Direction == DescOrder { @@ -1852,9 +1852,9 @@ func (node *ConvertUsingExpr) Format(buf *TrackedBuffer) { func (node *ConvertType) Format(buf *TrackedBuffer) { buf.astPrintf(node, "%#s", node.Type) if node.Length != nil { - buf.astPrintf(node, "(%v", node.Length) + buf.astPrintf(node, "(%d", *node.Length) if node.Scale != nil { - buf.astPrintf(node, ", %v", node.Scale) + buf.astPrintf(node, ", %d", *node.Scale) } buf.astPrintf(node, ")") } diff --git a/go/vt/sqlparser/ast_format_fast.go b/go/vt/sqlparser/ast_format_fast.go index 0f84cb64e7f..a7f1a3c1e93 100644 --- a/go/vt/sqlparser/ast_format_fast.go +++ b/go/vt/sqlparser/ast_format_fast.go @@ -907,14 +907,14 @@ func (ct *ColumnType) FormatFast(buf *TrackedBuffer) { if ct.Length != nil && ct.Scale != nil { buf.WriteByte('(') - ct.Length.FormatFast(buf) + buf.WriteString(fmt.Sprintf("%d", *ct.Length)) buf.WriteByte(',') - ct.Scale.FormatFast(buf) + buf.WriteString(fmt.Sprintf("%d", *ct.Scale)) buf.WriteByte(')') } else if ct.Length != nil { buf.WriteByte('(') - ct.Length.FormatFast(buf) + buf.WriteString(fmt.Sprintf("%d", *ct.Length)) buf.WriteByte(')') } @@ -1111,7 +1111,7 @@ func (idx *IndexDefinition) FormatFast(buf *TrackedBuffer) { col.Column.FormatFast(buf) if col.Length != nil { buf.WriteByte('(') - col.Length.FormatFast(buf) + buf.WriteString(fmt.Sprintf("%d", *col.Length)) buf.WriteByte(')') } } @@ -2486,10 +2486,10 @@ func (node *ConvertType) FormatFast(buf *TrackedBuffer) { buf.WriteString(node.Type) if node.Length != nil { buf.WriteByte('(') - node.Length.FormatFast(buf) + buf.WriteString(fmt.Sprintf("%d", *node.Length)) if node.Scale != nil { buf.WriteString(", ") - node.Scale.FormatFast(buf) + buf.WriteString(fmt.Sprintf("%d", *node.Scale)) } buf.WriteByte(')') } diff --git a/go/vt/sqlparser/ast_funcs.go b/go/vt/sqlparser/ast_funcs.go index 5e63774f5bf..2537cf0020f 100644 --- a/go/vt/sqlparser/ast_funcs.go +++ b/go/vt/sqlparser/ast_funcs.go @@ -69,7 +69,7 @@ type IndexColumn struct { // Only one of Column or Expression can be specified // Length is an optional field which is only applicable when Column is used Column IdentifierCI - Length *Literal + Length *int Expression Expr Direction OrderDirection } @@ -77,8 +77,8 @@ type IndexColumn struct { // LengthScaleOption is used for types that have an optional length // and scale type LengthScaleOption struct { - Length *Literal - Scale *Literal + Length *int + Scale *int } // IndexOption is used for trailing options for indexes: COMMENT, KEY_BLOCK_SIZE, USING, WITH PARSER diff --git a/go/vt/sqlparser/ast_rewrite.go b/go/vt/sqlparser/ast_rewrite.go index 87196ee0b2f..02308ed0758 100644 --- a/go/vt/sqlparser/ast_rewrite.go +++ b/go/vt/sqlparser/ast_rewrite.go @@ -1817,20 +1817,12 @@ func (a *application) rewriteRefOfColumnType(parent SQLNode, node *ColumnType, r return true } } - if !a.rewriteRefOfLiteral(node, node.Length, func(newNode, parent SQLNode) { - parent.(*ColumnType).Length = newNode.(*Literal) - }) { - return false - } - if !a.rewriteRefOfLiteral(node, node.Scale, func(newNode, parent SQLNode) { - parent.(*ColumnType).Scale = newNode.(*Literal) - }) { - return false - } if a.post != nil { - a.cur.replacer = replacer - a.cur.parent = parent - a.cur.node = node + if a.pre == nil { + a.cur.replacer = replacer + a.cur.parent = parent + a.cur.node = node + } if !a.post(&a.cur) { return false } @@ -2082,20 +2074,12 @@ func (a *application) rewriteRefOfConvertType(parent SQLNode, node *ConvertType, return true } } - if !a.rewriteRefOfLiteral(node, node.Length, func(newNode, parent SQLNode) { - parent.(*ConvertType).Length = newNode.(*Literal) - }) { - return false - } - if !a.rewriteRefOfLiteral(node, node.Scale, func(newNode, parent SQLNode) { - parent.(*ConvertType).Scale = newNode.(*Literal) - }) { - return false - } if a.post != nil { - a.cur.replacer = replacer - a.cur.parent = parent - a.cur.node = node + if a.pre == nil { + a.cur.replacer = replacer + a.cur.parent = parent + a.cur.node = node + } if !a.post(&a.cur) { return false } diff --git a/go/vt/sqlparser/ast_visit.go b/go/vt/sqlparser/ast_visit.go index 2133bc05330..007b4048da9 100644 --- a/go/vt/sqlparser/ast_visit.go +++ b/go/vt/sqlparser/ast_visit.go @@ -1105,12 +1105,6 @@ func VisitRefOfColumnType(in *ColumnType, f Visit) error { if cont, err := f(in); err != nil || !cont { return err } - if err := VisitRefOfLiteral(in.Length, f); err != nil { - return err - } - if err := VisitRefOfLiteral(in.Scale, f); err != nil { - return err - } return nil } func VisitColumns(in Columns, f Visit) error { @@ -1218,12 +1212,6 @@ func VisitRefOfConvertType(in *ConvertType, f Visit) error { if cont, err := f(in); err != nil || !cont { return err } - if err := VisitRefOfLiteral(in.Length, f); err != nil { - return err - } - if err := VisitRefOfLiteral(in.Scale, f); err != nil { - return err - } return nil } func VisitRefOfConvertUsingExpr(in *ConvertUsingExpr, f Visit) error { diff --git a/go/vt/sqlparser/cached_size.go b/go/vt/sqlparser/cached_size.go index fe83cdce2ed..bf5620f8b09 100644 --- a/go/vt/sqlparser/cached_size.go +++ b/go/vt/sqlparser/cached_size.go @@ -723,10 +723,10 @@ func (cached *ColumnType) CachedSize(alloc bool) int64 { size += hack.RuntimeAllocSize(int64(len(cached.Type))) // field Options *vitess.io/vitess/go/vt/sqlparser.ColumnTypeOptions size += cached.Options.CachedSize(true) - // field Length *vitess.io/vitess/go/vt/sqlparser.Literal - size += cached.Length.CachedSize(true) - // field Scale *vitess.io/vitess/go/vt/sqlparser.Literal - size += cached.Scale.CachedSize(true) + // field Length *int + size += hack.RuntimeAllocSize(int64(8)) + // field Scale *int + size += hack.RuntimeAllocSize(int64(8)) // field Charset vitess.io/vitess/go/vt/sqlparser.ColumnCharset size += cached.Charset.CachedSize(false) // field EnumValues []string @@ -905,10 +905,10 @@ func (cached *ConvertType) CachedSize(alloc bool) int64 { } // field Type string size += hack.RuntimeAllocSize(int64(len(cached.Type))) - // field Length *vitess.io/vitess/go/vt/sqlparser.Literal - size += cached.Length.CachedSize(true) - // field Scale *vitess.io/vitess/go/vt/sqlparser.Literal - size += cached.Scale.CachedSize(true) + // field Length *int + size += hack.RuntimeAllocSize(int64(8)) + // field Scale *int + size += hack.RuntimeAllocSize(int64(8)) // field Charset vitess.io/vitess/go/vt/sqlparser.ColumnCharset size += cached.Charset.CachedSize(false) return size @@ -1731,8 +1731,8 @@ func (cached *IndexColumn) CachedSize(alloc bool) int64 { } // field Column vitess.io/vitess/go/vt/sqlparser.IdentifierCI size += cached.Column.CachedSize(false) - // field Length *vitess.io/vitess/go/vt/sqlparser.Literal - size += cached.Length.CachedSize(true) + // field Length *int + size += hack.RuntimeAllocSize(int64(8)) // field Expression vitess.io/vitess/go/vt/sqlparser.Expr if cc, ok := cached.Expression.(cachedObject); ok { size += cc.CachedSize(true) diff --git a/go/vt/sqlparser/goyacc/goyacc.go b/go/vt/sqlparser/goyacc/goyacc.go index 5864b5090b4..51650b0891e 100644 --- a/go/vt/sqlparser/goyacc/goyacc.go +++ b/go/vt/sqlparser/goyacc/goyacc.go @@ -49,7 +49,6 @@ import ( "bufio" "bytes" "fmt" - "go/format" "os" "regexp" "sort" @@ -58,6 +57,8 @@ import ( "unicode" "github.com/spf13/pflag" + + "vitess.io/vitess/go/tools/codegen" ) // the following are adjustable @@ -3326,7 +3327,7 @@ func exit(status int) { if ftable != nil { ftable.Flush() ftable = nil - gofmt() + _ = codegen.GoImports(oflag) } if foutput != nil { foutput.Flush() @@ -3339,18 +3340,6 @@ func exit(status int) { os.Exit(status) } -func gofmt() { - src, err := os.ReadFile(oflag) - if err != nil { - return - } - src, err = format.Source(src) - if err != nil { - return - } - os.WriteFile(oflag, src, 0666) -} - const fastAppendHelperText = ` func $$Iaddr(v any) __yyunsafe__.Pointer { type h struct { diff --git a/go/vt/sqlparser/sql.go b/go/vt/sqlparser/sql.go index b35472fce71..baa8e713f94 100644 --- a/go/vt/sqlparser/sql.go +++ b/go/vt/sqlparser/sql.go @@ -6,6 +6,8 @@ package sqlparser import ( __yyfmt__ "fmt" __yyunsafe__ "unsafe" + + "vitess.io/vitess/go/ptr" ) //line sql.y:17 @@ -7731,7 +7733,7 @@ var yyPgo = [...]int{ 2812, 19, 4982, 7758, 2804, 41, 157, 2803, 2802, 7552, 22, 43, 15, 2801, 205, 2799, 2797, 2791, 2788, 197, 204, 108, 156, 58, 2786, 2783, 2780, 72, 2777, 2773, - 2766, 2764, 2763, 2754, 71, 34, 33, 31, 215, 59, + 2766, 2764, 2763, 2754, 34, 33, 31, 71, 215, 59, 25, 96, 152, 151, 69, 2753, 2752, 2751, 120, 87, 2750, 154, 153, 124, 165, 2748, 178, 140, 118, 2747, 106, 30, 2744, 2740, 2739, 2738, 85, 2737, 2734, 2733, @@ -7743,7 +7745,7 @@ var yyPgo = [...]int{ 2637, 139, 2636, 2627, 2617, 0, 1021, 127, 2616, 200, } -//line sql.y:8635 +//line sql.y:8625 type yySymType struct { union any empty struct{} @@ -8027,6 +8029,11 @@ func (st *yySymType) insertActionUnion() InsertAction { return v } +func (st *yySymType) intPtrUnion() *int { + v, _ := st.union.(*int) + return v +} + func (st *yySymType) integerUnion() int { v, _ := st.union.(int) return v @@ -8464,7 +8471,7 @@ var yyR1 = [...]int{ 319, 321, 321, 321, 321, 321, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 323, 323, 323, 323, 323, 323, 323, 323, - 338, 338, 324, 324, 332, 332, 333, 333, 334, 334, + 338, 338, 327, 327, 332, 332, 333, 333, 334, 334, 334, 335, 335, 335, 336, 336, 329, 329, 329, 329, 329, 329, 329, 329, 329, 331, 331, 330, 330, 330, 341, 366, 366, 365, 365, 363, 363, 363, 363, 363, @@ -8498,7 +8505,7 @@ var yyR1 = [...]int{ 376, 337, 337, 337, 370, 370, 372, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 116, 115, 115, 114, 117, 117, 117, 117, 117, 117, 117, 117, 374, - 374, 374, 63, 63, 375, 325, 326, 327, 5, 6, + 374, 374, 63, 63, 375, 324, 325, 326, 5, 6, 351, 373, 124, 124, 24, 39, 39, 25, 25, 25, 25, 26, 26, 64, 67, 67, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, @@ -9067,7 +9074,7 @@ var yyChk = [...]int{ 344, 345, 364, 365, 366, 367, 369, 370, 371, 372, 327, 348, 579, 328, 329, 330, 331, 332, 333, 335, 336, 339, 337, 338, 340, 341, -384, -383, 88, 90, - 89, -324, 88, -145, -137, 241, -383, 242, 242, 242, + 89, -327, 88, -145, -137, 241, -383, 242, 242, 242, -79, 471, -350, -350, -350, 272, 21, -46, -43, -376, 20, -42, -43, 233, 124, 125, 230, 88, -339, 88, -348, -384, -383, 88, 139, 247, 138, -347, -344, -347, @@ -9125,9 +9132,9 @@ var yyChk = [...]int{ -193, -216, -415, -173, -31, 600, 597, 16, -183, -184, -192, -299, -269, -312, -268, 89, 417, 419, 420, 78, 123, -145, -330, 179, -358, -357, -356, -339, -341, -342, - -343, 90, -330, -335, 379, 378, -324, -324, -324, -324, - -324, -329, -329, -329, -329, 88, 88, -324, -324, -324, - -324, -332, 88, -332, -332, -333, -332, 88, -333, -334, + -343, 90, -330, -335, 379, 378, -327, -327, -327, -327, + -327, -329, -329, -329, -329, 88, 88, -327, -327, -327, + -327, -332, 88, -332, -332, -333, -332, 88, -333, -334, 88, -334, -369, -145, -366, -365, -363, -364, 251, 102, 672, 628, 581, 621, 662, 79, -361, -233, 97, -416, -143, -285, 246, -367, -364, -383, -383, -383, -285, 92, @@ -9209,15 +9216,15 @@ var yyChk = [...]int{ 89, 90, 89, 90, 90, 89, -287, -286, -45, -44, -350, -350, 97, -383, 91, 91, 243, 28, -190, 78, 78, 78, -113, 732, 97, 88, -3, 83, -145, 88, - 21, -339, -217, -374, -325, -375, -326, -327, -5, -6, + 21, -339, -217, -374, -324, -375, -325, -326, -5, -6, -351, -116, 59, 102, -63, 46, 242, 712, 713, 128, -415, 725, -366, -254, -370, -372, -190, -149, -415, -161, -147, -146, -148, -154, 169, 170, 264, 342, 343, -218, -190, -138, 292, 300, 88, -142, 93, -386, 79, 283, 376, 283, 376, 91, -408, 315, 91, -408, -190, -84, -49, -190, -282, -282, 35, -383, -416, -162, -153, -125, - 164, 581, -316, 587, -324, -324, -324, -334, -324, 332, - -324, 332, -324, -416, -416, -416, 89, -416, 24, -416, + 164, 581, -316, 587, -327, -327, -327, -334, -327, 332, + -327, 332, -327, -416, -416, -416, 89, -416, 24, -416, 89, -145, 89, -121, 477, 89, 89, -416, 88, 88, -145, -416, -416, -416, 89, -416, -416, -416, -416, -416, -416, -416, -416, -416, -416, -416, -416, -416, 89, -416, @@ -9285,8 +9292,8 @@ var yyChk = [...]int{ 78, 592, 693, -92, -91, -88, 704, 730, -209, -94, -94, -145, -145, -145, -416, -293, 247, -416, -416, -107, 89, -104, -103, -293, 78, 123, -266, -293, 90, -416, - -415, -234, 90, -238, -29, 88, -3, 276, -325, -375, - -326, -327, -5, -6, -351, -82, 581, -377, -355, -299, + -415, -234, 90, -238, -29, 88, -3, 276, -324, -375, + -325, -326, -5, -6, -351, -82, 581, -377, -355, -299, -295, 91, 97, 90, 581, -416, -416, -90, 147, 702, 670, -155, 223, -416, 89, -416, 89, -416, 89, -105, 89, 27, -302, -176, -174, -293, 634, -395, -394, 577, @@ -10211,7 +10218,7 @@ yydefault: case 1: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:608 +//line sql.y:612 { stmt := yyDollar[2].statementUnion() // If the statement is empty and we have comments @@ -10225,58 +10232,58 @@ yydefault: } case 2: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:621 +//line sql.y:625 { } case 3: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:622 +//line sql.y:626 { } case 4: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:626 +//line sql.y:630 { yyLOCAL = yyDollar[1].selStmtUnion() } yyVAL.union = yyLOCAL case 40: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:665 +//line sql.y:669 { setParseTree(yylex, nil) } case 41: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Variable -//line sql.y:671 +//line sql.y:675 { yyLOCAL = NewVariableExpression(yyDollar[1].str, SingleAt) } yyVAL.union = yyLOCAL case 42: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:677 +//line sql.y:681 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } case 43: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:682 +//line sql.y:686 { yyVAL.identifierCI = NewIdentifierCI("") } case 44: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:686 +//line sql.y:690 { yyVAL.identifierCI = yyDollar[1].identifierCI } case 45: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Variable -//line sql.y:692 +//line sql.y:696 { yyLOCAL = NewVariableExpression(string(yyDollar[1].str), SingleAt) } @@ -10284,7 +10291,7 @@ yydefault: case 46: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Variable -//line sql.y:696 +//line sql.y:700 { yyLOCAL = NewVariableExpression(string(yyDollar[1].str), DoubleAt) } @@ -10292,7 +10299,7 @@ yydefault: case 47: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:702 +//line sql.y:706 { yyLOCAL = &OtherAdmin{} } @@ -10300,7 +10307,7 @@ yydefault: case 48: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:708 +//line sql.y:712 { yyLOCAL = &Load{} } @@ -10308,7 +10315,7 @@ yydefault: case 49: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *With -//line sql.y:714 +//line sql.y:718 { yyLOCAL = &With{CTEs: yyDollar[2].ctesUnion(), Recursive: false} } @@ -10316,7 +10323,7 @@ yydefault: case 50: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *With -//line sql.y:718 +//line sql.y:722 { yyLOCAL = &With{CTEs: yyDollar[3].ctesUnion(), Recursive: true} } @@ -10324,7 +10331,7 @@ yydefault: case 51: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *With -//line sql.y:723 +//line sql.y:727 { yyLOCAL = nil } @@ -10332,14 +10339,14 @@ yydefault: case 52: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *With -//line sql.y:727 +//line sql.y:731 { yyLOCAL = yyDollar[1].withUnion() } yyVAL.union = yyLOCAL case 53: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:733 +//line sql.y:737 { yySLICE := (*[]*CommonTableExpr)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].cteUnion()) @@ -10347,7 +10354,7 @@ yydefault: case 54: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*CommonTableExpr -//line sql.y:737 +//line sql.y:741 { yyLOCAL = []*CommonTableExpr{yyDollar[1].cteUnion()} } @@ -10355,7 +10362,7 @@ yydefault: case 55: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *CommonTableExpr -//line sql.y:743 +//line sql.y:747 { yyLOCAL = &CommonTableExpr{ID: yyDollar[1].identifierCS, Columns: yyDollar[2].columnsUnion(), Subquery: yyDollar[4].subqueryUnion()} } @@ -10363,7 +10370,7 @@ yydefault: case 56: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:749 +//line sql.y:753 { yyLOCAL = yyDollar[2].selStmtUnion() } @@ -10371,7 +10378,7 @@ yydefault: case 57: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:753 +//line sql.y:757 { yyLOCAL = yyDollar[2].selStmtUnion() } @@ -10379,7 +10386,7 @@ yydefault: case 58: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:757 +//line sql.y:761 { setLockInSelect(yyDollar[2].selStmtUnion(), yyDollar[3].lockUnion()) yyLOCAL = yyDollar[2].selStmtUnion() @@ -10388,7 +10395,7 @@ yydefault: case 59: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:780 +//line sql.y:784 { yyDollar[1].selStmtUnion().SetOrderBy(yyDollar[2].orderByUnion()) yyDollar[1].selStmtUnion().SetLimit(yyDollar[3].limitUnion()) @@ -10398,7 +10405,7 @@ yydefault: case 60: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:786 +//line sql.y:790 { yyDollar[1].selStmtUnion().SetLimit(yyDollar[2].limitUnion()) yyLOCAL = yyDollar[1].selStmtUnion() @@ -10407,7 +10414,7 @@ yydefault: case 61: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:791 +//line sql.y:795 { yyDollar[1].selStmtUnion().SetOrderBy(yyDollar[2].orderByUnion()) yyDollar[1].selStmtUnion().SetLimit(yyDollar[3].limitUnion()) @@ -10417,7 +10424,7 @@ yydefault: case 62: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:797 +//line sql.y:801 { yyDollar[2].selStmtUnion().SetWith(yyDollar[1].withUnion()) yyDollar[2].selStmtUnion().SetOrderBy(yyDollar[3].orderByUnion()) @@ -10428,7 +10435,7 @@ yydefault: case 63: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:804 +//line sql.y:808 { yyDollar[2].selStmtUnion().SetWith(yyDollar[1].withUnion()) yyDollar[2].selStmtUnion().SetLimit(yyDollar[3].limitUnion()) @@ -10438,7 +10445,7 @@ yydefault: case 64: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:810 +//line sql.y:814 { yyDollar[2].selStmtUnion().SetWith(yyDollar[1].withUnion()) yyDollar[2].selStmtUnion().SetOrderBy(yyDollar[3].orderByUnion()) @@ -10448,14 +10455,14 @@ yydefault: yyVAL.union = yyLOCAL case 65: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:817 +//line sql.y:821 { yyDollar[2].selStmtUnion().SetWith(yyDollar[1].withUnion()) } case 66: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:821 +//line sql.y:825 { yyLOCAL = NewSelect(Comments(yyDollar[2].strs), SelectExprs{&Nextval{Expr: yyDollar[5].exprUnion()}}, []string{yyDollar[3].str} /*options*/, nil, TableExprs{&AliasedTableExpr{Expr: yyDollar[7].tableName}}, nil /*where*/, nil /*groupBy*/, nil /*having*/, nil) } @@ -10463,7 +10470,7 @@ yydefault: case 67: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:827 +//line sql.y:831 { yyLOCAL = yyDollar[1].selStmtUnion() } @@ -10471,7 +10478,7 @@ yydefault: case 68: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:831 +//line sql.y:835 { yyLOCAL = &Union{Left: yyDollar[1].selStmtUnion(), Distinct: yyDollar[2].booleanUnion(), Right: yyDollar[3].selStmtUnion()} } @@ -10479,7 +10486,7 @@ yydefault: case 69: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:835 +//line sql.y:839 { yyLOCAL = &Union{Left: yyDollar[1].selStmtUnion(), Distinct: yyDollar[2].booleanUnion(), Right: yyDollar[3].selStmtUnion()} } @@ -10487,7 +10494,7 @@ yydefault: case 70: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:839 +//line sql.y:843 { yyLOCAL = &Union{Left: yyDollar[1].selStmtUnion(), Distinct: yyDollar[2].booleanUnion(), Right: yyDollar[3].selStmtUnion()} } @@ -10495,7 +10502,7 @@ yydefault: case 71: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:843 +//line sql.y:847 { yyLOCAL = &Union{Left: yyDollar[1].selStmtUnion(), Distinct: yyDollar[2].booleanUnion(), Right: yyDollar[3].selStmtUnion()} } @@ -10503,7 +10510,7 @@ yydefault: case 72: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:849 +//line sql.y:853 { yyLOCAL = yyDollar[1].selStmtUnion() } @@ -10511,7 +10518,7 @@ yydefault: case 73: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:853 +//line sql.y:857 { setLockInSelect(yyDollar[1].selStmtUnion(), yyDollar[2].lockUnion()) yyLOCAL = yyDollar[1].selStmtUnion() @@ -10520,7 +10527,7 @@ yydefault: case 74: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:858 +//line sql.y:862 { yyLOCAL = yyDollar[1].selStmtUnion() } @@ -10528,7 +10535,7 @@ yydefault: case 75: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:862 +//line sql.y:866 { yyLOCAL = yyDollar[1].selStmtUnion() } @@ -10536,7 +10543,7 @@ yydefault: case 76: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:868 +//line sql.y:872 { yyLOCAL = yyDollar[2].selStmtUnion() } @@ -10544,7 +10551,7 @@ yydefault: case 77: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:872 +//line sql.y:876 { yyDollar[1].selStmtUnion().SetInto(yyDollar[2].selectIntoUnion()) yyLOCAL = yyDollar[1].selStmtUnion() @@ -10553,7 +10560,7 @@ yydefault: case 78: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:877 +//line sql.y:881 { yyDollar[1].selStmtUnion().SetInto(yyDollar[2].selectIntoUnion()) yyDollar[1].selStmtUnion().SetLock(yyDollar[3].lockUnion()) @@ -10563,7 +10570,7 @@ yydefault: case 79: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:883 +//line sql.y:887 { yyDollar[1].selStmtUnion().SetInto(yyDollar[3].selectIntoUnion()) yyDollar[1].selStmtUnion().SetLock(yyDollar[2].lockUnion()) @@ -10573,7 +10580,7 @@ yydefault: case 80: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:889 +//line sql.y:893 { yyDollar[1].selStmtUnion().SetInto(yyDollar[2].selectIntoUnion()) yyLOCAL = yyDollar[1].selStmtUnion() @@ -10582,7 +10589,7 @@ yydefault: case 81: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:896 +//line sql.y:900 { yyLOCAL = &Stream{Comments: Comments(yyDollar[2].strs).Parsed(), SelectExpr: yyDollar[3].selectExprUnion(), Table: yyDollar[5].tableName} } @@ -10590,7 +10597,7 @@ yydefault: case 82: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:902 +//line sql.y:906 { yyLOCAL = &VStream{Comments: Comments(yyDollar[2].strs).Parsed(), SelectExpr: yyDollar[3].selectExprUnion(), Table: yyDollar[5].tableName, Where: NewWhere(WhereClause, yyDollar[6].exprUnion()), Limit: yyDollar[7].limitUnion()} } @@ -10598,7 +10605,7 @@ yydefault: case 83: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:910 +//line sql.y:914 { yyLOCAL = NewSelect(Comments(yyDollar[2].strs), yyDollar[4].selectExprsUnion() /*SelectExprs*/, yyDollar[3].strs /*options*/, yyDollar[5].selectIntoUnion() /*into*/, yyDollar[6].tableExprsUnion() /*from*/, NewWhere(WhereClause, yyDollar[7].exprUnion()), GroupBy(yyDollar[8].exprsUnion()), NewWhere(HavingClause, yyDollar[9].exprUnion()), yyDollar[10].namedWindowsUnion()) } @@ -10606,7 +10613,7 @@ yydefault: case 84: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL SelectStatement -//line sql.y:914 +//line sql.y:918 { yyLOCAL = NewSelect(Comments(yyDollar[2].strs), yyDollar[4].selectExprsUnion() /*SelectExprs*/, yyDollar[3].strs /*options*/, nil, yyDollar[5].tableExprsUnion() /*from*/, NewWhere(WhereClause, yyDollar[6].exprUnion()), GroupBy(yyDollar[7].exprsUnion()), NewWhere(HavingClause, yyDollar[8].exprUnion()), yyDollar[9].namedWindowsUnion()) } @@ -10614,7 +10621,7 @@ yydefault: case 85: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:920 +//line sql.y:924 { // insert_data returns a *Insert pre-filled with Columns & Values ins := yyDollar[6].insUnion() @@ -10630,7 +10637,7 @@ yydefault: case 86: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Statement -//line sql.y:932 +//line sql.y:936 { cols := make(Columns, 0, len(yyDollar[7].updateExprsUnion())) vals := make(ValTuple, 0, len(yyDollar[8].updateExprsUnion())) @@ -10644,7 +10651,7 @@ yydefault: case 87: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL InsertAction -//line sql.y:944 +//line sql.y:948 { yyLOCAL = InsertAct } @@ -10652,7 +10659,7 @@ yydefault: case 88: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL InsertAction -//line sql.y:948 +//line sql.y:952 { yyLOCAL = ReplaceAct } @@ -10660,7 +10667,7 @@ yydefault: case 89: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Statement -//line sql.y:954 +//line sql.y:958 { yyLOCAL = &Update{With: yyDollar[1].withUnion(), Comments: Comments(yyDollar[3].strs).Parsed(), Ignore: yyDollar[4].ignoreUnion(), TableExprs: yyDollar[5].tableExprsUnion(), Exprs: yyDollar[7].updateExprsUnion(), Where: NewWhere(WhereClause, yyDollar[8].exprUnion()), OrderBy: yyDollar[9].orderByUnion(), Limit: yyDollar[10].limitUnion()} } @@ -10668,7 +10675,7 @@ yydefault: case 90: yyDollar = yyS[yypt-11 : yypt+1] var yyLOCAL Statement -//line sql.y:960 +//line sql.y:964 { yyLOCAL = &Delete{With: yyDollar[1].withUnion(), Comments: Comments(yyDollar[3].strs).Parsed(), Ignore: yyDollar[4].ignoreUnion(), TableExprs: TableExprs{&AliasedTableExpr{Expr: yyDollar[6].tableName, As: yyDollar[7].identifierCS}}, Partitions: yyDollar[8].partitionsUnion(), Where: NewWhere(WhereClause, yyDollar[9].exprUnion()), OrderBy: yyDollar[10].orderByUnion(), Limit: yyDollar[11].limitUnion()} } @@ -10676,7 +10683,7 @@ yydefault: case 91: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Statement -//line sql.y:964 +//line sql.y:968 { yyLOCAL = &Delete{With: yyDollar[1].withUnion(), Comments: Comments(yyDollar[3].strs).Parsed(), Ignore: yyDollar[4].ignoreUnion(), Targets: yyDollar[6].tableNamesUnion(), TableExprs: yyDollar[8].tableExprsUnion(), Where: NewWhere(WhereClause, yyDollar[9].exprUnion())} } @@ -10684,7 +10691,7 @@ yydefault: case 92: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Statement -//line sql.y:968 +//line sql.y:972 { yyLOCAL = &Delete{With: yyDollar[1].withUnion(), Comments: Comments(yyDollar[3].strs).Parsed(), Ignore: yyDollar[4].ignoreUnion(), Targets: yyDollar[5].tableNamesUnion(), TableExprs: yyDollar[7].tableExprsUnion(), Where: NewWhere(WhereClause, yyDollar[8].exprUnion())} } @@ -10692,32 +10699,32 @@ yydefault: case 93: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Statement -//line sql.y:972 +//line sql.y:976 { yyLOCAL = &Delete{With: yyDollar[1].withUnion(), Comments: Comments(yyDollar[3].strs).Parsed(), Ignore: yyDollar[4].ignoreUnion(), Targets: yyDollar[5].tableNamesUnion(), TableExprs: yyDollar[7].tableExprsUnion(), Where: NewWhere(WhereClause, yyDollar[8].exprUnion())} } yyVAL.union = yyLOCAL case 94: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:977 +//line sql.y:981 { } case 95: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:978 +//line sql.y:982 { } case 96: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableNames -//line sql.y:982 +//line sql.y:986 { yyLOCAL = TableNames{yyDollar[1].tableName} } yyVAL.union = yyLOCAL case 97: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:986 +//line sql.y:990 { yySLICE := (*TableNames)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableName) @@ -10725,14 +10732,14 @@ yydefault: case 98: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableNames -//line sql.y:992 +//line sql.y:996 { yyLOCAL = TableNames{yyDollar[1].tableName} } yyVAL.union = yyLOCAL case 99: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:996 +//line sql.y:1000 { yySLICE := (*TableNames)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableName) @@ -10740,14 +10747,14 @@ yydefault: case 100: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableNames -//line sql.y:1002 +//line sql.y:1006 { yyLOCAL = TableNames{yyDollar[1].tableName} } yyVAL.union = yyLOCAL case 101: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1006 +//line sql.y:1010 { yySLICE := (*TableNames)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableName) @@ -10755,7 +10762,7 @@ yydefault: case 102: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Partitions -//line sql.y:1011 +//line sql.y:1015 { yyLOCAL = nil } @@ -10763,7 +10770,7 @@ yydefault: case 103: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Partitions -//line sql.y:1015 +//line sql.y:1019 { yyLOCAL = yyDollar[3].partitionsUnion() } @@ -10771,7 +10778,7 @@ yydefault: case 104: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:1021 +//line sql.y:1025 { yyLOCAL = NewSetStatement(Comments(yyDollar[2].strs).Parsed(), yyDollar[3].setExprsUnion()) } @@ -10779,14 +10786,14 @@ yydefault: case 105: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SetExprs -//line sql.y:1027 +//line sql.y:1031 { yyLOCAL = SetExprs{yyDollar[1].setExprUnion()} } yyVAL.union = yyLOCAL case 106: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1031 +//line sql.y:1035 { yySLICE := (*SetExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].setExprUnion()) @@ -10794,7 +10801,7 @@ yydefault: case 107: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SetExpr -//line sql.y:1037 +//line sql.y:1041 { yyLOCAL = &SetExpr{Var: yyDollar[1].variableUnion(), Expr: NewStrLiteral("on")} } @@ -10802,7 +10809,7 @@ yydefault: case 108: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SetExpr -//line sql.y:1041 +//line sql.y:1045 { yyLOCAL = &SetExpr{Var: yyDollar[1].variableUnion(), Expr: NewStrLiteral("off")} } @@ -10810,7 +10817,7 @@ yydefault: case 109: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SetExpr -//line sql.y:1045 +//line sql.y:1049 { yyLOCAL = &SetExpr{Var: yyDollar[1].variableUnion(), Expr: yyDollar[3].exprUnion()} } @@ -10818,7 +10825,7 @@ yydefault: case 110: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SetExpr -//line sql.y:1049 +//line sql.y:1053 { yyLOCAL = &SetExpr{Var: NewSetVariable(string(yyDollar[1].str), SessionScope), Expr: yyDollar[2].exprUnion()} } @@ -10826,7 +10833,7 @@ yydefault: case 111: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Variable -//line sql.y:1055 +//line sql.y:1059 { yyLOCAL = NewSetVariable(string(yyDollar[1].str), SessionScope) } @@ -10834,7 +10841,7 @@ yydefault: case 112: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Variable -//line sql.y:1059 +//line sql.y:1063 { yyLOCAL = yyDollar[1].variableUnion() } @@ -10842,7 +10849,7 @@ yydefault: case 113: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Variable -//line sql.y:1063 +//line sql.y:1067 { yyLOCAL = NewSetVariable(string(yyDollar[2].str), yyDollar[1].scopeUnion()) } @@ -10850,7 +10857,7 @@ yydefault: case 114: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:1069 +//line sql.y:1073 { yyLOCAL = NewSetStatement(Comments(yyDollar[2].strs).Parsed(), UpdateSetExprsScope(yyDollar[5].setExprsUnion(), yyDollar[3].scopeUnion())) } @@ -10858,7 +10865,7 @@ yydefault: case 115: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:1073 +//line sql.y:1077 { yyLOCAL = NewSetStatement(Comments(yyDollar[2].strs).Parsed(), yyDollar[4].setExprsUnion()) } @@ -10866,14 +10873,14 @@ yydefault: case 116: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SetExprs -//line sql.y:1079 +//line sql.y:1083 { yyLOCAL = SetExprs{yyDollar[1].setExprUnion()} } yyVAL.union = yyLOCAL case 117: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1083 +//line sql.y:1087 { yySLICE := (*SetExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].setExprUnion()) @@ -10881,7 +10888,7 @@ yydefault: case 118: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SetExpr -//line sql.y:1089 +//line sql.y:1093 { yyLOCAL = &SetExpr{Var: NewSetVariable(TransactionIsolationStr, NextTxScope), Expr: NewStrLiteral(yyDollar[3].str)} } @@ -10889,7 +10896,7 @@ yydefault: case 119: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SetExpr -//line sql.y:1093 +//line sql.y:1097 { yyLOCAL = &SetExpr{Var: NewSetVariable(TransactionReadOnlyStr, NextTxScope), Expr: NewStrLiteral("off")} } @@ -10897,39 +10904,39 @@ yydefault: case 120: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SetExpr -//line sql.y:1097 +//line sql.y:1101 { yyLOCAL = &SetExpr{Var: NewSetVariable(TransactionReadOnlyStr, NextTxScope), Expr: NewStrLiteral("on")} } yyVAL.union = yyLOCAL case 121: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1103 +//line sql.y:1107 { yyVAL.str = RepeatableReadStr } case 122: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1107 +//line sql.y:1111 { yyVAL.str = ReadCommittedStr } case 123: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1111 +//line sql.y:1115 { yyVAL.str = ReadUncommittedStr } case 124: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1115 +//line sql.y:1119 { yyVAL.str = SerializableStr } case 125: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Scope -//line sql.y:1121 +//line sql.y:1125 { yyLOCAL = SessionScope } @@ -10937,7 +10944,7 @@ yydefault: case 126: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Scope -//line sql.y:1125 +//line sql.y:1129 { yyLOCAL = SessionScope } @@ -10945,7 +10952,7 @@ yydefault: case 127: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Scope -//line sql.y:1129 +//line sql.y:1133 { yyLOCAL = GlobalScope } @@ -10953,7 +10960,7 @@ yydefault: case 128: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:1135 +//line sql.y:1139 { yyDollar[1].createTableUnion().TableSpec = yyDollar[2].tableSpecUnion() yyDollar[1].createTableUnion().FullyParsed = true @@ -10963,7 +10970,7 @@ yydefault: case 129: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:1141 +//line sql.y:1145 { // Create table [name] like [name] yyDollar[1].createTableUnion().OptLike = yyDollar[2].optLikeUnion() @@ -10974,7 +10981,7 @@ yydefault: case 130: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:1148 +//line sql.y:1152 { indexDef := yyDollar[1].alterTableUnion().AlterOptions[0].(*AddIndexDefinition).IndexDefinition indexDef.Columns = yyDollar[3].indexColumnsUnion() @@ -10987,7 +10994,7 @@ yydefault: case 131: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Statement -//line sql.y:1157 +//line sql.y:1161 { yyLOCAL = &CreateView{ViewName: yyDollar[8].tableName, Comments: Comments(yyDollar[2].strs).Parsed(), IsReplace: yyDollar[3].booleanUnion(), Algorithm: yyDollar[4].str, Definer: yyDollar[5].definerUnion(), Security: yyDollar[6].str, Columns: yyDollar[9].columnsUnion(), Select: yyDollar[11].selStmtUnion(), CheckOption: yyDollar[12].str} } @@ -10995,7 +11002,7 @@ yydefault: case 132: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:1161 +//line sql.y:1165 { yyDollar[1].createDatabaseUnion().FullyParsed = true yyDollar[1].createDatabaseUnion().CreateOptions = yyDollar[2].databaseOptionsUnion() @@ -11005,7 +11012,7 @@ yydefault: case 133: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:1168 +//line sql.y:1172 { yyLOCAL = false } @@ -11013,33 +11020,33 @@ yydefault: case 134: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:1172 +//line sql.y:1176 { yyLOCAL = true } yyVAL.union = yyLOCAL case 135: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1177 +//line sql.y:1181 { yyVAL.identifierCI = NewIdentifierCI("") } case 136: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1181 +//line sql.y:1185 { yyVAL.identifierCI = yyDollar[2].identifierCI } case 137: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1187 +//line sql.y:1191 { yyVAL.identifierCI = yyDollar[1].identifierCI } case 138: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []VindexParam -//line sql.y:1192 +//line sql.y:1196 { var v []VindexParam yyLOCAL = v @@ -11048,7 +11055,7 @@ yydefault: case 139: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []VindexParam -//line sql.y:1197 +//line sql.y:1201 { yyLOCAL = yyDollar[2].vindexParamsUnion() } @@ -11056,7 +11063,7 @@ yydefault: case 140: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []VindexParam -//line sql.y:1203 +//line sql.y:1207 { yyLOCAL = make([]VindexParam, 0, 4) yyLOCAL = append(yyLOCAL, yyDollar[1].vindexParam) @@ -11064,21 +11071,21 @@ yydefault: yyVAL.union = yyLOCAL case 141: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1208 +//line sql.y:1212 { yySLICE := (*[]VindexParam)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].vindexParam) } case 142: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1214 +//line sql.y:1218 { yyVAL.vindexParam = VindexParam{Key: yyDollar[1].identifierCI, Val: yyDollar[3].str} } case 143: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*JSONObjectParam -//line sql.y:1219 +//line sql.y:1223 { yyLOCAL = nil } @@ -11086,7 +11093,7 @@ yydefault: case 144: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*JSONObjectParam -//line sql.y:1223 +//line sql.y:1227 { yyLOCAL = yyDollar[1].jsonObjectParamsUnion() } @@ -11094,28 +11101,28 @@ yydefault: case 145: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*JSONObjectParam -//line sql.y:1229 +//line sql.y:1233 { yyLOCAL = []*JSONObjectParam{yyDollar[1].jsonObjectParam} } yyVAL.union = yyLOCAL case 146: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1233 +//line sql.y:1237 { yySLICE := (*[]*JSONObjectParam)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].jsonObjectParam) } case 147: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1239 +//line sql.y:1243 { yyVAL.jsonObjectParam = &JSONObjectParam{Key: yyDollar[1].exprUnion(), Value: yyDollar[3].exprUnion()} } case 148: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *CreateTable -//line sql.y:1245 +//line sql.y:1249 { yyLOCAL = &CreateTable{Comments: Comments(yyDollar[2].strs).Parsed(), Table: yyDollar[6].tableName, IfNotExists: yyDollar[5].booleanUnion(), Temp: yyDollar[3].booleanUnion()} setDDL(yylex, yyLOCAL) @@ -11124,7 +11131,7 @@ yydefault: case 149: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *AlterTable -//line sql.y:1252 +//line sql.y:1256 { yyLOCAL = &AlterTable{Comments: Comments(yyDollar[2].strs).Parsed(), Table: yyDollar[4].tableName} setDDL(yylex, yyLOCAL) @@ -11133,7 +11140,7 @@ yydefault: case 150: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *AlterTable -//line sql.y:1259 +//line sql.y:1263 { yyLOCAL = &AlterTable{Table: yyDollar[7].tableName, AlterOptions: []AlterOption{&AddIndexDefinition{IndexDefinition: &IndexDefinition{Info: &IndexInfo{Name: yyDollar[4].identifierCI}, Options: yyDollar[5].indexOptionsUnion()}}}} setDDL(yylex, yyLOCAL) @@ -11142,7 +11149,7 @@ yydefault: case 151: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *AlterTable -//line sql.y:1264 +//line sql.y:1268 { yyLOCAL = &AlterTable{Table: yyDollar[8].tableName, AlterOptions: []AlterOption{&AddIndexDefinition{IndexDefinition: &IndexDefinition{Info: &IndexInfo{Name: yyDollar[5].identifierCI, Type: IndexTypeFullText}, Options: yyDollar[6].indexOptionsUnion()}}}} setDDL(yylex, yyLOCAL) @@ -11151,7 +11158,7 @@ yydefault: case 152: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *AlterTable -//line sql.y:1269 +//line sql.y:1273 { yyLOCAL = &AlterTable{Table: yyDollar[8].tableName, AlterOptions: []AlterOption{&AddIndexDefinition{IndexDefinition: &IndexDefinition{Info: &IndexInfo{Name: yyDollar[5].identifierCI, Type: IndexTypeSpatial}, Options: yyDollar[6].indexOptionsUnion()}}}} setDDL(yylex, yyLOCAL) @@ -11160,7 +11167,7 @@ yydefault: case 153: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *AlterTable -//line sql.y:1274 +//line sql.y:1278 { yyLOCAL = &AlterTable{Table: yyDollar[8].tableName, AlterOptions: []AlterOption{&AddIndexDefinition{IndexDefinition: &IndexDefinition{Info: &IndexInfo{Name: yyDollar[5].identifierCI, Type: IndexTypeUnique}, Options: yyDollar[6].indexOptionsUnion()}}}} setDDL(yylex, yyLOCAL) @@ -11169,7 +11176,7 @@ yydefault: case 154: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *CreateDatabase -//line sql.y:1281 +//line sql.y:1285 { yyLOCAL = &CreateDatabase{Comments: Comments(yyDollar[4].strs).Parsed(), DBName: yyDollar[6].identifierCS, IfNotExists: yyDollar[5].booleanUnion()} setDDL(yylex, yyLOCAL) @@ -11178,7 +11185,7 @@ yydefault: case 155: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *AlterDatabase -//line sql.y:1288 +//line sql.y:1292 { yyLOCAL = &AlterDatabase{} setDDL(yylex, yyLOCAL) @@ -11187,7 +11194,7 @@ yydefault: case 158: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *TableSpec -//line sql.y:1299 +//line sql.y:1303 { yyLOCAL = yyDollar[2].tableSpecUnion() yyLOCAL.Options = yyDollar[4].tableOptionsUnion() @@ -11197,7 +11204,7 @@ yydefault: case 159: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []DatabaseOption -//line sql.y:1306 +//line sql.y:1310 { yyLOCAL = nil } @@ -11205,7 +11212,7 @@ yydefault: case 160: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []DatabaseOption -//line sql.y:1310 +//line sql.y:1314 { yyLOCAL = yyDollar[1].databaseOptionsUnion() } @@ -11213,7 +11220,7 @@ yydefault: case 161: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []DatabaseOption -//line sql.y:1316 +//line sql.y:1320 { yyLOCAL = []DatabaseOption{yyDollar[1].databaseOption} } @@ -11221,7 +11228,7 @@ yydefault: case 162: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []DatabaseOption -//line sql.y:1320 +//line sql.y:1324 { yyLOCAL = []DatabaseOption{yyDollar[1].databaseOption} } @@ -11229,28 +11236,28 @@ yydefault: case 163: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []DatabaseOption -//line sql.y:1324 +//line sql.y:1328 { yyLOCAL = []DatabaseOption{yyDollar[1].databaseOption} } yyVAL.union = yyLOCAL case 164: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1328 +//line sql.y:1332 { yySLICE := (*[]DatabaseOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].databaseOption) } case 165: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1332 +//line sql.y:1336 { yySLICE := (*[]DatabaseOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].databaseOption) } case 166: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1336 +//line sql.y:1340 { yySLICE := (*[]DatabaseOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].databaseOption) @@ -11258,7 +11265,7 @@ yydefault: case 167: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:1342 +//line sql.y:1346 { yyLOCAL = false } @@ -11266,51 +11273,51 @@ yydefault: case 168: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:1346 +//line sql.y:1350 { yyLOCAL = true } yyVAL.union = yyLOCAL case 169: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1352 +//line sql.y:1356 { yyVAL.databaseOption = DatabaseOption{Type: CharacterSetType, Value: string(yyDollar[4].str), IsDefault: yyDollar[1].booleanUnion()} } case 170: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1356 +//line sql.y:1360 { yyVAL.databaseOption = DatabaseOption{Type: CharacterSetType, Value: encodeSQLString(yyDollar[4].str), IsDefault: yyDollar[1].booleanUnion()} } case 171: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1362 +//line sql.y:1366 { yyVAL.databaseOption = DatabaseOption{Type: CollateType, Value: string(yyDollar[4].str), IsDefault: yyDollar[1].booleanUnion()} } case 172: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1366 +//line sql.y:1370 { yyVAL.databaseOption = DatabaseOption{Type: CollateType, Value: encodeSQLString(yyDollar[4].str), IsDefault: yyDollar[1].booleanUnion()} } case 173: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1372 +//line sql.y:1376 { yyVAL.databaseOption = DatabaseOption{Type: EncryptionType, Value: string(yyDollar[4].str), IsDefault: yyDollar[1].booleanUnion()} } case 174: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1376 +//line sql.y:1380 { yyVAL.databaseOption = DatabaseOption{Type: EncryptionType, Value: encodeSQLString(yyDollar[4].str), IsDefault: yyDollar[1].booleanUnion()} } case 175: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *OptLike -//line sql.y:1382 +//line sql.y:1386 { yyLOCAL = &OptLike{LikeTable: yyDollar[2].tableName} } @@ -11318,7 +11325,7 @@ yydefault: case 176: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *OptLike -//line sql.y:1386 +//line sql.y:1390 { yyLOCAL = &OptLike{LikeTable: yyDollar[3].tableName} } @@ -11326,14 +11333,14 @@ yydefault: case 177: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*ColumnDefinition -//line sql.y:1392 +//line sql.y:1396 { yyLOCAL = []*ColumnDefinition{yyDollar[1].columnDefinitionUnion()} } yyVAL.union = yyLOCAL case 178: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1396 +//line sql.y:1400 { yySLICE := (*[]*ColumnDefinition)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].columnDefinitionUnion()) @@ -11341,7 +11348,7 @@ yydefault: case 179: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *TableSpec -//line sql.y:1402 +//line sql.y:1406 { yyLOCAL = &TableSpec{} yyLOCAL.AddColumn(yyDollar[1].columnDefinitionUnion()) @@ -11350,7 +11357,7 @@ yydefault: case 180: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *TableSpec -//line sql.y:1407 +//line sql.y:1411 { yyLOCAL = &TableSpec{} yyLOCAL.AddConstraint(yyDollar[1].constraintDefinitionUnion()) @@ -11358,39 +11365,39 @@ yydefault: yyVAL.union = yyLOCAL case 181: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1412 +//line sql.y:1416 { yyVAL.tableSpecUnion().AddColumn(yyDollar[3].columnDefinitionUnion()) } case 182: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1416 +//line sql.y:1420 { yyVAL.tableSpecUnion().AddColumn(yyDollar[3].columnDefinitionUnion()) yyVAL.tableSpecUnion().AddConstraint(yyDollar[4].constraintDefinitionUnion()) } case 183: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1421 +//line sql.y:1425 { yyVAL.tableSpecUnion().AddIndex(yyDollar[3].indexDefinitionUnion()) } case 184: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1425 +//line sql.y:1429 { yyVAL.tableSpecUnion().AddConstraint(yyDollar[3].constraintDefinitionUnion()) } case 185: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1429 +//line sql.y:1433 { yyVAL.tableSpecUnion().AddConstraint(yyDollar[3].constraintDefinitionUnion()) } case 186: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ColumnDefinition -//line sql.y:1440 +//line sql.y:1444 { yyDollar[2].columnType.Options = yyDollar[4].columnTypeOptionsUnion() if yyDollar[2].columnType.Options.Collate == "" { @@ -11403,7 +11410,7 @@ yydefault: case 187: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL *ColumnDefinition -//line sql.y:1449 +//line sql.y:1453 { yyDollar[2].columnType.Options = yyDollar[9].columnTypeOptionsUnion() yyDollar[2].columnType.Options.As = yyDollar[7].exprUnion() @@ -11414,20 +11421,20 @@ yydefault: yyVAL.union = yyLOCAL case 188: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1458 +//line sql.y:1462 { yyVAL.str = "" } case 189: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1462 +//line sql.y:1466 { yyVAL.str = "" } case 190: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1471 +//line sql.y:1475 { yyLOCAL = &ColumnTypeOptions{Null: nil, Default: nil, OnUpdate: nil, Autoincrement: false, KeyOpt: ColKeyNone, Comment: nil, As: nil, Invisible: nil, Format: UnspecifiedFormat, EngineAttribute: nil, SecondaryEngineAttribute: nil} } @@ -11435,27 +11442,25 @@ yydefault: case 191: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1475 +//line sql.y:1479 { - val := true - yyDollar[1].columnTypeOptionsUnion().Null = &val + yyDollar[1].columnTypeOptionsUnion().Null = ptr.Of(true) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL case 192: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1481 +//line sql.y:1484 { - val := false - yyDollar[1].columnTypeOptionsUnion().Null = &val + yyDollar[1].columnTypeOptionsUnion().Null = ptr.Of(false) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL case 193: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1487 +//line sql.y:1489 { yyDollar[1].columnTypeOptionsUnion().Default = yyDollar[4].exprUnion() yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11464,7 +11469,7 @@ yydefault: case 194: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1492 +//line sql.y:1494 { yyDollar[1].columnTypeOptionsUnion().Default = yyDollar[3].exprUnion() yyDollar[1].columnTypeOptionsUnion().DefaultLiteral = true @@ -11474,7 +11479,7 @@ yydefault: case 195: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1498 +//line sql.y:1500 { yyDollar[1].columnTypeOptionsUnion().OnUpdate = yyDollar[4].exprUnion() yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11483,7 +11488,7 @@ yydefault: case 196: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1503 +//line sql.y:1505 { yyDollar[1].columnTypeOptionsUnion().Autoincrement = true yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11492,7 +11497,7 @@ yydefault: case 197: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1508 +//line sql.y:1510 { yyDollar[1].columnTypeOptionsUnion().Comment = NewStrLiteral(yyDollar[3].str) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11501,7 +11506,7 @@ yydefault: case 198: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1513 +//line sql.y:1515 { yyDollar[1].columnTypeOptionsUnion().KeyOpt = yyDollar[2].colKeyOptUnion() yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11509,14 +11514,14 @@ yydefault: yyVAL.union = yyLOCAL case 199: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1518 +//line sql.y:1520 { yyDollar[1].columnTypeOptionsUnion().Collate = encodeSQLString(yyDollar[3].str) } case 200: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1522 +//line sql.y:1524 { yyDollar[1].columnTypeOptionsUnion().Collate = string(yyDollar[3].identifierCI.String()) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11524,14 +11529,14 @@ yydefault: yyVAL.union = yyLOCAL case 201: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1527 +//line sql.y:1529 { yyDollar[1].columnTypeOptionsUnion().Format = yyDollar[3].columnFormatUnion() } case 202: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1531 +//line sql.y:1533 { yyDollar[1].columnTypeOptionsUnion().SRID = NewIntLiteral(yyDollar[3].str) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11540,20 +11545,18 @@ yydefault: case 203: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1536 +//line sql.y:1538 { - val := false - yyDollar[1].columnTypeOptionsUnion().Invisible = &val + yyDollar[1].columnTypeOptionsUnion().Invisible = ptr.Of(false) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL case 204: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1542 +//line sql.y:1543 { - val := true - yyDollar[1].columnTypeOptionsUnion().Invisible = &val + yyDollar[1].columnTypeOptionsUnion().Invisible = ptr.Of(true) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL @@ -11631,25 +11634,23 @@ yydefault: var yyLOCAL *ColumnTypeOptions //line sql.y:1590 { - val := true - yyDollar[1].columnTypeOptionsUnion().Null = &val + yyDollar[1].columnTypeOptionsUnion().Null = ptr.Of(true) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL case 215: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1596 +//line sql.y:1595 { - val := false - yyDollar[1].columnTypeOptionsUnion().Null = &val + yyDollar[1].columnTypeOptionsUnion().Null = ptr.Of(false) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL case 216: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1602 +//line sql.y:1600 { yyDollar[1].columnTypeOptionsUnion().Comment = NewStrLiteral(yyDollar[3].str) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11658,7 +11659,7 @@ yydefault: case 217: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1607 +//line sql.y:1605 { yyDollar[1].columnTypeOptionsUnion().KeyOpt = yyDollar[2].colKeyOptUnion() yyLOCAL = yyDollar[1].columnTypeOptionsUnion() @@ -11667,27 +11668,25 @@ yydefault: case 218: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1612 +//line sql.y:1610 { - val := false - yyDollar[1].columnTypeOptionsUnion().Invisible = &val + yyDollar[1].columnTypeOptionsUnion().Invisible = ptr.Of(false) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL case 219: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColumnTypeOptions -//line sql.y:1618 +//line sql.y:1615 { - val := true - yyDollar[1].columnTypeOptionsUnion().Invisible = &val + yyDollar[1].columnTypeOptionsUnion().Invisible = ptr.Of(true) yyLOCAL = yyDollar[1].columnTypeOptionsUnion() } yyVAL.union = yyLOCAL case 220: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1626 +//line sql.y:1622 { yyLOCAL = yyDollar[1].exprUnion() } @@ -11695,7 +11694,7 @@ yydefault: case 222: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1633 +//line sql.y:1629 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("current_timestamp"), Fsp: yyDollar[2].integerUnion()} } @@ -11703,7 +11702,7 @@ yydefault: case 223: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1637 +//line sql.y:1633 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("localtime"), Fsp: yyDollar[2].integerUnion()} } @@ -11711,7 +11710,7 @@ yydefault: case 224: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1641 +//line sql.y:1637 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("localtimestamp"), Fsp: yyDollar[2].integerUnion()} } @@ -11719,7 +11718,7 @@ yydefault: case 225: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1645 +//line sql.y:1641 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("utc_timestamp"), Fsp: yyDollar[2].integerUnion()} } @@ -11727,7 +11726,7 @@ yydefault: case 226: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1649 +//line sql.y:1645 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("now"), Fsp: yyDollar[2].integerUnion()} } @@ -11735,7 +11734,7 @@ yydefault: case 227: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1653 +//line sql.y:1649 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("sysdate"), Fsp: yyDollar[2].integerUnion()} } @@ -11743,7 +11742,7 @@ yydefault: case 230: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1663 +//line sql.y:1659 { yyLOCAL = &NullVal{} } @@ -11751,7 +11750,7 @@ yydefault: case 232: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1670 +//line sql.y:1666 { yyLOCAL = yyDollar[2].exprUnion() } @@ -11759,7 +11758,7 @@ yydefault: case 233: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1674 +//line sql.y:1670 { yyLOCAL = &UnaryExpr{Operator: UMinusOp, Expr: yyDollar[2].exprUnion()} } @@ -11767,7 +11766,7 @@ yydefault: case 234: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1680 +//line sql.y:1676 { yyLOCAL = yyDollar[1].exprUnion() } @@ -11775,7 +11774,7 @@ yydefault: case 235: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1684 +//line sql.y:1680 { yyLOCAL = yyDollar[1].exprUnion() } @@ -11783,7 +11782,7 @@ yydefault: case 236: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1688 +//line sql.y:1684 { yyLOCAL = yyDollar[1].boolValUnion() } @@ -11791,7 +11790,7 @@ yydefault: case 237: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1692 +//line sql.y:1688 { yyLOCAL = NewHexLiteral(yyDollar[1].str) } @@ -11799,7 +11798,7 @@ yydefault: case 238: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1696 +//line sql.y:1692 { yyLOCAL = NewHexNumLiteral(yyDollar[1].str) } @@ -11807,7 +11806,7 @@ yydefault: case 239: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1700 +//line sql.y:1696 { yyLOCAL = NewBitLiteral(yyDollar[1].str) } @@ -11815,7 +11814,7 @@ yydefault: case 240: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1704 +//line sql.y:1700 { yyLOCAL = NewBitLiteral("0b" + yyDollar[1].str) } @@ -11823,7 +11822,7 @@ yydefault: case 241: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1708 +//line sql.y:1704 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } @@ -11831,7 +11830,7 @@ yydefault: case 242: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1712 +//line sql.y:1708 { yyLOCAL = &IntroducerExpr{CharacterSet: yyDollar[1].str, Expr: NewBitLiteral("0b" + yyDollar[2].str)} } @@ -11839,7 +11838,7 @@ yydefault: case 243: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1716 +//line sql.y:1712 { yyLOCAL = &IntroducerExpr{CharacterSet: yyDollar[1].str, Expr: NewHexNumLiteral(yyDollar[2].str)} } @@ -11847,7 +11846,7 @@ yydefault: case 244: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1720 +//line sql.y:1716 { yyLOCAL = &IntroducerExpr{CharacterSet: yyDollar[1].str, Expr: NewBitLiteral(yyDollar[2].str)} } @@ -11855,7 +11854,7 @@ yydefault: case 245: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1724 +//line sql.y:1720 { yyLOCAL = &IntroducerExpr{CharacterSet: yyDollar[1].str, Expr: NewHexLiteral(yyDollar[2].str)} } @@ -11863,7 +11862,7 @@ yydefault: case 246: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1728 +//line sql.y:1724 { yyLOCAL = &IntroducerExpr{CharacterSet: yyDollar[1].str, Expr: yyDollar[2].exprUnion()} } @@ -11871,7 +11870,7 @@ yydefault: case 247: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1732 +//line sql.y:1728 { arg := parseBindVariable(yylex, yyDollar[2].str[1:]) yyLOCAL = &IntroducerExpr{CharacterSet: yyDollar[1].str, Expr: arg} @@ -11880,7 +11879,7 @@ yydefault: case 248: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1737 +//line sql.y:1733 { yyLOCAL = NewDateLiteral(yyDollar[2].str) } @@ -11888,7 +11887,7 @@ yydefault: case 249: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1741 +//line sql.y:1737 { yyLOCAL = NewTimeLiteral(yyDollar[2].str) } @@ -11896,267 +11895,267 @@ yydefault: case 250: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1745 +//line sql.y:1741 { yyLOCAL = NewTimestampLiteral(yyDollar[2].str) } yyVAL.union = yyLOCAL case 251: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1751 +//line sql.y:1747 { yyVAL.str = Armscii8Str } case 252: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1755 +//line sql.y:1751 { yyVAL.str = ASCIIStr } case 253: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1759 +//line sql.y:1755 { yyVAL.str = Big5Str } case 254: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1763 +//line sql.y:1759 { yyVAL.str = UBinaryStr } case 255: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1767 +//line sql.y:1763 { yyVAL.str = Cp1250Str } case 256: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1771 +//line sql.y:1767 { yyVAL.str = Cp1251Str } case 257: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1775 +//line sql.y:1771 { yyVAL.str = Cp1256Str } case 258: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1779 +//line sql.y:1775 { yyVAL.str = Cp1257Str } case 259: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1783 +//line sql.y:1779 { yyVAL.str = Cp850Str } case 260: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1787 +//line sql.y:1783 { yyVAL.str = Cp852Str } case 261: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1791 +//line sql.y:1787 { yyVAL.str = Cp866Str } case 262: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1795 +//line sql.y:1791 { yyVAL.str = Cp932Str } case 263: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1799 +//line sql.y:1795 { yyVAL.str = Dec8Str } case 264: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1803 +//line sql.y:1799 { yyVAL.str = EucjpmsStr } case 265: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1807 +//line sql.y:1803 { yyVAL.str = EuckrStr } case 266: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1811 +//line sql.y:1807 { yyVAL.str = Gb18030Str } case 267: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1815 +//line sql.y:1811 { yyVAL.str = Gb2312Str } case 268: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1819 +//line sql.y:1815 { yyVAL.str = GbkStr } case 269: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1823 +//line sql.y:1819 { yyVAL.str = Geostd8Str } case 270: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1827 +//line sql.y:1823 { yyVAL.str = GreekStr } case 271: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1831 +//line sql.y:1827 { yyVAL.str = HebrewStr } case 272: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1835 +//line sql.y:1831 { yyVAL.str = Hp8Str } case 273: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1839 +//line sql.y:1835 { yyVAL.str = Keybcs2Str } case 274: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1843 +//line sql.y:1839 { yyVAL.str = Koi8rStr } case 275: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1847 +//line sql.y:1843 { yyVAL.str = Koi8uStr } case 276: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1851 +//line sql.y:1847 { yyVAL.str = Latin1Str } case 277: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1855 +//line sql.y:1851 { yyVAL.str = Latin2Str } case 278: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1859 +//line sql.y:1855 { yyVAL.str = Latin5Str } case 279: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1863 +//line sql.y:1859 { yyVAL.str = Latin7Str } case 280: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1867 +//line sql.y:1863 { yyVAL.str = MacceStr } case 281: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1871 +//line sql.y:1867 { yyVAL.str = MacromanStr } case 282: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1875 +//line sql.y:1871 { yyVAL.str = SjisStr } case 283: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1879 +//line sql.y:1875 { yyVAL.str = Swe7Str } case 284: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1883 +//line sql.y:1879 { yyVAL.str = Tis620Str } case 285: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1887 +//line sql.y:1883 { yyVAL.str = Ucs2Str } case 286: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1891 +//line sql.y:1887 { yyVAL.str = UjisStr } case 287: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1895 +//line sql.y:1891 { yyVAL.str = Utf16Str } case 288: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1899 +//line sql.y:1895 { yyVAL.str = Utf16leStr } case 289: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1903 +//line sql.y:1899 { yyVAL.str = Utf32Str } case 290: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1907 +//line sql.y:1903 { yyVAL.str = Utf8mb3Str } case 291: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1911 +//line sql.y:1907 { yyVAL.str = Utf8mb4Str } case 292: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1915 +//line sql.y:1911 { yyVAL.str = Utf8mb3Str } case 295: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1925 +//line sql.y:1921 { yyLOCAL = NewIntLiteral(yyDollar[1].str) } @@ -12164,7 +12163,7 @@ yydefault: case 296: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1929 +//line sql.y:1925 { yyLOCAL = NewFloatLiteral(yyDollar[1].str) } @@ -12172,7 +12171,7 @@ yydefault: case 297: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1933 +//line sql.y:1929 { yyLOCAL = NewDecimalLiteral(yyDollar[1].str) } @@ -12180,7 +12179,7 @@ yydefault: case 298: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1939 +//line sql.y:1935 { yyLOCAL = yyDollar[1].exprUnion() } @@ -12188,7 +12187,7 @@ yydefault: case 299: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1943 +//line sql.y:1939 { yyLOCAL = AppendString(yyDollar[1].exprUnion(), yyDollar[2].str) } @@ -12196,7 +12195,7 @@ yydefault: case 300: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1949 +//line sql.y:1945 { yyLOCAL = NewStrLiteral(yyDollar[1].str) } @@ -12204,7 +12203,7 @@ yydefault: case 301: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1953 +//line sql.y:1949 { yyLOCAL = &UnaryExpr{Operator: NStringOp, Expr: NewStrLiteral(yyDollar[1].str)} } @@ -12212,7 +12211,7 @@ yydefault: case 302: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:1957 +//line sql.y:1953 { yyLOCAL = &IntroducerExpr{CharacterSet: yyDollar[1].str, Expr: NewStrLiteral(yyDollar[2].str)} } @@ -12220,7 +12219,7 @@ yydefault: case 303: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1963 +//line sql.y:1959 { yyLOCAL = yyDollar[1].exprUnion() } @@ -12228,7 +12227,7 @@ yydefault: case 304: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:1967 +//line sql.y:1963 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } @@ -12236,7 +12235,7 @@ yydefault: case 305: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ColumnKeyOption -//line sql.y:1973 +//line sql.y:1969 { yyLOCAL = ColKeyPrimary } @@ -12244,7 +12243,7 @@ yydefault: case 306: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColumnKeyOption -//line sql.y:1977 +//line sql.y:1973 { yyLOCAL = ColKeyUnique } @@ -12252,7 +12251,7 @@ yydefault: case 307: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ColumnKeyOption -//line sql.y:1981 +//line sql.y:1977 { yyLOCAL = ColKeyUniqueKey } @@ -12260,14 +12259,14 @@ yydefault: case 308: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColumnKeyOption -//line sql.y:1985 +//line sql.y:1981 { yyLOCAL = ColKey } yyVAL.union = yyLOCAL case 309: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1991 +//line sql.y:1987 { yyVAL.columnType = yyDollar[1].columnType yyVAL.columnType.Unsigned = yyDollar[2].booleanUnion() @@ -12275,74 +12274,74 @@ yydefault: } case 313: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2002 +//line sql.y:1998 { yyVAL.columnType = yyDollar[1].columnType - yyVAL.columnType.Length = yyDollar[2].literalUnion() + yyVAL.columnType.Length = yyDollar[2].intPtrUnion() } case 314: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2007 +//line sql.y:2003 { yyVAL.columnType = yyDollar[1].columnType } case 315: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2013 +//line sql.y:2009 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 316: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2017 +//line sql.y:2013 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 317: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2021 +//line sql.y:2017 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 318: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2025 +//line sql.y:2021 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 319: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2029 +//line sql.y:2025 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 320: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2033 +//line sql.y:2029 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 321: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2037 +//line sql.y:2033 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 322: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2041 +//line sql.y:2037 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 323: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2045 +//line sql.y:2041 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 324: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2051 +//line sql.y:2047 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length @@ -12350,7 +12349,7 @@ yydefault: } case 325: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2057 +//line sql.y:2053 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length @@ -12358,7 +12357,7 @@ yydefault: } case 326: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2063 +//line sql.y:2059 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length @@ -12366,7 +12365,7 @@ yydefault: } case 327: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2069 +//line sql.y:2065 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length @@ -12374,7 +12373,7 @@ yydefault: } case 328: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2075 +//line sql.y:2071 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length @@ -12382,7 +12381,7 @@ yydefault: } case 329: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2081 +//line sql.y:2077 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length @@ -12390,7 +12389,7 @@ yydefault: } case 330: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2087 +//line sql.y:2083 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length @@ -12398,265 +12397,265 @@ yydefault: } case 331: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2095 +//line sql.y:2091 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 332: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2099 +//line sql.y:2095 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } case 333: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2103 +//line sql.y:2099 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } case 334: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2107 +//line sql.y:2103 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } case 335: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2111 +//line sql.y:2107 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } case 336: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2117 +//line sql.y:2113 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion(), Charset: yyDollar[3].columnCharset} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion(), Charset: yyDollar[3].columnCharset} } case 337: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2121 +//line sql.y:2117 { // CHAR BYTE is an alias for binary. See also: // https://dev.mysql.com/doc/refman/8.0/en/string-type-syntax.html - yyVAL.columnType = &ColumnType{Type: "binary", Length: yyDollar[2].literalUnion()} + yyVAL.columnType = &ColumnType{Type: "binary", Length: yyDollar[2].intPtrUnion()} } case 338: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2127 +//line sql.y:2123 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion(), Charset: yyDollar[3].columnCharset} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion(), Charset: yyDollar[3].columnCharset} } case 339: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2131 +//line sql.y:2127 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } case 340: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2135 +//line sql.y:2131 { - yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } case 341: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2139 +//line sql.y:2135 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Charset: yyDollar[2].columnCharset} } case 342: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2143 +//line sql.y:2139 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Charset: yyDollar[2].columnCharset} } case 343: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2147 +//line sql.y:2143 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Charset: yyDollar[2].columnCharset} } case 344: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2151 +//line sql.y:2147 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), Charset: yyDollar[2].columnCharset} } case 345: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2155 +//line sql.y:2151 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 346: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2159 +//line sql.y:2155 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 347: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2163 +//line sql.y:2159 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 348: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2167 +//line sql.y:2163 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 349: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2171 +//line sql.y:2167 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 350: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2175 +//line sql.y:2171 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), EnumValues: yyDollar[3].strs, Charset: yyDollar[5].columnCharset} } case 351: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2180 +//line sql.y:2176 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str), EnumValues: yyDollar[3].strs, Charset: yyDollar[5].columnCharset} } case 352: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2186 +//line sql.y:2182 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 353: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2190 +//line sql.y:2186 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 354: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2194 +//line sql.y:2190 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 355: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2198 +//line sql.y:2194 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 356: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2202 +//line sql.y:2198 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 357: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2206 +//line sql.y:2202 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 358: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2210 +//line sql.y:2206 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 359: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2214 +//line sql.y:2210 { yyVAL.columnType = &ColumnType{Type: string(yyDollar[1].str)} } case 360: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2220 +//line sql.y:2216 { yyVAL.strs = make([]string, 0, 4) yyVAL.strs = append(yyVAL.strs, encodeSQLString(yyDollar[1].str)) } case 361: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2225 +//line sql.y:2221 { yyVAL.strs = append(yyDollar[1].strs, encodeSQLString(yyDollar[3].str)) } case 362: yyDollar = yyS[yypt-0 : yypt+1] - var yyLOCAL *Literal -//line sql.y:2230 + var yyLOCAL *int +//line sql.y:2226 { yyLOCAL = nil } yyVAL.union = yyLOCAL case 363: yyDollar = yyS[yypt-3 : yypt+1] - var yyLOCAL *Literal -//line sql.y:2234 + var yyLOCAL *int +//line sql.y:2230 { - yyLOCAL = NewIntLiteral(yyDollar[2].str) + yyLOCAL = ptr.Of(convertStringToInt(yyDollar[2].str)) } yyVAL.union = yyLOCAL case 364: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2239 +//line sql.y:2235 { yyVAL.LengthScaleOption = LengthScaleOption{} } case 365: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2243 +//line sql.y:2239 { yyVAL.LengthScaleOption = LengthScaleOption{ - Length: NewIntLiteral(yyDollar[2].str), - Scale: NewIntLiteral(yyDollar[4].str), + Length: ptr.Of(convertStringToInt(yyDollar[2].str)), + Scale: ptr.Of(convertStringToInt(yyDollar[4].str)), } } case 366: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2252 +//line sql.y:2248 { yyVAL.LengthScaleOption = yyDollar[1].LengthScaleOption } case 367: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2256 +//line sql.y:2252 { yyVAL.LengthScaleOption = LengthScaleOption{ - Length: NewIntLiteral(yyDollar[2].str), + Length: ptr.Of(convertStringToInt(yyDollar[2].str)), } } case 368: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2263 +//line sql.y:2259 { yyVAL.LengthScaleOption = LengthScaleOption{} } case 369: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2267 +//line sql.y:2263 { yyVAL.LengthScaleOption = LengthScaleOption{ - Length: NewIntLiteral(yyDollar[2].str), + Length: ptr.Of(convertStringToInt(yyDollar[2].str)), } } case 370: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2273 +//line sql.y:2269 { yyVAL.LengthScaleOption = LengthScaleOption{ - Length: NewIntLiteral(yyDollar[2].str), - Scale: NewIntLiteral(yyDollar[4].str), + Length: ptr.Of(convertStringToInt(yyDollar[2].str)), + Scale: ptr.Of(convertStringToInt(yyDollar[4].str)), } } case 371: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:2281 +//line sql.y:2277 { yyLOCAL = false } @@ -12664,7 +12663,7 @@ yydefault: case 372: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:2285 +//line sql.y:2281 { yyLOCAL = true } @@ -12672,7 +12671,7 @@ yydefault: case 373: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:2289 +//line sql.y:2285 { yyLOCAL = false } @@ -12680,7 +12679,7 @@ yydefault: case 374: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:2294 +//line sql.y:2290 { yyLOCAL = false } @@ -12688,66 +12687,66 @@ yydefault: case 375: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:2298 +//line sql.y:2294 { yyLOCAL = true } yyVAL.union = yyLOCAL case 376: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2303 +//line sql.y:2299 { yyVAL.columnCharset = ColumnCharset{} } case 377: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2307 +//line sql.y:2303 { yyVAL.columnCharset = ColumnCharset{Name: string(yyDollar[2].identifierCI.String()), Binary: yyDollar[3].booleanUnion()} } case 378: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2311 +//line sql.y:2307 { yyVAL.columnCharset = ColumnCharset{Name: encodeSQLString(yyDollar[2].str), Binary: yyDollar[3].booleanUnion()} } case 379: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2315 +//line sql.y:2311 { yyVAL.columnCharset = ColumnCharset{Name: string(yyDollar[2].str)} } case 380: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2319 +//line sql.y:2315 { // ASCII: Shorthand for CHARACTER SET latin1. yyVAL.columnCharset = ColumnCharset{Name: "latin1", Binary: yyDollar[2].booleanUnion()} } case 381: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2324 +//line sql.y:2320 { // UNICODE: Shorthand for CHARACTER SET ucs2. yyVAL.columnCharset = ColumnCharset{Name: "ucs2", Binary: yyDollar[2].booleanUnion()} } case 382: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2329 +//line sql.y:2325 { // BINARY: Shorthand for default CHARACTER SET but with binary collation yyVAL.columnCharset = ColumnCharset{Name: "", Binary: true} } case 383: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2334 +//line sql.y:2330 { // BINARY ASCII: Shorthand for CHARACTER SET latin1 with binary collation yyVAL.columnCharset = ColumnCharset{Name: "latin1", Binary: true} } case 384: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2339 +//line sql.y:2335 { // BINARY UNICODE: Shorthand for CHARACTER SET ucs2 with binary collation yyVAL.columnCharset = ColumnCharset{Name: "ucs2", Binary: true} @@ -12755,7 +12754,7 @@ yydefault: case 385: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:2345 +//line sql.y:2341 { yyLOCAL = false } @@ -12763,33 +12762,33 @@ yydefault: case 386: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:2349 +//line sql.y:2345 { yyLOCAL = true } yyVAL.union = yyLOCAL case 387: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2354 +//line sql.y:2350 { yyVAL.str = "" } case 388: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2358 +//line sql.y:2354 { yyVAL.str = string(yyDollar[2].identifierCI.String()) } case 389: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2362 +//line sql.y:2358 { yyVAL.str = encodeSQLString(yyDollar[2].str) } case 390: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexDefinition -//line sql.y:2368 +//line sql.y:2364 { yyLOCAL = &IndexDefinition{Info: yyDollar[1].indexInfoUnion(), Columns: yyDollar[3].indexColumnsUnion(), Options: yyDollar[5].indexOptionsUnion()} } @@ -12797,7 +12796,7 @@ yydefault: case 391: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:2373 +//line sql.y:2369 { yyLOCAL = nil } @@ -12805,7 +12804,7 @@ yydefault: case 392: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:2377 +//line sql.y:2373 { yyLOCAL = yyDollar[1].indexOptionsUnion() } @@ -12813,14 +12812,14 @@ yydefault: case 393: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:2383 +//line sql.y:2379 { yyLOCAL = []*IndexOption{yyDollar[1].indexOptionUnion()} } yyVAL.union = yyLOCAL case 394: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2387 +//line sql.y:2383 { yySLICE := (*[]*IndexOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].indexOptionUnion()) @@ -12828,7 +12827,7 @@ yydefault: case 395: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2393 +//line sql.y:2389 { yyLOCAL = yyDollar[1].indexOptionUnion() } @@ -12836,7 +12835,7 @@ yydefault: case 396: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2397 +//line sql.y:2393 { // should not be string yyLOCAL = &IndexOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} @@ -12845,7 +12844,7 @@ yydefault: case 397: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2402 +//line sql.y:2398 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[2].str)} } @@ -12853,7 +12852,7 @@ yydefault: case 398: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2406 +//line sql.y:2402 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str)} } @@ -12861,7 +12860,7 @@ yydefault: case 399: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2410 +//line sql.y:2406 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str)} } @@ -12869,7 +12868,7 @@ yydefault: case 400: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2414 +//line sql.y:2410 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str) + " " + string(yyDollar[2].str), String: yyDollar[3].identifierCI.String()} } @@ -12877,7 +12876,7 @@ yydefault: case 401: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2418 +//line sql.y:2414 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -12885,27 +12884,27 @@ yydefault: case 402: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:2422 +//line sql.y:2418 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } yyVAL.union = yyLOCAL case 403: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2428 +//line sql.y:2424 { yyVAL.str = "" } case 404: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2432 +//line sql.y:2428 { yyVAL.str = string(yyDollar[1].str) } case 405: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *IndexInfo -//line sql.y:2438 +//line sql.y:2434 { yyLOCAL = &IndexInfo{Type: IndexTypePrimary, ConstraintName: NewIdentifierCI(yyDollar[1].str), Name: NewIdentifierCI("PRIMARY")} } @@ -12913,7 +12912,7 @@ yydefault: case 406: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *IndexInfo -//line sql.y:2442 +//line sql.y:2438 { yyLOCAL = &IndexInfo{Type: IndexTypeSpatial, Name: NewIdentifierCI(yyDollar[3].str)} } @@ -12921,7 +12920,7 @@ yydefault: case 407: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *IndexInfo -//line sql.y:2446 +//line sql.y:2442 { yyLOCAL = &IndexInfo{Type: IndexTypeFullText, Name: NewIdentifierCI(yyDollar[3].str)} } @@ -12929,7 +12928,7 @@ yydefault: case 408: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *IndexInfo -//line sql.y:2450 +//line sql.y:2446 { yyLOCAL = &IndexInfo{Type: IndexTypeUnique, ConstraintName: NewIdentifierCI(yyDollar[1].str), Name: NewIdentifierCI(yyDollar[4].str)} } @@ -12937,100 +12936,100 @@ yydefault: case 409: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *IndexInfo -//line sql.y:2454 +//line sql.y:2450 { yyLOCAL = &IndexInfo{Type: IndexTypeDefault, Name: NewIdentifierCI(yyDollar[2].str)} } yyVAL.union = yyLOCAL case 410: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2459 +//line sql.y:2455 { yyVAL.str = "" } case 411: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2463 +//line sql.y:2459 { yyVAL.str = yyDollar[2].str } case 412: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2469 +//line sql.y:2465 { yyVAL.str = string(yyDollar[1].str) } case 413: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2473 +//line sql.y:2469 { yyVAL.str = string(yyDollar[1].str) } case 414: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2477 +//line sql.y:2473 { yyVAL.str = string(yyDollar[1].str) } case 415: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2483 +//line sql.y:2479 { yyVAL.str = string(yyDollar[1].str) } case 416: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2487 +//line sql.y:2483 { yyVAL.str = string(yyDollar[1].str) } case 417: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2492 +//line sql.y:2488 { yyVAL.str = "" } case 418: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2496 +//line sql.y:2492 { yyVAL.str = yyDollar[1].str } case 419: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2502 +//line sql.y:2498 { yyVAL.str = string(yyDollar[1].str) } case 420: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2506 +//line sql.y:2502 { yyVAL.str = string(yyDollar[1].str) } case 421: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2511 +//line sql.y:2507 { yyVAL.str = "" } case 422: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2515 +//line sql.y:2511 { yyVAL.str = string(yyDollar[1].identifierCI.String()) } case 423: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*IndexColumn -//line sql.y:2521 +//line sql.y:2517 { yyLOCAL = []*IndexColumn{yyDollar[1].indexColumnUnion()} } yyVAL.union = yyLOCAL case 424: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2525 +//line sql.y:2521 { yySLICE := (*[]*IndexColumn)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].indexColumnUnion()) @@ -13038,15 +13037,15 @@ yydefault: case 425: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *IndexColumn -//line sql.y:2531 +//line sql.y:2527 { - yyLOCAL = &IndexColumn{Column: yyDollar[1].identifierCI, Length: yyDollar[2].literalUnion(), Direction: yyDollar[3].orderDirectionUnion()} + yyLOCAL = &IndexColumn{Column: yyDollar[1].identifierCI, Length: yyDollar[2].intPtrUnion(), Direction: yyDollar[3].orderDirectionUnion()} } yyVAL.union = yyLOCAL case 426: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *IndexColumn -//line sql.y:2535 +//line sql.y:2531 { yyLOCAL = &IndexColumn{Expression: yyDollar[2].exprUnion(), Direction: yyDollar[4].orderDirectionUnion()} } @@ -13054,7 +13053,7 @@ yydefault: case 427: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ConstraintDefinition -//line sql.y:2541 +//line sql.y:2537 { yyLOCAL = &ConstraintDefinition{Name: yyDollar[2].identifierCI, Details: yyDollar[3].constraintInfoUnion()} } @@ -13062,7 +13061,7 @@ yydefault: case 428: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConstraintDefinition -//line sql.y:2545 +//line sql.y:2541 { yyLOCAL = &ConstraintDefinition{Details: yyDollar[1].constraintInfoUnion()} } @@ -13070,7 +13069,7 @@ yydefault: case 429: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ConstraintDefinition -//line sql.y:2551 +//line sql.y:2547 { yyLOCAL = &ConstraintDefinition{Name: yyDollar[2].identifierCI, Details: yyDollar[3].constraintInfoUnion()} } @@ -13078,7 +13077,7 @@ yydefault: case 430: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConstraintDefinition -//line sql.y:2555 +//line sql.y:2551 { yyLOCAL = &ConstraintDefinition{Details: yyDollar[1].constraintInfoUnion()} } @@ -13086,7 +13085,7 @@ yydefault: case 431: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL ConstraintInfo -//line sql.y:2561 +//line sql.y:2557 { yyLOCAL = &ForeignKeyDefinition{IndexName: NewIdentifierCI(yyDollar[3].str), Source: yyDollar[5].columnsUnion(), ReferenceDefinition: yyDollar[7].referenceDefinitionUnion()} } @@ -13094,7 +13093,7 @@ yydefault: case 432: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *ReferenceDefinition -//line sql.y:2567 +//line sql.y:2563 { yyLOCAL = &ReferenceDefinition{ReferencedTable: yyDollar[2].tableName, ReferencedColumns: yyDollar[4].columnsUnion(), Match: yyDollar[6].matchActionUnion()} } @@ -13102,7 +13101,7 @@ yydefault: case 433: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *ReferenceDefinition -//line sql.y:2571 +//line sql.y:2567 { yyLOCAL = &ReferenceDefinition{ReferencedTable: yyDollar[2].tableName, ReferencedColumns: yyDollar[4].columnsUnion(), Match: yyDollar[6].matchActionUnion(), OnDelete: yyDollar[7].referenceActionUnion()} } @@ -13110,7 +13109,7 @@ yydefault: case 434: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *ReferenceDefinition -//line sql.y:2575 +//line sql.y:2571 { yyLOCAL = &ReferenceDefinition{ReferencedTable: yyDollar[2].tableName, ReferencedColumns: yyDollar[4].columnsUnion(), Match: yyDollar[6].matchActionUnion(), OnUpdate: yyDollar[7].referenceActionUnion()} } @@ -13118,7 +13117,7 @@ yydefault: case 435: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *ReferenceDefinition -//line sql.y:2579 +//line sql.y:2575 { yyLOCAL = &ReferenceDefinition{ReferencedTable: yyDollar[2].tableName, ReferencedColumns: yyDollar[4].columnsUnion(), Match: yyDollar[6].matchActionUnion(), OnDelete: yyDollar[7].referenceActionUnion(), OnUpdate: yyDollar[8].referenceActionUnion()} } @@ -13126,7 +13125,7 @@ yydefault: case 436: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *ReferenceDefinition -//line sql.y:2583 +//line sql.y:2579 { yyLOCAL = &ReferenceDefinition{ReferencedTable: yyDollar[2].tableName, ReferencedColumns: yyDollar[4].columnsUnion(), Match: yyDollar[6].matchActionUnion(), OnUpdate: yyDollar[7].referenceActionUnion(), OnDelete: yyDollar[8].referenceActionUnion()} } @@ -13134,7 +13133,7 @@ yydefault: case 437: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ReferenceDefinition -//line sql.y:2588 +//line sql.y:2584 { yyLOCAL = nil } @@ -13142,7 +13141,7 @@ yydefault: case 438: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ReferenceDefinition -//line sql.y:2592 +//line sql.y:2588 { yyLOCAL = yyDollar[1].referenceDefinitionUnion() } @@ -13150,7 +13149,7 @@ yydefault: case 439: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL ConstraintInfo -//line sql.y:2598 +//line sql.y:2594 { yyLOCAL = &CheckConstraintDefinition{Expr: yyDollar[3].exprUnion(), Enforced: yyDollar[5].booleanUnion()} } @@ -13158,7 +13157,7 @@ yydefault: case 440: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL MatchAction -//line sql.y:2604 +//line sql.y:2600 { yyLOCAL = yyDollar[2].matchActionUnion() } @@ -13166,7 +13165,7 @@ yydefault: case 441: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL MatchAction -//line sql.y:2610 +//line sql.y:2606 { yyLOCAL = Full } @@ -13174,7 +13173,7 @@ yydefault: case 442: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL MatchAction -//line sql.y:2614 +//line sql.y:2610 { yyLOCAL = Partial } @@ -13182,7 +13181,7 @@ yydefault: case 443: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL MatchAction -//line sql.y:2618 +//line sql.y:2614 { yyLOCAL = Simple } @@ -13190,7 +13189,7 @@ yydefault: case 444: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL MatchAction -//line sql.y:2623 +//line sql.y:2619 { yyLOCAL = DefaultMatch } @@ -13198,7 +13197,7 @@ yydefault: case 445: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL MatchAction -//line sql.y:2627 +//line sql.y:2623 { yyLOCAL = yyDollar[1].matchActionUnion() } @@ -13206,7 +13205,7 @@ yydefault: case 446: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ReferenceAction -//line sql.y:2633 +//line sql.y:2629 { yyLOCAL = yyDollar[3].referenceActionUnion() } @@ -13214,7 +13213,7 @@ yydefault: case 447: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ReferenceAction -//line sql.y:2639 +//line sql.y:2635 { yyLOCAL = yyDollar[3].referenceActionUnion() } @@ -13222,7 +13221,7 @@ yydefault: case 448: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ReferenceAction -//line sql.y:2645 +//line sql.y:2641 { yyLOCAL = Restrict } @@ -13230,7 +13229,7 @@ yydefault: case 449: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ReferenceAction -//line sql.y:2649 +//line sql.y:2645 { yyLOCAL = Cascade } @@ -13238,7 +13237,7 @@ yydefault: case 450: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ReferenceAction -//line sql.y:2653 +//line sql.y:2649 { yyLOCAL = NoAction } @@ -13246,7 +13245,7 @@ yydefault: case 451: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ReferenceAction -//line sql.y:2657 +//line sql.y:2653 { yyLOCAL = SetDefault } @@ -13254,33 +13253,33 @@ yydefault: case 452: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ReferenceAction -//line sql.y:2661 +//line sql.y:2657 { yyLOCAL = SetNull } yyVAL.union = yyLOCAL case 453: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2666 +//line sql.y:2662 { yyVAL.str = "" } case 454: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2670 +//line sql.y:2666 { yyVAL.str = string(yyDollar[1].str) } case 455: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2674 +//line sql.y:2670 { yyVAL.str = string(yyDollar[1].str) } case 456: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:2680 +//line sql.y:2676 { yyLOCAL = true } @@ -13288,7 +13287,7 @@ yydefault: case 457: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:2684 +//line sql.y:2680 { yyLOCAL = false } @@ -13296,7 +13295,7 @@ yydefault: case 458: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:2689 +//line sql.y:2685 { yyLOCAL = true } @@ -13304,7 +13303,7 @@ yydefault: case 459: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:2693 +//line sql.y:2689 { yyLOCAL = yyDollar[1].booleanUnion() } @@ -13312,7 +13311,7 @@ yydefault: case 460: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL TableOptions -//line sql.y:2698 +//line sql.y:2694 { yyLOCAL = nil } @@ -13320,7 +13319,7 @@ yydefault: case 461: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableOptions -//line sql.y:2702 +//line sql.y:2698 { yyLOCAL = yyDollar[1].tableOptionsUnion() } @@ -13328,21 +13327,21 @@ yydefault: case 462: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableOptions -//line sql.y:2708 +//line sql.y:2704 { yyLOCAL = TableOptions{yyDollar[1].tableOptionUnion()} } yyVAL.union = yyLOCAL case 463: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2712 +//line sql.y:2708 { yySLICE := (*TableOptions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableOptionUnion()) } case 464: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2716 +//line sql.y:2712 { yySLICE := (*TableOptions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].tableOptionUnion()) @@ -13350,14 +13349,14 @@ yydefault: case 465: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableOptions -//line sql.y:2722 +//line sql.y:2718 { yyLOCAL = TableOptions{yyDollar[1].tableOptionUnion()} } yyVAL.union = yyLOCAL case 466: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2726 +//line sql.y:2722 { yySLICE := (*TableOptions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].tableOptionUnion()) @@ -13365,7 +13364,7 @@ yydefault: case 467: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2732 +//line sql.y:2728 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13373,7 +13372,7 @@ yydefault: case 468: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2736 +//line sql.y:2732 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13381,7 +13380,7 @@ yydefault: case 469: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2740 +//line sql.y:2736 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13389,7 +13388,7 @@ yydefault: case 470: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2744 +//line sql.y:2740 { yyLOCAL = &TableOption{Name: (string(yyDollar[2].str)), String: yyDollar[4].str, CaseSensitive: true} } @@ -13397,7 +13396,7 @@ yydefault: case 471: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2748 +//line sql.y:2744 { yyLOCAL = &TableOption{Name: string(yyDollar[2].str), String: yyDollar[4].str, CaseSensitive: true} } @@ -13405,7 +13404,7 @@ yydefault: case 472: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2752 +//line sql.y:2748 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13413,7 +13412,7 @@ yydefault: case 473: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2756 +//line sql.y:2752 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -13421,7 +13420,7 @@ yydefault: case 474: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2760 +//line sql.y:2756 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -13429,7 +13428,7 @@ yydefault: case 475: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2764 +//line sql.y:2760 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -13437,7 +13436,7 @@ yydefault: case 476: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2768 +//line sql.y:2764 { yyLOCAL = &TableOption{Name: (string(yyDollar[1].str) + " " + string(yyDollar[2].str)), Value: NewStrLiteral(yyDollar[4].str)} } @@ -13445,7 +13444,7 @@ yydefault: case 477: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2772 +//line sql.y:2768 { yyLOCAL = &TableOption{Name: (string(yyDollar[1].str) + " " + string(yyDollar[2].str)), Value: NewStrLiteral(yyDollar[4].str)} } @@ -13453,7 +13452,7 @@ yydefault: case 478: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2776 +//line sql.y:2772 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13461,7 +13460,7 @@ yydefault: case 479: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2780 +//line sql.y:2776 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -13469,7 +13468,7 @@ yydefault: case 480: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2784 +//line sql.y:2780 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), String: yyDollar[3].identifierCS.String(), CaseSensitive: true} } @@ -13477,7 +13476,7 @@ yydefault: case 481: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2788 +//line sql.y:2784 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -13485,7 +13484,7 @@ yydefault: case 482: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2792 +//line sql.y:2788 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), String: string(yyDollar[3].str)} } @@ -13493,7 +13492,7 @@ yydefault: case 483: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2796 +//line sql.y:2792 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13501,7 +13500,7 @@ yydefault: case 484: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2800 +//line sql.y:2796 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13509,7 +13508,7 @@ yydefault: case 485: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2804 +//line sql.y:2800 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13517,7 +13516,7 @@ yydefault: case 486: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2808 +//line sql.y:2804 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13525,7 +13524,7 @@ yydefault: case 487: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2812 +//line sql.y:2808 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), String: string(yyDollar[3].str)} } @@ -13533,7 +13532,7 @@ yydefault: case 488: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2816 +//line sql.y:2812 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -13541,7 +13540,7 @@ yydefault: case 489: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2820 +//line sql.y:2816 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), String: string(yyDollar[3].str)} } @@ -13549,7 +13548,7 @@ yydefault: case 490: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2824 +//line sql.y:2820 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewStrLiteral(yyDollar[3].str)} } @@ -13557,7 +13556,7 @@ yydefault: case 491: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2828 +//line sql.y:2824 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13565,7 +13564,7 @@ yydefault: case 492: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2832 +//line sql.y:2828 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), String: string(yyDollar[3].str)} } @@ -13573,7 +13572,7 @@ yydefault: case 493: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2836 +//line sql.y:2832 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13581,7 +13580,7 @@ yydefault: case 494: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2840 +//line sql.y:2836 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), String: string(yyDollar[3].str)} } @@ -13589,7 +13588,7 @@ yydefault: case 495: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2844 +//line sql.y:2840 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Value: NewIntLiteral(yyDollar[3].str)} } @@ -13597,7 +13596,7 @@ yydefault: case 496: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2848 +//line sql.y:2844 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), String: (yyDollar[3].identifierCI.String() + yyDollar[4].str), CaseSensitive: true} } @@ -13605,63 +13604,63 @@ yydefault: case 497: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *TableOption -//line sql.y:2852 +//line sql.y:2848 { yyLOCAL = &TableOption{Name: string(yyDollar[1].str), Tables: yyDollar[4].tableNamesUnion()} } yyVAL.union = yyLOCAL case 498: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2857 +//line sql.y:2853 { yyVAL.str = "" } case 499: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2861 +//line sql.y:2857 { yyVAL.str = " " + string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 500: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2865 +//line sql.y:2861 { yyVAL.str = " " + string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 510: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2884 +//line sql.y:2880 { yyVAL.str = String(TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS}) } case 511: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2888 +//line sql.y:2884 { yyVAL.str = yyDollar[1].identifierCI.String() } case 512: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2892 +//line sql.y:2888 { yyVAL.str = encodeSQLString(yyDollar[1].str) } case 513: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2896 +//line sql.y:2892 { yyVAL.str = string(yyDollar[1].str) } case 514: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2901 +//line sql.y:2897 { yyVAL.str = "" } case 516: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:2907 +//line sql.y:2903 { yyLOCAL = false } @@ -13669,7 +13668,7 @@ yydefault: case 517: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:2911 +//line sql.y:2907 { yyLOCAL = true } @@ -13677,7 +13676,7 @@ yydefault: case 518: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ColName -//line sql.y:2916 +//line sql.y:2912 { yyLOCAL = nil } @@ -13685,27 +13684,27 @@ yydefault: case 519: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ColName -//line sql.y:2920 +//line sql.y:2916 { yyLOCAL = yyDollar[2].colNameUnion() } yyVAL.union = yyLOCAL case 520: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2925 +//line sql.y:2921 { yyVAL.str = "" } case 521: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2929 +//line sql.y:2925 { yyVAL.str = string(yyDollar[2].str) } case 522: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *Literal -//line sql.y:2934 +//line sql.y:2930 { yyLOCAL = nil } @@ -13713,7 +13712,7 @@ yydefault: case 523: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Literal -//line sql.y:2938 +//line sql.y:2934 { yyLOCAL = NewIntLiteral(yyDollar[2].str) } @@ -13721,7 +13720,7 @@ yydefault: case 524: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Literal -//line sql.y:2942 +//line sql.y:2938 { yyLOCAL = NewDecimalLiteral(yyDollar[2].str) } @@ -13729,7 +13728,7 @@ yydefault: case 525: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:2947 +//line sql.y:2943 { yyLOCAL = nil } @@ -13737,14 +13736,14 @@ yydefault: case 526: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:2951 +//line sql.y:2947 { yyLOCAL = yyDollar[1].alterOptionsUnion() } yyVAL.union = yyLOCAL case 527: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2955 +//line sql.y:2951 { yySLICE := (*[]AlterOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, &OrderByOption{Cols: yyDollar[5].columnsUnion()}) @@ -13752,14 +13751,14 @@ yydefault: case 528: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:2959 +//line sql.y:2955 { yyLOCAL = yyDollar[1].alterOptionsUnion() } yyVAL.union = yyLOCAL case 529: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2963 +//line sql.y:2959 { yySLICE := (*[]AlterOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].alterOptionsUnion()...) @@ -13767,7 +13766,7 @@ yydefault: case 530: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:2967 +//line sql.y:2963 { yyLOCAL = append(append(yyDollar[1].alterOptionsUnion(), yyDollar[3].alterOptionsUnion()...), &OrderByOption{Cols: yyDollar[7].columnsUnion()}) } @@ -13775,21 +13774,21 @@ yydefault: case 531: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:2973 +//line sql.y:2969 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } yyVAL.union = yyLOCAL case 532: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2977 +//line sql.y:2973 { yySLICE := (*[]AlterOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].alterOptionUnion()) } case 533: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2981 +//line sql.y:2977 { yySLICE := (*[]AlterOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].alterOptionUnion()) @@ -13797,7 +13796,7 @@ yydefault: case 534: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL AlterOption -//line sql.y:2987 +//line sql.y:2983 { yyLOCAL = yyDollar[1].tableOptionsUnion() } @@ -13805,7 +13804,7 @@ yydefault: case 535: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:2991 +//line sql.y:2987 { yyLOCAL = &AddConstraintDefinition{ConstraintDefinition: yyDollar[2].constraintDefinitionUnion()} } @@ -13813,7 +13812,7 @@ yydefault: case 536: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:2995 +//line sql.y:2991 { yyLOCAL = &AddConstraintDefinition{ConstraintDefinition: yyDollar[2].constraintDefinitionUnion()} } @@ -13821,7 +13820,7 @@ yydefault: case 537: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:2999 +//line sql.y:2995 { yyLOCAL = &AddIndexDefinition{IndexDefinition: yyDollar[2].indexDefinitionUnion()} } @@ -13829,7 +13828,7 @@ yydefault: case 538: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3003 +//line sql.y:2999 { yyLOCAL = &AddColumns{Columns: yyDollar[4].columnDefinitionsUnion()} } @@ -13837,7 +13836,7 @@ yydefault: case 539: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3007 +//line sql.y:3003 { yyLOCAL = &AddColumns{Columns: []*ColumnDefinition{yyDollar[3].columnDefinitionUnion()}, First: yyDollar[4].booleanUnion(), After: yyDollar[5].colNameUnion()} } @@ -13845,7 +13844,7 @@ yydefault: case 540: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3011 +//line sql.y:3007 { yyLOCAL = &AlterColumn{Column: yyDollar[3].colNameUnion(), DropDefault: true} } @@ -13853,7 +13852,7 @@ yydefault: case 541: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3015 +//line sql.y:3011 { yyLOCAL = &AlterColumn{Column: yyDollar[3].colNameUnion(), DropDefault: false, DefaultVal: yyDollar[6].exprUnion(), DefaultLiteral: true} } @@ -13861,7 +13860,7 @@ yydefault: case 542: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3019 +//line sql.y:3015 { yyLOCAL = &AlterColumn{Column: yyDollar[3].colNameUnion(), DropDefault: false, DefaultVal: yyDollar[7].exprUnion()} } @@ -13869,25 +13868,23 @@ yydefault: case 543: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3023 +//line sql.y:3019 { - val := false - yyLOCAL = &AlterColumn{Column: yyDollar[3].colNameUnion(), Invisible: &val} + yyLOCAL = &AlterColumn{Column: yyDollar[3].colNameUnion(), Invisible: ptr.Of(false)} } yyVAL.union = yyLOCAL case 544: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3028 +//line sql.y:3023 { - val := true - yyLOCAL = &AlterColumn{Column: yyDollar[3].colNameUnion(), Invisible: &val} + yyLOCAL = &AlterColumn{Column: yyDollar[3].colNameUnion(), Invisible: ptr.Of(true)} } yyVAL.union = yyLOCAL case 545: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3033 +//line sql.y:3027 { yyLOCAL = &AlterCheck{Name: yyDollar[3].identifierCI, Enforced: yyDollar[4].booleanUnion()} } @@ -13895,7 +13892,7 @@ yydefault: case 546: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3037 +//line sql.y:3031 { yyLOCAL = &AlterIndex{Name: yyDollar[3].identifierCI, Invisible: false} } @@ -13903,7 +13900,7 @@ yydefault: case 547: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3041 +//line sql.y:3035 { yyLOCAL = &AlterIndex{Name: yyDollar[3].identifierCI, Invisible: true} } @@ -13911,7 +13908,7 @@ yydefault: case 548: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3045 +//line sql.y:3039 { yyLOCAL = &ChangeColumn{OldColumn: yyDollar[3].colNameUnion(), NewColDefinition: yyDollar[4].columnDefinitionUnion(), First: yyDollar[5].booleanUnion(), After: yyDollar[6].colNameUnion()} } @@ -13919,7 +13916,7 @@ yydefault: case 549: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3049 +//line sql.y:3043 { yyLOCAL = &ModifyColumn{NewColDefinition: yyDollar[3].columnDefinitionUnion(), First: yyDollar[4].booleanUnion(), After: yyDollar[5].colNameUnion()} } @@ -13927,7 +13924,7 @@ yydefault: case 550: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3053 +//line sql.y:3047 { yyLOCAL = &RenameColumn{OldName: yyDollar[3].colNameUnion(), NewName: yyDollar[5].colNameUnion()} } @@ -13935,7 +13932,7 @@ yydefault: case 551: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3057 +//line sql.y:3051 { yyLOCAL = &AlterCharset{CharacterSet: yyDollar[4].str, Collate: yyDollar[5].str} } @@ -13943,7 +13940,7 @@ yydefault: case 552: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3061 +//line sql.y:3055 { yyLOCAL = &KeyState{Enable: false} } @@ -13951,7 +13948,7 @@ yydefault: case 553: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3065 +//line sql.y:3059 { yyLOCAL = &KeyState{Enable: true} } @@ -13959,7 +13956,7 @@ yydefault: case 554: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3069 +//line sql.y:3063 { yyLOCAL = &TablespaceOperation{Import: false} } @@ -13967,7 +13964,7 @@ yydefault: case 555: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3073 +//line sql.y:3067 { yyLOCAL = &TablespaceOperation{Import: true} } @@ -13975,7 +13972,7 @@ yydefault: case 556: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3077 +//line sql.y:3071 { yyLOCAL = &DropColumn{Name: yyDollar[3].colNameUnion()} } @@ -13983,7 +13980,7 @@ yydefault: case 557: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3081 +//line sql.y:3075 { yyLOCAL = &DropKey{Type: NormalKeyType, Name: yyDollar[3].identifierCI} } @@ -13991,7 +13988,7 @@ yydefault: case 558: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3085 +//line sql.y:3079 { yyLOCAL = &DropKey{Type: PrimaryKeyType} } @@ -13999,7 +13996,7 @@ yydefault: case 559: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3089 +//line sql.y:3083 { yyLOCAL = &DropKey{Type: ForeignKeyType, Name: yyDollar[4].identifierCI} } @@ -14007,7 +14004,7 @@ yydefault: case 560: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3093 +//line sql.y:3087 { yyLOCAL = &DropKey{Type: CheckKeyType, Name: yyDollar[3].identifierCI} } @@ -14015,7 +14012,7 @@ yydefault: case 561: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3097 +//line sql.y:3091 { yyLOCAL = &DropKey{Type: CheckKeyType, Name: yyDollar[3].identifierCI} } @@ -14023,7 +14020,7 @@ yydefault: case 562: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3101 +//line sql.y:3095 { yyLOCAL = &Force{} } @@ -14031,7 +14028,7 @@ yydefault: case 563: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3105 +//line sql.y:3099 { yyLOCAL = &RenameTableName{Table: yyDollar[3].tableName} } @@ -14039,7 +14036,7 @@ yydefault: case 564: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3109 +//line sql.y:3103 { yyLOCAL = &RenameIndex{OldName: yyDollar[3].identifierCI, NewName: yyDollar[5].identifierCI} } @@ -14047,14 +14044,14 @@ yydefault: case 565: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:3115 +//line sql.y:3109 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } yyVAL.union = yyLOCAL case 566: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3119 +//line sql.y:3113 { yySLICE := (*[]AlterOption)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].alterOptionUnion()) @@ -14062,7 +14059,7 @@ yydefault: case 567: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3125 +//line sql.y:3119 { yyLOCAL = AlgorithmValue(string(yyDollar[3].str)) } @@ -14070,7 +14067,7 @@ yydefault: case 568: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3129 +//line sql.y:3123 { yyLOCAL = AlgorithmValue(string(yyDollar[3].str)) } @@ -14078,7 +14075,7 @@ yydefault: case 569: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3133 +//line sql.y:3127 { yyLOCAL = AlgorithmValue(string(yyDollar[3].str)) } @@ -14086,7 +14083,7 @@ yydefault: case 570: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3137 +//line sql.y:3131 { yyLOCAL = AlgorithmValue(string(yyDollar[3].str)) } @@ -14094,7 +14091,7 @@ yydefault: case 571: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3141 +//line sql.y:3135 { yyLOCAL = &LockOption{Type: DefaultType} } @@ -14102,7 +14099,7 @@ yydefault: case 572: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3145 +//line sql.y:3139 { yyLOCAL = &LockOption{Type: NoneType} } @@ -14110,7 +14107,7 @@ yydefault: case 573: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3149 +//line sql.y:3143 { yyLOCAL = &LockOption{Type: SharedType} } @@ -14118,7 +14115,7 @@ yydefault: case 574: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3153 +//line sql.y:3147 { yyLOCAL = &LockOption{Type: ExclusiveType} } @@ -14126,7 +14123,7 @@ yydefault: case 575: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3157 +//line sql.y:3151 { yyLOCAL = &Validation{With: true} } @@ -14134,7 +14131,7 @@ yydefault: case 576: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL AlterOption -//line sql.y:3161 +//line sql.y:3155 { yyLOCAL = &Validation{With: false} } @@ -14142,7 +14139,7 @@ yydefault: case 577: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:3167 +//line sql.y:3161 { yyDollar[1].alterTableUnion().FullyParsed = true yyDollar[1].alterTableUnion().AlterOptions = yyDollar[2].alterOptionsUnion() @@ -14153,7 +14150,7 @@ yydefault: case 578: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:3174 +//line sql.y:3168 { yyDollar[1].alterTableUnion().FullyParsed = true yyDollar[1].alterTableUnion().AlterOptions = yyDollar[2].alterOptionsUnion() @@ -14164,7 +14161,7 @@ yydefault: case 579: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:3181 +//line sql.y:3175 { yyDollar[1].alterTableUnion().FullyParsed = true yyDollar[1].alterTableUnion().AlterOptions = yyDollar[2].alterOptionsUnion() @@ -14175,7 +14172,7 @@ yydefault: case 580: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:3188 +//line sql.y:3182 { yyDollar[1].alterTableUnion().FullyParsed = true yyDollar[1].alterTableUnion().PartitionSpec = yyDollar[2].partSpecUnion() @@ -14185,7 +14182,7 @@ yydefault: case 581: yyDollar = yyS[yypt-11 : yypt+1] var yyLOCAL Statement -//line sql.y:3194 +//line sql.y:3188 { yyLOCAL = &AlterView{ViewName: yyDollar[7].tableName, Comments: Comments(yyDollar[2].strs).Parsed(), Algorithm: yyDollar[3].str, Definer: yyDollar[4].definerUnion(), Security: yyDollar[5].str, Columns: yyDollar[8].columnsUnion(), Select: yyDollar[10].selStmtUnion(), CheckOption: yyDollar[11].str} } @@ -14193,7 +14190,7 @@ yydefault: case 582: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:3204 +//line sql.y:3198 { yyDollar[1].alterDatabaseUnion().FullyParsed = true yyDollar[1].alterDatabaseUnion().DBName = yyDollar[2].identifierCS @@ -14204,7 +14201,7 @@ yydefault: case 583: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3211 +//line sql.y:3205 { yyDollar[1].alterDatabaseUnion().FullyParsed = true yyDollar[1].alterDatabaseUnion().DBName = yyDollar[2].identifierCS @@ -14215,7 +14212,7 @@ yydefault: case 584: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Statement -//line sql.y:3218 +//line sql.y:3212 { yyLOCAL = &AlterVschema{ Action: CreateVindexDDLAction, @@ -14231,7 +14228,7 @@ yydefault: case 585: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3230 +//line sql.y:3224 { yyLOCAL = &AlterVschema{ Action: DropVindexDDLAction, @@ -14245,7 +14242,7 @@ yydefault: case 586: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3240 +//line sql.y:3234 { yyLOCAL = &AlterVschema{Action: AddVschemaTableDDLAction, Table: yyDollar[6].tableName} } @@ -14253,7 +14250,7 @@ yydefault: case 587: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3244 +//line sql.y:3238 { yyLOCAL = &AlterVschema{Action: DropVschemaTableDDLAction, Table: yyDollar[6].tableName} } @@ -14261,7 +14258,7 @@ yydefault: case 588: yyDollar = yyS[yypt-13 : yypt+1] var yyLOCAL Statement -//line sql.y:3248 +//line sql.y:3242 { yyLOCAL = &AlterVschema{ Action: AddColVindexDDLAction, @@ -14278,7 +14275,7 @@ yydefault: case 589: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Statement -//line sql.y:3261 +//line sql.y:3255 { yyLOCAL = &AlterVschema{ Action: DropColVindexDDLAction, @@ -14292,7 +14289,7 @@ yydefault: case 590: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3271 +//line sql.y:3265 { yyLOCAL = &AlterVschema{Action: AddSequenceDDLAction, Table: yyDollar[6].tableName} } @@ -14300,7 +14297,7 @@ yydefault: case 591: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3275 +//line sql.y:3269 { yyLOCAL = &AlterVschema{Action: DropSequenceDDLAction, Table: yyDollar[6].tableName} } @@ -14308,7 +14305,7 @@ yydefault: case 592: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Statement -//line sql.y:3279 +//line sql.y:3273 { yyLOCAL = &AlterVschema{ Action: AddAutoIncDDLAction, @@ -14323,7 +14320,7 @@ yydefault: case 593: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3290 +//line sql.y:3284 { yyLOCAL = &AlterVschema{ Action: DropAutoIncDDLAction, @@ -14334,7 +14331,7 @@ yydefault: case 594: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3297 +//line sql.y:3291 { yyLOCAL = &AlterMigration{ Type: RetryMigrationType, @@ -14345,7 +14342,7 @@ yydefault: case 595: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3304 +//line sql.y:3298 { yyLOCAL = &AlterMigration{ Type: CleanupMigrationType, @@ -14356,7 +14353,7 @@ yydefault: case 596: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3311 +//line sql.y:3305 { yyLOCAL = &AlterMigration{ Type: LaunchMigrationType, @@ -14367,7 +14364,7 @@ yydefault: case 597: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3318 +//line sql.y:3312 { yyLOCAL = &AlterMigration{ Type: LaunchMigrationType, @@ -14379,7 +14376,7 @@ yydefault: case 598: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3326 +//line sql.y:3320 { yyLOCAL = &AlterMigration{ Type: LaunchAllMigrationType, @@ -14389,7 +14386,7 @@ yydefault: case 599: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3332 +//line sql.y:3326 { yyLOCAL = &AlterMigration{ Type: CompleteMigrationType, @@ -14400,7 +14397,7 @@ yydefault: case 600: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3339 +//line sql.y:3333 { yyLOCAL = &AlterMigration{ Type: CompleteAllMigrationType, @@ -14410,7 +14407,7 @@ yydefault: case 601: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3345 +//line sql.y:3339 { yyLOCAL = &AlterMigration{ Type: CancelMigrationType, @@ -14421,7 +14418,7 @@ yydefault: case 602: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3352 +//line sql.y:3346 { yyLOCAL = &AlterMigration{ Type: CancelAllMigrationType, @@ -14431,7 +14428,7 @@ yydefault: case 603: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3358 +//line sql.y:3352 { yyLOCAL = &AlterMigration{ Type: ThrottleMigrationType, @@ -14444,7 +14441,7 @@ yydefault: case 604: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3367 +//line sql.y:3361 { yyLOCAL = &AlterMigration{ Type: ThrottleAllMigrationType, @@ -14456,7 +14453,7 @@ yydefault: case 605: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3375 +//line sql.y:3369 { yyLOCAL = &AlterMigration{ Type: UnthrottleMigrationType, @@ -14467,7 +14464,7 @@ yydefault: case 606: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3382 +//line sql.y:3376 { yyLOCAL = &AlterMigration{ Type: UnthrottleAllMigrationType, @@ -14477,7 +14474,7 @@ yydefault: case 607: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3388 +//line sql.y:3382 { yyLOCAL = &AlterMigration{ Type: ForceCutOverMigrationType, @@ -14488,7 +14485,7 @@ yydefault: case 608: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3395 +//line sql.y:3389 { yyLOCAL = &AlterMigration{ Type: ForceCutOverAllMigrationType, @@ -14498,7 +14495,7 @@ yydefault: case 609: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3402 +//line sql.y:3396 { yyLOCAL = nil } @@ -14506,7 +14503,7 @@ yydefault: case 610: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3406 +//line sql.y:3400 { yyDollar[3].partitionOptionUnion().Partitions = yyDollar[4].integerUnion() yyDollar[3].partitionOptionUnion().SubPartition = yyDollar[5].subPartitionUnion() @@ -14517,7 +14514,7 @@ yydefault: case 611: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3415 +//line sql.y:3409 { yyLOCAL = &PartitionOption{ IsLinear: yyDollar[1].booleanUnion(), @@ -14529,7 +14526,7 @@ yydefault: case 612: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3423 +//line sql.y:3417 { yyLOCAL = &PartitionOption{ IsLinear: yyDollar[1].booleanUnion(), @@ -14542,7 +14539,7 @@ yydefault: case 613: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3432 +//line sql.y:3426 { yyLOCAL = &PartitionOption{ Type: yyDollar[1].partitionByTypeUnion(), @@ -14553,7 +14550,7 @@ yydefault: case 614: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3439 +//line sql.y:3433 { yyLOCAL = &PartitionOption{ Type: yyDollar[1].partitionByTypeUnion(), @@ -14564,7 +14561,7 @@ yydefault: case 615: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *SubPartition -//line sql.y:3447 +//line sql.y:3441 { yyLOCAL = nil } @@ -14572,7 +14569,7 @@ yydefault: case 616: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *SubPartition -//line sql.y:3451 +//line sql.y:3445 { yyLOCAL = &SubPartition{ IsLinear: yyDollar[3].booleanUnion(), @@ -14585,7 +14582,7 @@ yydefault: case 617: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL *SubPartition -//line sql.y:3460 +//line sql.y:3454 { yyLOCAL = &SubPartition{ IsLinear: yyDollar[3].booleanUnion(), @@ -14599,7 +14596,7 @@ yydefault: case 618: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*PartitionDefinition -//line sql.y:3471 +//line sql.y:3465 { yyLOCAL = nil } @@ -14607,7 +14604,7 @@ yydefault: case 619: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []*PartitionDefinition -//line sql.y:3475 +//line sql.y:3469 { yyLOCAL = yyDollar[2].partDefsUnion() } @@ -14615,7 +14612,7 @@ yydefault: case 620: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3480 +//line sql.y:3474 { yyLOCAL = false } @@ -14623,7 +14620,7 @@ yydefault: case 621: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3484 +//line sql.y:3478 { yyLOCAL = true } @@ -14631,7 +14628,7 @@ yydefault: case 622: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:3489 +//line sql.y:3483 { yyLOCAL = 0 } @@ -14639,7 +14636,7 @@ yydefault: case 623: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:3493 +//line sql.y:3487 { yyLOCAL = convertStringToInt(yyDollar[3].str) } @@ -14647,7 +14644,7 @@ yydefault: case 624: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL TableExpr -//line sql.y:3499 +//line sql.y:3493 { yyLOCAL = &JSONTableExpr{Expr: yyDollar[3].exprUnion(), Filter: yyDollar[5].exprUnion(), Columns: yyDollar[6].jtColumnListUnion(), Alias: yyDollar[8].identifierCS} } @@ -14655,7 +14652,7 @@ yydefault: case 625: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL []*JtColumnDefinition -//line sql.y:3505 +//line sql.y:3499 { yyLOCAL = yyDollar[3].jtColumnListUnion() } @@ -14663,14 +14660,14 @@ yydefault: case 626: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*JtColumnDefinition -//line sql.y:3511 +//line sql.y:3505 { yyLOCAL = []*JtColumnDefinition{yyDollar[1].jtColumnDefinitionUnion()} } yyVAL.union = yyLOCAL case 627: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3515 +//line sql.y:3509 { yySLICE := (*[]*JtColumnDefinition)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].jtColumnDefinitionUnion()) @@ -14678,7 +14675,7 @@ yydefault: case 628: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3521 +//line sql.y:3515 { yyLOCAL = &JtColumnDefinition{JtOrdinal: &JtOrdinalColDef{Name: yyDollar[1].identifierCI}} } @@ -14686,7 +14683,7 @@ yydefault: case 629: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3525 +//line sql.y:3519 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion()} @@ -14696,7 +14693,7 @@ yydefault: case 630: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3531 +//line sql.y:3525 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion()} @@ -14706,7 +14703,7 @@ yydefault: case 631: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3537 +//line sql.y:3531 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion(), ErrorOnResponse: yyDollar[7].jtOnResponseUnion()} @@ -14716,7 +14713,7 @@ yydefault: case 632: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3543 +//line sql.y:3537 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion(), ErrorOnResponse: yyDollar[8].jtOnResponseUnion()} @@ -14726,7 +14723,7 @@ yydefault: case 633: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3549 +//line sql.y:3543 { jtNestedPath := &JtNestedPathColDef{Path: yyDollar[3].exprUnion(), Columns: yyDollar[4].jtColumnListUnion()} yyLOCAL = &JtColumnDefinition{JtNestedPath: jtNestedPath} @@ -14735,7 +14732,7 @@ yydefault: case 634: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3555 +//line sql.y:3549 { yyLOCAL = false } @@ -14743,7 +14740,7 @@ yydefault: case 635: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3559 +//line sql.y:3553 { yyLOCAL = true } @@ -14751,7 +14748,7 @@ yydefault: case 636: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3563 +//line sql.y:3557 { yyLOCAL = false } @@ -14759,7 +14756,7 @@ yydefault: case 637: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3567 +//line sql.y:3561 { yyLOCAL = true } @@ -14767,7 +14764,7 @@ yydefault: case 638: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3573 +//line sql.y:3567 { yyLOCAL = yyDollar[1].jtOnResponseUnion() } @@ -14775,7 +14772,7 @@ yydefault: case 639: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3579 +//line sql.y:3573 { yyLOCAL = yyDollar[1].jtOnResponseUnion() } @@ -14783,7 +14780,7 @@ yydefault: case 640: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3585 +//line sql.y:3579 { yyLOCAL = &JtOnResponse{ResponseType: ErrorJSONType} } @@ -14791,7 +14788,7 @@ yydefault: case 641: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3589 +//line sql.y:3583 { yyLOCAL = &JtOnResponse{ResponseType: NullJSONType} } @@ -14799,7 +14796,7 @@ yydefault: case 642: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3593 +//line sql.y:3587 { yyLOCAL = &JtOnResponse{ResponseType: DefaultJSONType, Expr: yyDollar[2].exprUnion()} } @@ -14807,7 +14804,7 @@ yydefault: case 643: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL PartitionByType -//line sql.y:3599 +//line sql.y:3593 { yyLOCAL = RangeType } @@ -14815,7 +14812,7 @@ yydefault: case 644: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL PartitionByType -//line sql.y:3603 +//line sql.y:3597 { yyLOCAL = ListType } @@ -14823,7 +14820,7 @@ yydefault: case 645: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:3608 +//line sql.y:3602 { yyLOCAL = -1 } @@ -14831,7 +14828,7 @@ yydefault: case 646: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL int -//line sql.y:3612 +//line sql.y:3606 { yyLOCAL = convertStringToInt(yyDollar[2].str) } @@ -14839,7 +14836,7 @@ yydefault: case 647: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:3617 +//line sql.y:3611 { yyLOCAL = -1 } @@ -14847,7 +14844,7 @@ yydefault: case 648: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL int -//line sql.y:3621 +//line sql.y:3615 { yyLOCAL = convertStringToInt(yyDollar[2].str) } @@ -14855,7 +14852,7 @@ yydefault: case 649: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3627 +//line sql.y:3621 { yyLOCAL = &PartitionSpec{Action: AddAction, Definitions: []*PartitionDefinition{yyDollar[4].partDefUnion()}} } @@ -14863,7 +14860,7 @@ yydefault: case 650: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3631 +//line sql.y:3625 { yyLOCAL = &PartitionSpec{Action: DropAction, Names: yyDollar[3].partitionsUnion()} } @@ -14871,7 +14868,7 @@ yydefault: case 651: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3635 +//line sql.y:3629 { yyLOCAL = &PartitionSpec{Action: ReorganizeAction, Names: yyDollar[3].partitionsUnion(), Definitions: yyDollar[6].partDefsUnion()} } @@ -14879,7 +14876,7 @@ yydefault: case 652: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3639 +//line sql.y:3633 { yyLOCAL = &PartitionSpec{Action: DiscardAction, Names: yyDollar[3].partitionsUnion()} } @@ -14887,7 +14884,7 @@ yydefault: case 653: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3643 +//line sql.y:3637 { yyLOCAL = &PartitionSpec{Action: DiscardAction, IsAll: true} } @@ -14895,7 +14892,7 @@ yydefault: case 654: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3647 +//line sql.y:3641 { yyLOCAL = &PartitionSpec{Action: ImportAction, Names: yyDollar[3].partitionsUnion()} } @@ -14903,7 +14900,7 @@ yydefault: case 655: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3651 +//line sql.y:3645 { yyLOCAL = &PartitionSpec{Action: ImportAction, IsAll: true} } @@ -14911,7 +14908,7 @@ yydefault: case 656: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3655 +//line sql.y:3649 { yyLOCAL = &PartitionSpec{Action: TruncateAction, Names: yyDollar[3].partitionsUnion()} } @@ -14919,7 +14916,7 @@ yydefault: case 657: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3659 +//line sql.y:3653 { yyLOCAL = &PartitionSpec{Action: TruncateAction, IsAll: true} } @@ -14927,7 +14924,7 @@ yydefault: case 658: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3663 +//line sql.y:3657 { yyLOCAL = &PartitionSpec{Action: CoalesceAction, Number: NewIntLiteral(yyDollar[3].str)} } @@ -14935,7 +14932,7 @@ yydefault: case 659: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3667 +//line sql.y:3661 { yyLOCAL = &PartitionSpec{Action: ExchangeAction, Names: Partitions{yyDollar[3].identifierCI}, TableName: yyDollar[6].tableName, WithoutValidation: yyDollar[7].booleanUnion()} } @@ -14943,7 +14940,7 @@ yydefault: case 660: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3671 +//line sql.y:3665 { yyLOCAL = &PartitionSpec{Action: AnalyzeAction, Names: yyDollar[3].partitionsUnion()} } @@ -14951,7 +14948,7 @@ yydefault: case 661: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3675 +//line sql.y:3669 { yyLOCAL = &PartitionSpec{Action: AnalyzeAction, IsAll: true} } @@ -14959,7 +14956,7 @@ yydefault: case 662: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3679 +//line sql.y:3673 { yyLOCAL = &PartitionSpec{Action: CheckAction, Names: yyDollar[3].partitionsUnion()} } @@ -14967,7 +14964,7 @@ yydefault: case 663: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3683 +//line sql.y:3677 { yyLOCAL = &PartitionSpec{Action: CheckAction, IsAll: true} } @@ -14975,7 +14972,7 @@ yydefault: case 664: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3687 +//line sql.y:3681 { yyLOCAL = &PartitionSpec{Action: OptimizeAction, Names: yyDollar[3].partitionsUnion()} } @@ -14983,7 +14980,7 @@ yydefault: case 665: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3691 +//line sql.y:3685 { yyLOCAL = &PartitionSpec{Action: OptimizeAction, IsAll: true} } @@ -14991,7 +14988,7 @@ yydefault: case 666: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3695 +//line sql.y:3689 { yyLOCAL = &PartitionSpec{Action: RebuildAction, Names: yyDollar[3].partitionsUnion()} } @@ -14999,7 +14996,7 @@ yydefault: case 667: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3699 +//line sql.y:3693 { yyLOCAL = &PartitionSpec{Action: RebuildAction, IsAll: true} } @@ -15007,7 +15004,7 @@ yydefault: case 668: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3703 +//line sql.y:3697 { yyLOCAL = &PartitionSpec{Action: RepairAction, Names: yyDollar[3].partitionsUnion()} } @@ -15015,7 +15012,7 @@ yydefault: case 669: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3707 +//line sql.y:3701 { yyLOCAL = &PartitionSpec{Action: RepairAction, IsAll: true} } @@ -15023,7 +15020,7 @@ yydefault: case 670: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3711 +//line sql.y:3705 { yyLOCAL = &PartitionSpec{Action: UpgradeAction} } @@ -15031,7 +15028,7 @@ yydefault: case 671: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3716 +//line sql.y:3710 { yyLOCAL = false } @@ -15039,7 +15036,7 @@ yydefault: case 672: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:3720 +//line sql.y:3714 { yyLOCAL = false } @@ -15047,7 +15044,7 @@ yydefault: case 673: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:3724 +//line sql.y:3718 { yyLOCAL = true } @@ -15055,28 +15052,28 @@ yydefault: case 674: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*PartitionDefinition -//line sql.y:3730 +//line sql.y:3724 { yyLOCAL = []*PartitionDefinition{yyDollar[1].partDefUnion()} } yyVAL.union = yyLOCAL case 675: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3734 +//line sql.y:3728 { yySLICE := (*[]*PartitionDefinition)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].partDefUnion()) } case 676: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3740 +//line sql.y:3734 { yyVAL.partDefUnion().Options = yyDollar[2].partitionDefinitionOptionsUnion() } case 677: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3745 +//line sql.y:3739 { yyLOCAL = &PartitionDefinitionOptions{} } @@ -15084,7 +15081,7 @@ yydefault: case 678: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3749 +//line sql.y:3743 { yyDollar[1].partitionDefinitionOptionsUnion().ValueRange = yyDollar[2].partitionValueRangeUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() @@ -15093,7 +15090,7 @@ yydefault: case 679: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3754 +//line sql.y:3748 { yyDollar[1].partitionDefinitionOptionsUnion().Comment = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() @@ -15102,7 +15099,7 @@ yydefault: case 680: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3759 +//line sql.y:3753 { yyDollar[1].partitionDefinitionOptionsUnion().Engine = yyDollar[2].partitionEngineUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() @@ -15111,7 +15108,7 @@ yydefault: case 681: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3764 +//line sql.y:3758 { yyDollar[1].partitionDefinitionOptionsUnion().DataDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() @@ -15120,7 +15117,7 @@ yydefault: case 682: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3769 +//line sql.y:3763 { yyDollar[1].partitionDefinitionOptionsUnion().IndexDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() @@ -15129,27 +15126,25 @@ yydefault: case 683: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3774 +//line sql.y:3768 { - val := yyDollar[2].integerUnion() - yyDollar[1].partitionDefinitionOptionsUnion().MaxRows = &val + yyDollar[1].partitionDefinitionOptionsUnion().MaxRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL case 684: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3780 +//line sql.y:3773 { - val := yyDollar[2].integerUnion() - yyDollar[1].partitionDefinitionOptionsUnion().MinRows = &val + yyDollar[1].partitionDefinitionOptionsUnion().MinRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL case 685: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3786 +//line sql.y:3778 { yyDollar[1].partitionDefinitionOptionsUnion().TableSpace = yyDollar[2].str yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() @@ -15158,7 +15153,7 @@ yydefault: case 686: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3791 +//line sql.y:3783 { yyDollar[1].partitionDefinitionOptionsUnion().SubPartitionDefinitions = yyDollar[2].subPartitionDefinitionsUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() @@ -15167,7 +15162,7 @@ yydefault: case 687: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SubPartitionDefinitions -//line sql.y:3797 +//line sql.y:3789 { yyLOCAL = yyDollar[2].subPartitionDefinitionsUnion() } @@ -15175,14 +15170,14 @@ yydefault: case 688: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SubPartitionDefinitions -//line sql.y:3803 +//line sql.y:3795 { yyLOCAL = SubPartitionDefinitions{yyDollar[1].subPartitionDefinitionUnion()} } yyVAL.union = yyLOCAL case 689: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3807 +//line sql.y:3799 { yySLICE := (*SubPartitionDefinitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].subPartitionDefinitionUnion()) @@ -15190,7 +15185,7 @@ yydefault: case 690: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SubPartitionDefinition -//line sql.y:3813 +//line sql.y:3805 { yyLOCAL = &SubPartitionDefinition{Name: yyDollar[2].identifierCI, Options: yyDollar[3].subPartitionDefinitionOptionsUnion()} } @@ -15198,7 +15193,7 @@ yydefault: case 691: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3818 +//line sql.y:3810 { yyLOCAL = &SubPartitionDefinitionOptions{} } @@ -15206,7 +15201,7 @@ yydefault: case 692: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3822 +//line sql.y:3814 { yyDollar[1].subPartitionDefinitionOptionsUnion().Comment = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() @@ -15215,7 +15210,7 @@ yydefault: case 693: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3827 +//line sql.y:3819 { yyDollar[1].subPartitionDefinitionOptionsUnion().Engine = yyDollar[2].partitionEngineUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() @@ -15224,7 +15219,7 @@ yydefault: case 694: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3832 +//line sql.y:3824 { yyDollar[1].subPartitionDefinitionOptionsUnion().DataDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() @@ -15233,7 +15228,7 @@ yydefault: case 695: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3837 +//line sql.y:3829 { yyDollar[1].subPartitionDefinitionOptionsUnion().IndexDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() @@ -15242,27 +15237,25 @@ yydefault: case 696: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3842 +//line sql.y:3834 { - val := yyDollar[2].integerUnion() - yyDollar[1].subPartitionDefinitionOptionsUnion().MaxRows = &val + yyDollar[1].subPartitionDefinitionOptionsUnion().MaxRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL case 697: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3848 +//line sql.y:3839 { - val := yyDollar[2].integerUnion() - yyDollar[1].subPartitionDefinitionOptionsUnion().MinRows = &val + yyDollar[1].subPartitionDefinitionOptionsUnion().MinRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL case 698: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3854 +//line sql.y:3844 { yyDollar[1].subPartitionDefinitionOptionsUnion().TableSpace = yyDollar[2].str yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() @@ -15271,7 +15264,7 @@ yydefault: case 699: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionValueRange -//line sql.y:3861 +//line sql.y:3851 { yyLOCAL = &PartitionValueRange{ Type: LessThanType, @@ -15282,7 +15275,7 @@ yydefault: case 700: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionValueRange -//line sql.y:3868 +//line sql.y:3858 { yyLOCAL = &PartitionValueRange{ Type: LessThanType, @@ -15293,7 +15286,7 @@ yydefault: case 701: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionValueRange -//line sql.y:3875 +//line sql.y:3865 { yyLOCAL = &PartitionValueRange{ Type: InType, @@ -15304,7 +15297,7 @@ yydefault: case 702: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3883 +//line sql.y:3873 { yyLOCAL = false } @@ -15312,7 +15305,7 @@ yydefault: case 703: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3887 +//line sql.y:3877 { yyLOCAL = true } @@ -15320,7 +15313,7 @@ yydefault: case 704: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionEngine -//line sql.y:3893 +//line sql.y:3883 { yyLOCAL = &PartitionEngine{Storage: yyDollar[1].booleanUnion(), Name: yyDollar[4].identifierCS.String()} } @@ -15328,7 +15321,7 @@ yydefault: case 705: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Literal -//line sql.y:3899 +//line sql.y:3889 { yyLOCAL = NewStrLiteral(yyDollar[3].str) } @@ -15336,7 +15329,7 @@ yydefault: case 706: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Literal -//line sql.y:3905 +//line sql.y:3895 { yyLOCAL = NewStrLiteral(yyDollar[4].str) } @@ -15344,7 +15337,7 @@ yydefault: case 707: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Literal -//line sql.y:3911 +//line sql.y:3901 { yyLOCAL = NewStrLiteral(yyDollar[4].str) } @@ -15352,7 +15345,7 @@ yydefault: case 708: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:3917 +//line sql.y:3907 { yyLOCAL = convertStringToInt(yyDollar[3].str) } @@ -15360,41 +15353,41 @@ yydefault: case 709: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:3923 +//line sql.y:3913 { yyLOCAL = convertStringToInt(yyDollar[3].str) } yyVAL.union = yyLOCAL case 710: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3929 +//line sql.y:3919 { yyVAL.str = yyDollar[3].identifierCS.String() } case 711: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinition -//line sql.y:3935 +//line sql.y:3925 { yyLOCAL = &PartitionDefinition{Name: yyDollar[2].identifierCI} } yyVAL.union = yyLOCAL case 712: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3941 +//line sql.y:3931 { yyVAL.str = "" } case 713: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3945 +//line sql.y:3935 { yyVAL.str = "" } case 714: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:3951 +//line sql.y:3941 { yyLOCAL = &RenameTable{TablePairs: yyDollar[3].renameTablePairsUnion()} } @@ -15402,14 +15395,14 @@ yydefault: case 715: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []*RenameTablePair -//line sql.y:3957 +//line sql.y:3947 { yyLOCAL = []*RenameTablePair{{FromTable: yyDollar[1].tableName, ToTable: yyDollar[3].tableName}} } yyVAL.union = yyLOCAL case 716: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3961 +//line sql.y:3951 { yySLICE := (*[]*RenameTablePair)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, &RenameTablePair{FromTable: yyDollar[3].tableName, ToTable: yyDollar[5].tableName}) @@ -15417,7 +15410,7 @@ yydefault: case 717: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3967 +//line sql.y:3957 { yyLOCAL = &DropTable{FromTables: yyDollar[6].tableNamesUnion(), IfExists: yyDollar[5].booleanUnion(), Comments: Comments(yyDollar[2].strs).Parsed(), Temp: yyDollar[3].booleanUnion()} } @@ -15425,7 +15418,7 @@ yydefault: case 718: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3971 +//line sql.y:3961 { // Change this to an alter statement if yyDollar[4].identifierCI.Lowered() == "primary" { @@ -15438,7 +15431,7 @@ yydefault: case 719: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3980 +//line sql.y:3970 { yyLOCAL = &DropView{FromTables: yyDollar[5].tableNamesUnion(), Comments: Comments(yyDollar[2].strs).Parsed(), IfExists: yyDollar[4].booleanUnion()} } @@ -15446,7 +15439,7 @@ yydefault: case 720: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3984 +//line sql.y:3974 { yyLOCAL = &DropDatabase{Comments: Comments(yyDollar[2].strs).Parsed(), DBName: yyDollar[5].identifierCS, IfExists: yyDollar[4].booleanUnion()} } @@ -15454,7 +15447,7 @@ yydefault: case 721: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:3990 +//line sql.y:3980 { yyLOCAL = &TruncateTable{Table: yyDollar[3].tableName} } @@ -15462,7 +15455,7 @@ yydefault: case 722: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:3994 +//line sql.y:3984 { yyLOCAL = &TruncateTable{Table: yyDollar[2].tableName} } @@ -15470,7 +15463,7 @@ yydefault: case 723: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4000 +//line sql.y:3990 { yyLOCAL = &Analyze{IsLocal: yyDollar[2].booleanUnion(), Table: yyDollar[4].tableName} } @@ -15478,7 +15471,7 @@ yydefault: case 724: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4006 +//line sql.y:3996 { yyLOCAL = &PurgeBinaryLogs{To: string(yyDollar[5].str)} } @@ -15486,7 +15479,7 @@ yydefault: case 725: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4010 +//line sql.y:4000 { yyLOCAL = &PurgeBinaryLogs{Before: string(yyDollar[5].str)} } @@ -15494,7 +15487,7 @@ yydefault: case 726: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4016 +//line sql.y:4006 { yyLOCAL = &Show{&ShowBasic{Command: Charset, Filter: yyDollar[3].showFilterUnion()}} } @@ -15502,7 +15495,7 @@ yydefault: case 727: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4020 +//line sql.y:4010 { yyLOCAL = &Show{&ShowBasic{Command: Collation, Filter: yyDollar[3].showFilterUnion()}} } @@ -15510,7 +15503,7 @@ yydefault: case 728: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:4024 +//line sql.y:4014 { yyLOCAL = &Show{&ShowBasic{Full: yyDollar[2].booleanUnion(), Command: Column, Tbl: yyDollar[5].tableName, DbName: yyDollar[6].identifierCS, Filter: yyDollar[7].showFilterUnion()}} } @@ -15518,7 +15511,7 @@ yydefault: case 729: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4028 +//line sql.y:4018 { yyLOCAL = &Show{&ShowBasic{Command: Database, Filter: yyDollar[3].showFilterUnion()}} } @@ -15526,7 +15519,7 @@ yydefault: case 730: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4032 +//line sql.y:4022 { yyLOCAL = &Show{&ShowBasic{Command: Database, Filter: yyDollar[3].showFilterUnion()}} } @@ -15534,7 +15527,7 @@ yydefault: case 731: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4036 +//line sql.y:4026 { yyLOCAL = &Show{&ShowBasic{Command: Keyspace, Filter: yyDollar[3].showFilterUnion()}} } @@ -15542,7 +15535,7 @@ yydefault: case 732: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4040 +//line sql.y:4030 { yyLOCAL = &Show{&ShowBasic{Command: Keyspace, Filter: yyDollar[3].showFilterUnion()}} } @@ -15550,7 +15543,7 @@ yydefault: case 733: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4044 +//line sql.y:4034 { yyLOCAL = &Show{&ShowBasic{Command: Function, Filter: yyDollar[4].showFilterUnion()}} } @@ -15558,7 +15551,7 @@ yydefault: case 734: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:4048 +//line sql.y:4038 { yyLOCAL = &Show{&ShowBasic{Command: Index, Tbl: yyDollar[5].tableName, DbName: yyDollar[6].identifierCS, Filter: yyDollar[7].showFilterUnion()}} } @@ -15566,7 +15559,7 @@ yydefault: case 735: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4052 +//line sql.y:4042 { yyLOCAL = &Show{&ShowBasic{Command: OpenTable, DbName: yyDollar[4].identifierCS, Filter: yyDollar[5].showFilterUnion()}} } @@ -15574,7 +15567,7 @@ yydefault: case 736: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4056 +//line sql.y:4046 { yyLOCAL = &Show{&ShowBasic{Command: Privilege}} } @@ -15582,7 +15575,7 @@ yydefault: case 737: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4060 +//line sql.y:4050 { yyLOCAL = &Show{&ShowBasic{Command: Procedure, Filter: yyDollar[4].showFilterUnion()}} } @@ -15590,7 +15583,7 @@ yydefault: case 738: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4064 +//line sql.y:4054 { yyLOCAL = &Show{&ShowBasic{Command: StatusSession, Filter: yyDollar[4].showFilterUnion()}} } @@ -15598,7 +15591,7 @@ yydefault: case 739: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4068 +//line sql.y:4058 { yyLOCAL = &Show{&ShowBasic{Command: StatusGlobal, Filter: yyDollar[4].showFilterUnion()}} } @@ -15606,7 +15599,7 @@ yydefault: case 740: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4072 +//line sql.y:4062 { yyLOCAL = &Show{&ShowBasic{Command: VariableSession, Filter: yyDollar[4].showFilterUnion()}} } @@ -15614,7 +15607,7 @@ yydefault: case 741: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4076 +//line sql.y:4066 { yyLOCAL = &Show{&ShowBasic{Command: VariableGlobal, Filter: yyDollar[4].showFilterUnion()}} } @@ -15622,7 +15615,7 @@ yydefault: case 742: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4080 +//line sql.y:4070 { yyLOCAL = &Show{&ShowBasic{Command: TableStatus, DbName: yyDollar[4].identifierCS, Filter: yyDollar[5].showFilterUnion()}} } @@ -15630,7 +15623,7 @@ yydefault: case 743: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4084 +//line sql.y:4074 { yyLOCAL = &Show{&ShowBasic{Command: Table, Full: yyDollar[2].booleanUnion(), DbName: yyDollar[4].identifierCS, Filter: yyDollar[5].showFilterUnion()}} } @@ -15638,7 +15631,7 @@ yydefault: case 744: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4088 +//line sql.y:4078 { yyLOCAL = &Show{&ShowBasic{Command: Trigger, DbName: yyDollar[3].identifierCS, Filter: yyDollar[4].showFilterUnion()}} } @@ -15646,7 +15639,7 @@ yydefault: case 745: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4092 +//line sql.y:4082 { yyLOCAL = &Show{&ShowCreate{Command: CreateDb, Op: yyDollar[4].tableName}} } @@ -15654,7 +15647,7 @@ yydefault: case 746: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4096 +//line sql.y:4086 { yyLOCAL = &Show{&ShowCreate{Command: CreateE, Op: yyDollar[4].tableName}} } @@ -15662,7 +15655,7 @@ yydefault: case 747: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4100 +//line sql.y:4090 { yyLOCAL = &Show{&ShowCreate{Command: CreateF, Op: yyDollar[4].tableName}} } @@ -15670,7 +15663,7 @@ yydefault: case 748: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4104 +//line sql.y:4094 { yyLOCAL = &Show{&ShowCreate{Command: CreateProc, Op: yyDollar[4].tableName}} } @@ -15678,7 +15671,7 @@ yydefault: case 749: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4108 +//line sql.y:4098 { yyLOCAL = &Show{&ShowCreate{Command: CreateTbl, Op: yyDollar[4].tableName}} } @@ -15686,7 +15679,7 @@ yydefault: case 750: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4112 +//line sql.y:4102 { yyLOCAL = &Show{&ShowCreate{Command: CreateTr, Op: yyDollar[4].tableName}} } @@ -15694,7 +15687,7 @@ yydefault: case 751: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4116 +//line sql.y:4106 { yyLOCAL = &Show{&ShowCreate{Command: CreateV, Op: yyDollar[4].tableName}} } @@ -15702,7 +15695,7 @@ yydefault: case 752: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4120 +//line sql.y:4110 { yyLOCAL = &Show{&ShowBasic{Command: Engines}} } @@ -15710,7 +15703,7 @@ yydefault: case 753: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4124 +//line sql.y:4114 { yyLOCAL = &Show{&ShowBasic{Command: Plugins}} } @@ -15718,7 +15711,7 @@ yydefault: case 754: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4128 +//line sql.y:4118 { yyLOCAL = &Show{&ShowBasic{Command: GtidExecGlobal, DbName: yyDollar[4].identifierCS}} } @@ -15726,7 +15719,7 @@ yydefault: case 755: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4132 +//line sql.y:4122 { yyLOCAL = &Show{&ShowBasic{Command: VGtidExecGlobal, DbName: yyDollar[4].identifierCS}} } @@ -15734,7 +15727,7 @@ yydefault: case 756: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4136 +//line sql.y:4126 { yyLOCAL = &Show{&ShowBasic{Command: VitessVariables, Filter: yyDollar[4].showFilterUnion()}} } @@ -15742,7 +15735,7 @@ yydefault: case 757: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4140 +//line sql.y:4130 { yyLOCAL = &Show{&ShowBasic{Command: VitessMigrations, Filter: yyDollar[4].showFilterUnion(), DbName: yyDollar[3].identifierCS}} } @@ -15750,7 +15743,7 @@ yydefault: case 758: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4144 +//line sql.y:4134 { yyLOCAL = &ShowMigrationLogs{UUID: string(yyDollar[3].str)} } @@ -15758,7 +15751,7 @@ yydefault: case 759: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4148 +//line sql.y:4138 { yyLOCAL = &ShowThrottledApps{} } @@ -15766,7 +15759,7 @@ yydefault: case 760: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4152 +//line sql.y:4142 { yyLOCAL = &Show{&ShowBasic{Command: VitessReplicationStatus, Filter: yyDollar[3].showFilterUnion()}} } @@ -15774,7 +15767,7 @@ yydefault: case 761: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4156 +//line sql.y:4146 { yyLOCAL = &ShowThrottlerStatus{} } @@ -15782,7 +15775,7 @@ yydefault: case 762: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4160 +//line sql.y:4150 { yyLOCAL = &Show{&ShowBasic{Command: VschemaTables}} } @@ -15790,7 +15783,7 @@ yydefault: case 763: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4164 +//line sql.y:4154 { yyLOCAL = &Show{&ShowBasic{Command: VschemaKeyspaces}} } @@ -15798,7 +15791,7 @@ yydefault: case 764: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4168 +//line sql.y:4158 { yyLOCAL = &Show{&ShowBasic{Command: VschemaVindexes}} } @@ -15806,7 +15799,7 @@ yydefault: case 765: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4172 +//line sql.y:4162 { yyLOCAL = &Show{&ShowBasic{Command: VschemaVindexes, Tbl: yyDollar[5].tableName}} } @@ -15814,7 +15807,7 @@ yydefault: case 766: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4176 +//line sql.y:4166 { yyLOCAL = &Show{&ShowBasic{Command: Warnings}} } @@ -15822,7 +15815,7 @@ yydefault: case 767: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4180 +//line sql.y:4170 { yyLOCAL = &Show{&ShowBasic{Command: VitessShards, Filter: yyDollar[3].showFilterUnion()}} } @@ -15830,7 +15823,7 @@ yydefault: case 768: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4184 +//line sql.y:4174 { yyLOCAL = &Show{&ShowBasic{Command: VitessTablets, Filter: yyDollar[3].showFilterUnion()}} } @@ -15838,7 +15831,7 @@ yydefault: case 769: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4188 +//line sql.y:4178 { yyLOCAL = &Show{&ShowBasic{Command: VitessTarget}} } @@ -15846,7 +15839,7 @@ yydefault: case 770: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4195 +//line sql.y:4185 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].identifierCI.String())}} } @@ -15854,7 +15847,7 @@ yydefault: case 771: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4199 +//line sql.y:4189 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str)}} } @@ -15862,7 +15855,7 @@ yydefault: case 772: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4203 +//line sql.y:4193 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + yyDollar[3].identifierCI.String()}} } @@ -15870,7 +15863,7 @@ yydefault: case 773: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4207 +//line sql.y:4197 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str)}} } @@ -15878,7 +15871,7 @@ yydefault: case 774: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4211 +//line sql.y:4201 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str)}} } @@ -15886,7 +15879,7 @@ yydefault: case 775: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4215 +//line sql.y:4205 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str) + " " + String(yyDollar[4].tableName)}} } @@ -15894,7 +15887,7 @@ yydefault: case 776: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4219 +//line sql.y:4209 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str) + " " + String(yyDollar[4].tableName)}} } @@ -15902,7 +15895,7 @@ yydefault: case 777: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4223 +//line sql.y:4213 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[3].str)}} } @@ -15910,27 +15903,27 @@ yydefault: case 778: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4227 +//line sql.y:4217 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str)}} } yyVAL.union = yyLOCAL case 779: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4233 +//line sql.y:4223 { yyVAL.str = "" } case 780: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4237 +//line sql.y:4227 { yyVAL.str = "extended " } case 781: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:4243 +//line sql.y:4233 { yyLOCAL = false } @@ -15938,45 +15931,45 @@ yydefault: case 782: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4247 +//line sql.y:4237 { yyLOCAL = true } yyVAL.union = yyLOCAL case 783: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4253 +//line sql.y:4243 { yyVAL.str = string(yyDollar[1].str) } case 784: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4257 +//line sql.y:4247 { yyVAL.str = string(yyDollar[1].str) } case 785: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4263 +//line sql.y:4253 { yyVAL.identifierCS = NewIdentifierCS("") } case 786: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4267 +//line sql.y:4257 { yyVAL.identifierCS = yyDollar[2].identifierCS } case 787: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4271 +//line sql.y:4261 { yyVAL.identifierCS = yyDollar[2].identifierCS } case 788: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4277 +//line sql.y:4267 { yyLOCAL = nil } @@ -15984,7 +15977,7 @@ yydefault: case 789: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4281 +//line sql.y:4271 { yyLOCAL = &ShowFilter{Like: string(yyDollar[2].str)} } @@ -15992,7 +15985,7 @@ yydefault: case 790: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4285 +//line sql.y:4275 { yyLOCAL = &ShowFilter{Filter: yyDollar[2].exprUnion()} } @@ -16000,7 +15993,7 @@ yydefault: case 791: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4291 +//line sql.y:4281 { yyLOCAL = nil } @@ -16008,45 +16001,45 @@ yydefault: case 792: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4295 +//line sql.y:4285 { yyLOCAL = &ShowFilter{Like: string(yyDollar[2].str)} } yyVAL.union = yyLOCAL case 793: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4301 +//line sql.y:4291 { yyVAL.empty = struct{}{} } case 794: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4305 +//line sql.y:4295 { yyVAL.empty = struct{}{} } case 795: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4309 +//line sql.y:4299 { yyVAL.empty = struct{}{} } case 796: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4315 +//line sql.y:4305 { yyVAL.str = string(yyDollar[1].str) } case 797: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4319 +//line sql.y:4309 { yyVAL.str = string(yyDollar[1].str) } case 798: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4325 +//line sql.y:4315 { yyLOCAL = &Use{DBName: yyDollar[2].identifierCS} } @@ -16054,7 +16047,7 @@ yydefault: case 799: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4329 +//line sql.y:4319 { yyLOCAL = &Use{DBName: IdentifierCS{v: ""}} } @@ -16062,39 +16055,39 @@ yydefault: case 800: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4333 +//line sql.y:4323 { yyLOCAL = &Use{DBName: NewIdentifierCS(yyDollar[2].identifierCS.String() + "@" + string(yyDollar[3].str))} } yyVAL.union = yyLOCAL case 801: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4340 +//line sql.y:4330 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } case 802: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4344 +//line sql.y:4334 { yyVAL.identifierCS = NewIdentifierCS("@" + string(yyDollar[1].str)) } case 803: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4348 +//line sql.y:4338 { yyVAL.identifierCS = NewIdentifierCS("@@" + string(yyDollar[1].str)) } case 804: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4352 +//line sql.y:4342 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } case 805: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4359 +//line sql.y:4349 { yyLOCAL = &Begin{} } @@ -16102,7 +16095,7 @@ yydefault: case 806: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4363 +//line sql.y:4353 { yyLOCAL = &Begin{TxAccessModes: yyDollar[3].txAccessModesUnion()} } @@ -16110,7 +16103,7 @@ yydefault: case 807: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []TxAccessMode -//line sql.y:4368 +//line sql.y:4358 { yyLOCAL = nil } @@ -16118,7 +16111,7 @@ yydefault: case 808: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []TxAccessMode -//line sql.y:4372 +//line sql.y:4362 { yyLOCAL = yyDollar[1].txAccessModesUnion() } @@ -16126,14 +16119,14 @@ yydefault: case 809: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []TxAccessMode -//line sql.y:4378 +//line sql.y:4368 { yyLOCAL = []TxAccessMode{yyDollar[1].txAccessModeUnion()} } yyVAL.union = yyLOCAL case 810: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4382 +//line sql.y:4372 { yySLICE := (*[]TxAccessMode)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].txAccessModeUnion()) @@ -16141,7 +16134,7 @@ yydefault: case 811: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TxAccessMode -//line sql.y:4388 +//line sql.y:4378 { yyLOCAL = WithConsistentSnapshot } @@ -16149,7 +16142,7 @@ yydefault: case 812: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL TxAccessMode -//line sql.y:4392 +//line sql.y:4382 { yyLOCAL = ReadWrite } @@ -16157,7 +16150,7 @@ yydefault: case 813: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL TxAccessMode -//line sql.y:4396 +//line sql.y:4386 { yyLOCAL = ReadOnly } @@ -16165,7 +16158,7 @@ yydefault: case 814: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4403 +//line sql.y:4393 { yyLOCAL = &Commit{} } @@ -16173,7 +16166,7 @@ yydefault: case 815: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4409 +//line sql.y:4399 { yyLOCAL = &Rollback{} } @@ -16181,39 +16174,39 @@ yydefault: case 816: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4413 +//line sql.y:4403 { yyLOCAL = &SRollback{Name: yyDollar[5].identifierCI} } yyVAL.union = yyLOCAL case 817: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4418 +//line sql.y:4408 { yyVAL.empty = struct{}{} } case 818: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4420 +//line sql.y:4410 { yyVAL.empty = struct{}{} } case 819: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4423 +//line sql.y:4413 { yyVAL.empty = struct{}{} } case 820: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4425 +//line sql.y:4415 { yyVAL.empty = struct{}{} } case 821: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4429 +//line sql.y:4419 { yyLOCAL = &Savepoint{Name: yyDollar[2].identifierCI} } @@ -16221,7 +16214,7 @@ yydefault: case 822: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4435 +//line sql.y:4425 { yyLOCAL = &Release{Name: yyDollar[3].identifierCI} } @@ -16229,7 +16222,7 @@ yydefault: case 823: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4440 +//line sql.y:4430 { yyLOCAL = EmptyType } @@ -16237,7 +16230,7 @@ yydefault: case 824: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4444 +//line sql.y:4434 { yyLOCAL = JSONType } @@ -16245,7 +16238,7 @@ yydefault: case 825: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4448 +//line sql.y:4438 { yyLOCAL = TreeType } @@ -16253,7 +16246,7 @@ yydefault: case 826: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4452 +//line sql.y:4442 { yyLOCAL = TraditionalType } @@ -16261,7 +16254,7 @@ yydefault: case 827: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4456 +//line sql.y:4446 { yyLOCAL = AnalyzeType } @@ -16269,7 +16262,7 @@ yydefault: case 828: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4461 +//line sql.y:4451 { yyLOCAL = PlanVExplainType } @@ -16277,7 +16270,7 @@ yydefault: case 829: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4465 +//line sql.y:4455 { yyLOCAL = PlanVExplainType } @@ -16285,7 +16278,7 @@ yydefault: case 830: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4469 +//line sql.y:4459 { yyLOCAL = AllVExplainType } @@ -16293,33 +16286,33 @@ yydefault: case 831: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4473 +//line sql.y:4463 { yyLOCAL = QueriesVExplainType } yyVAL.union = yyLOCAL case 832: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4479 +//line sql.y:4469 { yyVAL.str = yyDollar[1].str } case 833: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4483 +//line sql.y:4473 { yyVAL.str = yyDollar[1].str } case 834: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4487 +//line sql.y:4477 { yyVAL.str = yyDollar[1].str } case 835: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4493 +//line sql.y:4483 { yyLOCAL = yyDollar[1].selStmtUnion() } @@ -16327,7 +16320,7 @@ yydefault: case 836: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4497 +//line sql.y:4487 { yyLOCAL = yyDollar[1].statementUnion() } @@ -16335,7 +16328,7 @@ yydefault: case 837: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4501 +//line sql.y:4491 { yyLOCAL = yyDollar[1].statementUnion() } @@ -16343,33 +16336,33 @@ yydefault: case 838: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4505 +//line sql.y:4495 { yyLOCAL = yyDollar[1].statementUnion() } yyVAL.union = yyLOCAL case 839: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4510 +//line sql.y:4500 { yyVAL.str = "" } case 840: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4514 +//line sql.y:4504 { yyVAL.str = yyDollar[1].identifierCI.val } case 841: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4518 +//line sql.y:4508 { yyVAL.str = encodeSQLString(yyDollar[1].str) } case 842: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4524 +//line sql.y:4514 { yyLOCAL = &ExplainTab{Table: yyDollar[3].tableName, Wild: yyDollar[4].str} } @@ -16377,7 +16370,7 @@ yydefault: case 843: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4528 +//line sql.y:4518 { yyLOCAL = &ExplainStmt{Type: yyDollar[3].explainTypeUnion(), Statement: yyDollar[4].statementUnion(), Comments: Comments(yyDollar[2].strs).Parsed()} } @@ -16385,7 +16378,7 @@ yydefault: case 844: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4534 +//line sql.y:4524 { yyLOCAL = &VExplainStmt{Type: yyDollar[3].vexplainTypeUnion(), Statement: yyDollar[4].statementUnion(), Comments: Comments(yyDollar[2].strs).Parsed()} } @@ -16393,7 +16386,7 @@ yydefault: case 845: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4540 +//line sql.y:4530 { yyLOCAL = &OtherAdmin{} } @@ -16401,7 +16394,7 @@ yydefault: case 846: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4544 +//line sql.y:4534 { yyLOCAL = &OtherAdmin{} } @@ -16409,7 +16402,7 @@ yydefault: case 847: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4550 +//line sql.y:4540 { yyLOCAL = &LockTables{Tables: yyDollar[3].tableAndLockTypesUnion()} } @@ -16417,14 +16410,14 @@ yydefault: case 848: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableAndLockTypes -//line sql.y:4556 +//line sql.y:4546 { yyLOCAL = TableAndLockTypes{yyDollar[1].tableAndLockTypeUnion()} } yyVAL.union = yyLOCAL case 849: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4560 +//line sql.y:4550 { yySLICE := (*TableAndLockTypes)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableAndLockTypeUnion()) @@ -16432,7 +16425,7 @@ yydefault: case 850: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *TableAndLockType -//line sql.y:4566 +//line sql.y:4556 { yyLOCAL = &TableAndLockType{Table: yyDollar[1].aliasedTableNameUnion(), Lock: yyDollar[2].lockTypeUnion()} } @@ -16440,7 +16433,7 @@ yydefault: case 851: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LockType -//line sql.y:4572 +//line sql.y:4562 { yyLOCAL = Read } @@ -16448,7 +16441,7 @@ yydefault: case 852: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL LockType -//line sql.y:4576 +//line sql.y:4566 { yyLOCAL = ReadLocal } @@ -16456,7 +16449,7 @@ yydefault: case 853: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LockType -//line sql.y:4580 +//line sql.y:4570 { yyLOCAL = Write } @@ -16464,7 +16457,7 @@ yydefault: case 854: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL LockType -//line sql.y:4584 +//line sql.y:4574 { yyLOCAL = LowPriorityWrite } @@ -16472,7 +16465,7 @@ yydefault: case 855: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4590 +//line sql.y:4580 { yyLOCAL = &UnlockTables{} } @@ -16480,7 +16473,7 @@ yydefault: case 856: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4596 +//line sql.y:4586 { yyLOCAL = &RevertMigration{Comments: Comments(yyDollar[2].strs).Parsed(), UUID: string(yyDollar[4].str)} } @@ -16488,7 +16481,7 @@ yydefault: case 857: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4602 +//line sql.y:4592 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), FlushOptions: yyDollar[3].strs} } @@ -16496,7 +16489,7 @@ yydefault: case 858: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4606 +//line sql.y:4596 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion()} } @@ -16504,7 +16497,7 @@ yydefault: case 859: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:4610 +//line sql.y:4600 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), WithLock: true} } @@ -16512,7 +16505,7 @@ yydefault: case 860: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4614 +//line sql.y:4604 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), TableNames: yyDollar[4].tableNamesUnion()} } @@ -16520,7 +16513,7 @@ yydefault: case 861: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:4618 +//line sql.y:4608 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), TableNames: yyDollar[4].tableNamesUnion(), WithLock: true} } @@ -16528,99 +16521,99 @@ yydefault: case 862: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:4622 +//line sql.y:4612 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), TableNames: yyDollar[4].tableNamesUnion(), ForExport: true} } yyVAL.union = yyLOCAL case 863: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4628 +//line sql.y:4618 { yyVAL.strs = []string{yyDollar[1].str} } case 864: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4632 +//line sql.y:4622 { yyVAL.strs = append(yyDollar[1].strs, yyDollar[3].str) } case 865: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4638 +//line sql.y:4628 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 866: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4642 +//line sql.y:4632 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 867: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4646 +//line sql.y:4636 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 868: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4650 +//line sql.y:4640 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 869: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4654 +//line sql.y:4644 { yyVAL.str = string(yyDollar[1].str) } case 870: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4658 +//line sql.y:4648 { yyVAL.str = string(yyDollar[1].str) } case 871: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4662 +//line sql.y:4652 { yyVAL.str = string(yyDollar[1].str) } case 872: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4666 +//line sql.y:4656 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) + yyDollar[3].str } case 873: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4670 +//line sql.y:4660 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 874: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4674 +//line sql.y:4664 { yyVAL.str = string(yyDollar[1].str) } case 875: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4678 +//line sql.y:4668 { yyVAL.str = string(yyDollar[1].str) } case 876: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4682 +//line sql.y:4672 { yyVAL.str = string(yyDollar[1].str) } case 877: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:4687 +//line sql.y:4677 { yyLOCAL = false } @@ -16628,7 +16621,7 @@ yydefault: case 878: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4691 +//line sql.y:4681 { yyLOCAL = true } @@ -16636,52 +16629,52 @@ yydefault: case 879: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4695 +//line sql.y:4685 { yyLOCAL = true } yyVAL.union = yyLOCAL case 880: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4700 +//line sql.y:4690 { yyVAL.str = "" } case 881: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4704 +//line sql.y:4694 { yyVAL.str = " " + string(yyDollar[1].str) + " " + string(yyDollar[2].str) + " " + yyDollar[3].identifierCI.String() } case 882: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4709 +//line sql.y:4699 { setAllowComments(yylex, true) } case 883: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4713 +//line sql.y:4703 { yyVAL.strs = yyDollar[2].strs setAllowComments(yylex, false) } case 884: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4719 +//line sql.y:4709 { yyVAL.strs = nil } case 885: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4723 +//line sql.y:4713 { yyVAL.strs = append(yyDollar[1].strs, yyDollar[2].str) } case 886: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4729 +//line sql.y:4719 { yyLOCAL = true } @@ -16689,7 +16682,7 @@ yydefault: case 887: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:4733 +//line sql.y:4723 { yyLOCAL = false } @@ -16697,33 +16690,33 @@ yydefault: case 888: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:4737 +//line sql.y:4727 { yyLOCAL = true } yyVAL.union = yyLOCAL case 889: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4742 +//line sql.y:4732 { yyVAL.str = "" } case 890: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4746 +//line sql.y:4736 { yyVAL.str = SQLNoCacheStr } case 891: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4750 +//line sql.y:4740 { yyVAL.str = SQLCacheStr } case 892: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:4755 +//line sql.y:4745 { yyLOCAL = false } @@ -16731,7 +16724,7 @@ yydefault: case 893: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4759 +//line sql.y:4749 { yyLOCAL = true } @@ -16739,7 +16732,7 @@ yydefault: case 894: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4763 +//line sql.y:4753 { yyLOCAL = true } @@ -16747,7 +16740,7 @@ yydefault: case 895: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4769 +//line sql.y:4759 { yyLOCAL = &PrepareStmt{Name: yyDollar[3].identifierCI, Comments: Comments(yyDollar[2].strs).Parsed(), Statement: yyDollar[5].exprUnion()} } @@ -16755,7 +16748,7 @@ yydefault: case 896: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4773 +//line sql.y:4763 { yyLOCAL = &PrepareStmt{ Name: yyDollar[3].identifierCI, @@ -16767,7 +16760,7 @@ yydefault: case 897: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4783 +//line sql.y:4773 { yyLOCAL = &ExecuteStmt{Name: yyDollar[3].identifierCI, Comments: Comments(yyDollar[2].strs).Parsed(), Arguments: yyDollar[4].variablesUnion()} } @@ -16775,7 +16768,7 @@ yydefault: case 898: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*Variable -//line sql.y:4788 +//line sql.y:4778 { yyLOCAL = nil } @@ -16783,7 +16776,7 @@ yydefault: case 899: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []*Variable -//line sql.y:4792 +//line sql.y:4782 { yyLOCAL = yyDollar[2].variablesUnion() } @@ -16791,7 +16784,7 @@ yydefault: case 900: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4798 +//line sql.y:4788 { yyLOCAL = &DeallocateStmt{Comments: Comments(yyDollar[2].strs).Parsed(), Name: yyDollar[4].identifierCI} } @@ -16799,7 +16792,7 @@ yydefault: case 901: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4802 +//line sql.y:4792 { yyLOCAL = &DeallocateStmt{Comments: Comments(yyDollar[2].strs).Parsed(), Name: yyDollar[4].identifierCI} } @@ -16807,7 +16800,7 @@ yydefault: case 902: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL SelectExprs -//line sql.y:4807 +//line sql.y:4797 { yyLOCAL = nil } @@ -16815,88 +16808,88 @@ yydefault: case 903: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectExprs -//line sql.y:4811 +//line sql.y:4801 { yyLOCAL = yyDollar[1].selectExprsUnion() } yyVAL.union = yyLOCAL case 904: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4816 +//line sql.y:4806 { yyVAL.strs = nil } case 905: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4820 +//line sql.y:4810 { yyVAL.strs = yyDollar[1].strs } case 906: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4826 +//line sql.y:4816 { yyVAL.strs = []string{yyDollar[1].str} } case 907: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4830 +//line sql.y:4820 { yyVAL.strs = append(yyDollar[1].strs, yyDollar[2].str) } case 908: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4836 +//line sql.y:4826 { yyVAL.str = SQLNoCacheStr } case 909: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4840 +//line sql.y:4830 { yyVAL.str = SQLCacheStr } case 910: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4844 +//line sql.y:4834 { yyVAL.str = DistinctStr } case 911: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4848 +//line sql.y:4838 { yyVAL.str = DistinctStr } case 912: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4852 +//line sql.y:4842 { yyVAL.str = StraightJoinHint } case 913: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4856 +//line sql.y:4846 { yyVAL.str = SQLCalcFoundRowsStr } case 914: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4860 +//line sql.y:4850 { yyVAL.str = AllStr // These are not picked up by NewSelect, and so ALL will be dropped. But this is OK, since it's redundant anyway } case 915: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectExprs -//line sql.y:4866 +//line sql.y:4856 { yyLOCAL = SelectExprs{yyDollar[1].selectExprUnion()} } yyVAL.union = yyLOCAL case 916: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4870 +//line sql.y:4860 { yySLICE := (*SelectExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].selectExprUnion()) @@ -16904,7 +16897,7 @@ yydefault: case 917: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4876 +//line sql.y:4866 { yyLOCAL = &StarExpr{} } @@ -16912,7 +16905,7 @@ yydefault: case 918: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4880 +//line sql.y:4870 { yyLOCAL = &AliasedExpr{Expr: yyDollar[1].exprUnion(), As: yyDollar[2].identifierCI} } @@ -16920,7 +16913,7 @@ yydefault: case 919: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4884 +//line sql.y:4874 { yyLOCAL = &StarExpr{TableName: TableName{Name: yyDollar[1].identifierCS}} } @@ -16928,39 +16921,39 @@ yydefault: case 920: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4888 +//line sql.y:4878 { yyLOCAL = &StarExpr{TableName: TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS}} } yyVAL.union = yyLOCAL case 921: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4893 +//line sql.y:4883 { yyVAL.identifierCI = IdentifierCI{} } case 922: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4897 +//line sql.y:4887 { yyVAL.identifierCI = yyDollar[1].identifierCI } case 923: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4901 +//line sql.y:4891 { yyVAL.identifierCI = yyDollar[2].identifierCI } case 925: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4908 +//line sql.y:4898 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } case 926: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4913 +//line sql.y:4903 { yyLOCAL = TableExprs{&AliasedTableExpr{Expr: TableName{Name: NewIdentifierCS("dual")}}} } @@ -16968,7 +16961,7 @@ yydefault: case 927: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4917 +//line sql.y:4907 { yyLOCAL = yyDollar[1].tableExprsUnion() } @@ -16976,7 +16969,7 @@ yydefault: case 928: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4923 +//line sql.y:4913 { yyLOCAL = yyDollar[2].tableExprsUnion() } @@ -16984,14 +16977,14 @@ yydefault: case 929: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4929 +//line sql.y:4919 { yyLOCAL = TableExprs{yyDollar[1].tableExprUnion()} } yyVAL.union = yyLOCAL case 930: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4933 +//line sql.y:4923 { yySLICE := (*TableExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableExprUnion()) @@ -16999,7 +16992,7 @@ yydefault: case 933: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4943 +//line sql.y:4933 { yyLOCAL = yyDollar[1].aliasedTableNameUnion() } @@ -17007,7 +17000,7 @@ yydefault: case 934: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4947 +//line sql.y:4937 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].derivedTableUnion(), As: yyDollar[3].identifierCS, Columns: yyDollar[4].columnsUnion()} } @@ -17015,7 +17008,7 @@ yydefault: case 935: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4951 +//line sql.y:4941 { yyLOCAL = &ParenTableExpr{Exprs: yyDollar[2].tableExprsUnion()} } @@ -17023,7 +17016,7 @@ yydefault: case 936: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4955 +//line sql.y:4945 { yyLOCAL = yyDollar[1].tableExprUnion() } @@ -17031,7 +17024,7 @@ yydefault: case 937: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *DerivedTable -//line sql.y:4961 +//line sql.y:4951 { yyLOCAL = &DerivedTable{Lateral: false, Select: yyDollar[1].selStmtUnion()} } @@ -17039,7 +17032,7 @@ yydefault: case 938: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *DerivedTable -//line sql.y:4965 +//line sql.y:4955 { yyLOCAL = &DerivedTable{Lateral: true, Select: yyDollar[2].selStmtUnion()} } @@ -17047,7 +17040,7 @@ yydefault: case 939: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *AliasedTableExpr -//line sql.y:4971 +//line sql.y:4961 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].tableName, As: yyDollar[2].identifierCS, Hints: yyDollar[3].indexHintsUnion()} } @@ -17055,7 +17048,7 @@ yydefault: case 940: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *AliasedTableExpr -//line sql.y:4975 +//line sql.y:4965 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].tableName, Partitions: yyDollar[4].partitionsUnion(), As: yyDollar[6].identifierCS, Hints: yyDollar[7].indexHintsUnion()} } @@ -17063,7 +17056,7 @@ yydefault: case 941: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Columns -//line sql.y:4980 +//line sql.y:4970 { yyLOCAL = nil } @@ -17071,7 +17064,7 @@ yydefault: case 942: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Columns -//line sql.y:4984 +//line sql.y:4974 { yyLOCAL = yyDollar[2].columnsUnion() } @@ -17079,7 +17072,7 @@ yydefault: case 943: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Columns -//line sql.y:4989 +//line sql.y:4979 { yyLOCAL = nil } @@ -17087,7 +17080,7 @@ yydefault: case 944: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:4993 +//line sql.y:4983 { yyLOCAL = yyDollar[1].columnsUnion() } @@ -17095,14 +17088,14 @@ yydefault: case 945: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:4999 +//line sql.y:4989 { yyLOCAL = Columns{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL case 946: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5003 +//line sql.y:4993 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) @@ -17110,14 +17103,14 @@ yydefault: case 947: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*Variable -//line sql.y:5009 +//line sql.y:4999 { yyLOCAL = []*Variable{yyDollar[1].variableUnion()} } yyVAL.union = yyLOCAL case 948: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5013 +//line sql.y:5003 { yySLICE := (*[]*Variable)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].variableUnion()) @@ -17125,7 +17118,7 @@ yydefault: case 949: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5019 +//line sql.y:5009 { yyLOCAL = Columns{yyDollar[1].identifierCI} } @@ -17133,21 +17126,21 @@ yydefault: case 950: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5023 +//line sql.y:5013 { yyLOCAL = Columns{NewIdentifierCI(string(yyDollar[1].str))} } yyVAL.union = yyLOCAL case 951: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5027 +//line sql.y:5017 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } case 952: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5031 +//line sql.y:5021 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, NewIdentifierCI(string(yyDollar[3].str))) @@ -17155,14 +17148,14 @@ yydefault: case 953: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Partitions -//line sql.y:5037 +//line sql.y:5027 { yyLOCAL = Partitions{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL case 954: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5041 +//line sql.y:5031 { yySLICE := (*Partitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) @@ -17170,7 +17163,7 @@ yydefault: case 955: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5054 +//line sql.y:5044 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } @@ -17178,7 +17171,7 @@ yydefault: case 956: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5058 +//line sql.y:5048 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } @@ -17186,7 +17179,7 @@ yydefault: case 957: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5062 +//line sql.y:5052 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } @@ -17194,87 +17187,87 @@ yydefault: case 958: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5066 +//line sql.y:5056 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion()} } yyVAL.union = yyLOCAL case 959: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5072 +//line sql.y:5062 { yyVAL.joinCondition = &JoinCondition{On: yyDollar[2].exprUnion()} } case 960: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5074 +//line sql.y:5064 { yyVAL.joinCondition = &JoinCondition{Using: yyDollar[3].columnsUnion()} } case 961: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5078 +//line sql.y:5068 { yyVAL.joinCondition = &JoinCondition{} } case 962: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5080 +//line sql.y:5070 { yyVAL.joinCondition = yyDollar[1].joinCondition } case 963: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5084 +//line sql.y:5074 { yyVAL.joinCondition = &JoinCondition{} } case 964: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5086 +//line sql.y:5076 { yyVAL.joinCondition = &JoinCondition{On: yyDollar[2].exprUnion()} } case 965: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5089 +//line sql.y:5079 { yyVAL.empty = struct{}{} } case 966: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5091 +//line sql.y:5081 { yyVAL.empty = struct{}{} } case 967: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5094 +//line sql.y:5084 { yyVAL.identifierCS = NewIdentifierCS("") } case 968: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5098 +//line sql.y:5088 { yyVAL.identifierCS = yyDollar[1].identifierCS } case 969: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5102 +//line sql.y:5092 { yyVAL.identifierCS = yyDollar[2].identifierCS } case 971: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5109 +//line sql.y:5099 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } case 972: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL JoinType -//line sql.y:5115 +//line sql.y:5105 { yyLOCAL = NormalJoinType } @@ -17282,7 +17275,7 @@ yydefault: case 973: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5119 +//line sql.y:5109 { yyLOCAL = NormalJoinType } @@ -17290,7 +17283,7 @@ yydefault: case 974: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5123 +//line sql.y:5113 { yyLOCAL = NormalJoinType } @@ -17298,7 +17291,7 @@ yydefault: case 975: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL JoinType -//line sql.y:5129 +//line sql.y:5119 { yyLOCAL = StraightJoinType } @@ -17306,7 +17299,7 @@ yydefault: case 976: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5135 +//line sql.y:5125 { yyLOCAL = LeftJoinType } @@ -17314,7 +17307,7 @@ yydefault: case 977: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL JoinType -//line sql.y:5139 +//line sql.y:5129 { yyLOCAL = LeftJoinType } @@ -17322,7 +17315,7 @@ yydefault: case 978: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5143 +//line sql.y:5133 { yyLOCAL = RightJoinType } @@ -17330,7 +17323,7 @@ yydefault: case 979: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL JoinType -//line sql.y:5147 +//line sql.y:5137 { yyLOCAL = RightJoinType } @@ -17338,7 +17331,7 @@ yydefault: case 980: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5153 +//line sql.y:5143 { yyLOCAL = NaturalJoinType } @@ -17346,7 +17339,7 @@ yydefault: case 981: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5157 +//line sql.y:5147 { if yyDollar[2].joinTypeUnion() == LeftJoinType { yyLOCAL = NaturalLeftJoinType @@ -17357,38 +17350,38 @@ yydefault: yyVAL.union = yyLOCAL case 982: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5167 +//line sql.y:5157 { yyVAL.tableName = yyDollar[2].tableName } case 983: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5171 +//line sql.y:5161 { yyVAL.tableName = yyDollar[1].tableName } case 984: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5177 +//line sql.y:5167 { yyVAL.tableName = TableName{Name: yyDollar[1].identifierCS} } case 985: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5181 +//line sql.y:5171 { yyVAL.tableName = TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS} } case 986: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5187 +//line sql.y:5177 { yyVAL.tableName = TableName{Name: yyDollar[1].identifierCS} } case 987: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5192 +//line sql.y:5182 { yyLOCAL = nil } @@ -17396,7 +17389,7 @@ yydefault: case 988: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5196 +//line sql.y:5186 { yyLOCAL = yyDollar[1].indexHintsUnion() } @@ -17404,14 +17397,14 @@ yydefault: case 989: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5202 +//line sql.y:5192 { yyLOCAL = IndexHints{yyDollar[1].indexHintUnion()} } yyVAL.union = yyLOCAL case 990: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5206 +//line sql.y:5196 { yySLICE := (*IndexHints)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].indexHintUnion()) @@ -17419,7 +17412,7 @@ yydefault: case 991: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5212 +//line sql.y:5202 { yyLOCAL = &IndexHint{Type: UseOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } @@ -17427,7 +17420,7 @@ yydefault: case 992: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5216 +//line sql.y:5206 { yyLOCAL = &IndexHint{Type: UseOp, ForType: yyDollar[3].indexHintForTypeUnion()} } @@ -17435,7 +17428,7 @@ yydefault: case 993: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5220 +//line sql.y:5210 { yyLOCAL = &IndexHint{Type: IgnoreOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } @@ -17443,7 +17436,7 @@ yydefault: case 994: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5224 +//line sql.y:5214 { yyLOCAL = &IndexHint{Type: ForceOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } @@ -17451,7 +17444,7 @@ yydefault: case 995: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5228 +//line sql.y:5218 { yyLOCAL = &IndexHint{Type: UseVindexOp, Indexes: yyDollar[4].columnsUnion()} } @@ -17459,7 +17452,7 @@ yydefault: case 996: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5232 +//line sql.y:5222 { yyLOCAL = &IndexHint{Type: IgnoreVindexOp, Indexes: yyDollar[4].columnsUnion()} } @@ -17467,7 +17460,7 @@ yydefault: case 997: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5237 +//line sql.y:5227 { yyLOCAL = NoForType } @@ -17475,7 +17468,7 @@ yydefault: case 998: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5241 +//line sql.y:5231 { yyLOCAL = JoinForType } @@ -17483,7 +17476,7 @@ yydefault: case 999: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5245 +//line sql.y:5235 { yyLOCAL = OrderByForType } @@ -17491,7 +17484,7 @@ yydefault: case 1000: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5249 +//line sql.y:5239 { yyLOCAL = GroupByForType } @@ -17499,7 +17492,7 @@ yydefault: case 1001: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:5255 +//line sql.y:5245 { yyLOCAL = nil } @@ -17507,7 +17500,7 @@ yydefault: case 1002: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5259 +//line sql.y:5249 { yyLOCAL = yyDollar[2].exprUnion() } @@ -17515,7 +17508,7 @@ yydefault: case 1003: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5266 +//line sql.y:5256 { yyLOCAL = &OrExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } @@ -17523,7 +17516,7 @@ yydefault: case 1004: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5270 +//line sql.y:5260 { yyLOCAL = &XorExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } @@ -17531,7 +17524,7 @@ yydefault: case 1005: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5274 +//line sql.y:5264 { yyLOCAL = &AndExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } @@ -17539,7 +17532,7 @@ yydefault: case 1006: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5278 +//line sql.y:5268 { yyLOCAL = &NotExpr{Expr: yyDollar[2].exprUnion()} } @@ -17547,7 +17540,7 @@ yydefault: case 1007: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5282 +//line sql.y:5272 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].isExprOperatorUnion()} } @@ -17555,7 +17548,7 @@ yydefault: case 1008: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5286 +//line sql.y:5276 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17563,7 +17556,7 @@ yydefault: case 1009: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5290 +//line sql.y:5280 { yyLOCAL = &AssignmentExpr{Left: yyDollar[1].variableUnion(), Right: yyDollar[3].exprUnion()} } @@ -17571,7 +17564,7 @@ yydefault: case 1010: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5294 +//line sql.y:5284 { yyLOCAL = &MemberOfExpr{Value: yyDollar[1].exprUnion(), JSONArr: yyDollar[5].exprUnion()} } @@ -17579,7 +17572,7 @@ yydefault: case 1011: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5300 +//line sql.y:5290 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: IsNullOp} } @@ -17587,7 +17580,7 @@ yydefault: case 1012: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5304 +//line sql.y:5294 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: IsNotNullOp} } @@ -17595,7 +17588,7 @@ yydefault: case 1013: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5308 +//line sql.y:5298 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: yyDollar[2].comparisonExprOperatorUnion(), Right: yyDollar[3].exprUnion()} } @@ -17603,7 +17596,7 @@ yydefault: case 1014: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5312 +//line sql.y:5302 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17611,7 +17604,7 @@ yydefault: case 1015: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5318 +//line sql.y:5308 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: InOp, Right: yyDollar[3].colTupleUnion()} } @@ -17619,7 +17612,7 @@ yydefault: case 1016: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5322 +//line sql.y:5312 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotInOp, Right: yyDollar[4].colTupleUnion()} } @@ -17627,7 +17620,7 @@ yydefault: case 1017: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5326 +//line sql.y:5316 { yyLOCAL = &BetweenExpr{Left: yyDollar[1].exprUnion(), IsBetween: true, From: yyDollar[3].exprUnion(), To: yyDollar[5].exprUnion()} } @@ -17635,7 +17628,7 @@ yydefault: case 1018: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5330 +//line sql.y:5320 { yyLOCAL = &BetweenExpr{Left: yyDollar[1].exprUnion(), IsBetween: false, From: yyDollar[4].exprUnion(), To: yyDollar[6].exprUnion()} } @@ -17643,7 +17636,7 @@ yydefault: case 1019: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5334 +//line sql.y:5324 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: LikeOp, Right: yyDollar[3].exprUnion()} } @@ -17651,7 +17644,7 @@ yydefault: case 1020: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5338 +//line sql.y:5328 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotLikeOp, Right: yyDollar[4].exprUnion()} } @@ -17659,7 +17652,7 @@ yydefault: case 1021: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5342 +//line sql.y:5332 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: LikeOp, Right: yyDollar[3].exprUnion(), Escape: yyDollar[5].exprUnion()} } @@ -17667,7 +17660,7 @@ yydefault: case 1022: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5346 +//line sql.y:5336 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotLikeOp, Right: yyDollar[4].exprUnion(), Escape: yyDollar[6].exprUnion()} } @@ -17675,7 +17668,7 @@ yydefault: case 1023: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5350 +//line sql.y:5340 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: RegexpOp, Right: yyDollar[3].exprUnion()} } @@ -17683,7 +17676,7 @@ yydefault: case 1024: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5354 +//line sql.y:5344 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotRegexpOp, Right: yyDollar[4].exprUnion()} } @@ -17691,25 +17684,25 @@ yydefault: case 1025: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5358 +//line sql.y:5348 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL case 1026: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5364 +//line sql.y:5354 { } case 1027: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5367 +//line sql.y:5357 { } case 1028: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5373 +//line sql.y:5363 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitOrOp, Right: yyDollar[3].exprUnion()} } @@ -17717,7 +17710,7 @@ yydefault: case 1029: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5377 +//line sql.y:5367 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitAndOp, Right: yyDollar[3].exprUnion()} } @@ -17725,7 +17718,7 @@ yydefault: case 1030: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5381 +//line sql.y:5371 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ShiftLeftOp, Right: yyDollar[3].exprUnion()} } @@ -17733,7 +17726,7 @@ yydefault: case 1031: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5385 +//line sql.y:5375 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ShiftRightOp, Right: yyDollar[3].exprUnion()} } @@ -17741,7 +17734,7 @@ yydefault: case 1032: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5389 +//line sql.y:5379 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: PlusOp, Right: yyDollar[3].exprUnion()} } @@ -17749,7 +17742,7 @@ yydefault: case 1033: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5393 +//line sql.y:5383 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: MinusOp, Right: yyDollar[3].exprUnion()} } @@ -17757,7 +17750,7 @@ yydefault: case 1034: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5397 +//line sql.y:5387 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinaryAdd, Date: yyDollar[1].exprUnion(), Unit: yyDollar[5].intervalTypeUnion(), Interval: yyDollar[4].exprUnion()} } @@ -17765,7 +17758,7 @@ yydefault: case 1035: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5401 +//line sql.y:5391 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinarySub, Date: yyDollar[1].exprUnion(), Unit: yyDollar[5].intervalTypeUnion(), Interval: yyDollar[4].exprUnion()} } @@ -17773,7 +17766,7 @@ yydefault: case 1036: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5405 +//line sql.y:5395 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: MultOp, Right: yyDollar[3].exprUnion()} } @@ -17781,7 +17774,7 @@ yydefault: case 1037: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5409 +//line sql.y:5399 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: DivOp, Right: yyDollar[3].exprUnion()} } @@ -17789,7 +17782,7 @@ yydefault: case 1038: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5413 +//line sql.y:5403 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ModOp, Right: yyDollar[3].exprUnion()} } @@ -17797,7 +17790,7 @@ yydefault: case 1039: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5417 +//line sql.y:5407 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: IntDivOp, Right: yyDollar[3].exprUnion()} } @@ -17805,7 +17798,7 @@ yydefault: case 1040: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5421 +//line sql.y:5411 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ModOp, Right: yyDollar[3].exprUnion()} } @@ -17813,7 +17806,7 @@ yydefault: case 1041: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5425 +//line sql.y:5415 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitXorOp, Right: yyDollar[3].exprUnion()} } @@ -17821,7 +17814,7 @@ yydefault: case 1042: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5429 +//line sql.y:5419 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17829,7 +17822,7 @@ yydefault: case 1043: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5435 +//line sql.y:5425 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17837,7 +17830,7 @@ yydefault: case 1044: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5439 +//line sql.y:5429 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17845,7 +17838,7 @@ yydefault: case 1045: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5443 +//line sql.y:5433 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17853,7 +17846,7 @@ yydefault: case 1046: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5447 +//line sql.y:5437 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17861,7 +17854,7 @@ yydefault: case 1047: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5451 +//line sql.y:5441 { yyLOCAL = &CollateExpr{Expr: yyDollar[1].exprUnion(), Collation: yyDollar[3].str} } @@ -17869,7 +17862,7 @@ yydefault: case 1048: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5455 +//line sql.y:5445 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17877,7 +17870,7 @@ yydefault: case 1049: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5459 +//line sql.y:5449 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17885,7 +17878,7 @@ yydefault: case 1050: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5463 +//line sql.y:5453 { yyLOCAL = yyDollar[1].variableUnion() } @@ -17893,7 +17886,7 @@ yydefault: case 1051: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5467 +//line sql.y:5457 { yyLOCAL = yyDollar[2].exprUnion() // TODO: do we really want to ignore unary '+' before any kind of literals? } @@ -17901,7 +17894,7 @@ yydefault: case 1052: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5471 +//line sql.y:5461 { yyLOCAL = &UnaryExpr{Operator: UMinusOp, Expr: yyDollar[2].exprUnion()} } @@ -17909,7 +17902,7 @@ yydefault: case 1053: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5475 +//line sql.y:5465 { yyLOCAL = &UnaryExpr{Operator: TildaOp, Expr: yyDollar[2].exprUnion()} } @@ -17917,7 +17910,7 @@ yydefault: case 1054: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5479 +//line sql.y:5469 { yyLOCAL = &UnaryExpr{Operator: BangOp, Expr: yyDollar[2].exprUnion()} } @@ -17925,7 +17918,7 @@ yydefault: case 1055: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5483 +//line sql.y:5473 { yyLOCAL = yyDollar[1].subqueryUnion() } @@ -17933,7 +17926,7 @@ yydefault: case 1056: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5487 +//line sql.y:5477 { yyLOCAL = yyDollar[1].exprUnion() } @@ -17941,7 +17934,7 @@ yydefault: case 1057: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5491 +//line sql.y:5481 { yyLOCAL = &ExistsExpr{Subquery: yyDollar[2].subqueryUnion()} } @@ -17949,7 +17942,7 @@ yydefault: case 1058: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:5495 +//line sql.y:5485 { yyLOCAL = &MatchExpr{Columns: yyDollar[2].colNamesUnion(), Expr: yyDollar[5].exprUnion(), Option: yyDollar[6].matchExprOptionUnion()} } @@ -17957,7 +17950,7 @@ yydefault: case 1059: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:5499 +//line sql.y:5489 { yyLOCAL = &CastExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].convertTypeUnion(), Array: yyDollar[6].booleanUnion()} } @@ -17965,7 +17958,7 @@ yydefault: case 1060: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5503 +//line sql.y:5493 { yyLOCAL = &ConvertExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].convertTypeUnion()} } @@ -17973,7 +17966,7 @@ yydefault: case 1061: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5507 +//line sql.y:5497 { yyLOCAL = &ConvertUsingExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].str} } @@ -17981,7 +17974,7 @@ yydefault: case 1062: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5511 +//line sql.y:5501 { // From: https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#operator_binary // To convert a string expression to a binary string, these constructs are equivalent: @@ -17993,7 +17986,7 @@ yydefault: case 1063: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5519 +//line sql.y:5509 { yyLOCAL = &Default{ColName: yyDollar[2].str} } @@ -18001,7 +17994,7 @@ yydefault: case 1064: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5523 +//line sql.y:5513 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinaryAddLeft, Date: yyDollar[5].exprUnion(), Unit: yyDollar[3].intervalTypeUnion(), Interval: yyDollar[2].exprUnion()} } @@ -18009,7 +18002,7 @@ yydefault: case 1065: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5527 +//line sql.y:5517 { yyLOCAL = &IntervalFuncExpr{Expr: yyDollar[3].exprUnion(), Exprs: yyDollar[5].exprsUnion()} } @@ -18017,7 +18010,7 @@ yydefault: case 1066: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5531 +//line sql.y:5521 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: JSONExtractOp, Right: yyDollar[3].exprUnion()} } @@ -18025,7 +18018,7 @@ yydefault: case 1067: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5535 +//line sql.y:5525 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: JSONUnquoteExtractOp, Right: yyDollar[3].exprUnion()} } @@ -18033,7 +18026,7 @@ yydefault: case 1068: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5541 +//line sql.y:5531 { yyLOCAL = yyDollar[1].colNamesUnion() } @@ -18041,7 +18034,7 @@ yydefault: case 1069: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5545 +//line sql.y:5535 { yyLOCAL = yyDollar[2].colNamesUnion() } @@ -18049,14 +18042,14 @@ yydefault: case 1070: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5551 +//line sql.y:5541 { yyLOCAL = []*ColName{yyDollar[1].colNameUnion()} } yyVAL.union = yyLOCAL case 1071: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5555 +//line sql.y:5545 { yySLICE := (*[]*ColName)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].colNameUnion()) @@ -18064,7 +18057,7 @@ yydefault: case 1072: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5561 +//line sql.y:5551 { yyLOCAL = BothTrimType } @@ -18072,7 +18065,7 @@ yydefault: case 1073: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5565 +//line sql.y:5555 { yyLOCAL = LeadingTrimType } @@ -18080,7 +18073,7 @@ yydefault: case 1074: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5569 +//line sql.y:5559 { yyLOCAL = TrailingTrimType } @@ -18088,7 +18081,7 @@ yydefault: case 1075: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FrameUnitType -//line sql.y:5575 +//line sql.y:5565 { yyLOCAL = FrameRowsType } @@ -18096,7 +18089,7 @@ yydefault: case 1076: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FrameUnitType -//line sql.y:5579 +//line sql.y:5569 { yyLOCAL = FrameRangeType } @@ -18104,7 +18097,7 @@ yydefault: case 1077: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5586 +//line sql.y:5576 { yyLOCAL = CumeDistExprType } @@ -18112,7 +18105,7 @@ yydefault: case 1078: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5590 +//line sql.y:5580 { yyLOCAL = DenseRankExprType } @@ -18120,7 +18113,7 @@ yydefault: case 1079: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5594 +//line sql.y:5584 { yyLOCAL = PercentRankExprType } @@ -18128,7 +18121,7 @@ yydefault: case 1080: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5598 +//line sql.y:5588 { yyLOCAL = RankExprType } @@ -18136,7 +18129,7 @@ yydefault: case 1081: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5602 +//line sql.y:5592 { yyLOCAL = RowNumberExprType } @@ -18144,7 +18137,7 @@ yydefault: case 1082: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5608 +//line sql.y:5598 { yyLOCAL = &FramePoint{Type: CurrentRowType} } @@ -18152,7 +18145,7 @@ yydefault: case 1083: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5612 +//line sql.y:5602 { yyLOCAL = &FramePoint{Type: UnboundedPrecedingType} } @@ -18160,7 +18153,7 @@ yydefault: case 1084: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5616 +//line sql.y:5606 { yyLOCAL = &FramePoint{Type: UnboundedFollowingType} } @@ -18168,7 +18161,7 @@ yydefault: case 1085: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5620 +//line sql.y:5610 { yyLOCAL = &FramePoint{Type: ExprPrecedingType, Expr: yyDollar[1].exprUnion()} } @@ -18176,7 +18169,7 @@ yydefault: case 1086: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5624 +//line sql.y:5614 { yyLOCAL = &FramePoint{Type: ExprPrecedingType, Expr: yyDollar[2].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } @@ -18184,7 +18177,7 @@ yydefault: case 1087: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5628 +//line sql.y:5618 { yyLOCAL = &FramePoint{Type: ExprFollowingType, Expr: yyDollar[1].exprUnion()} } @@ -18192,7 +18185,7 @@ yydefault: case 1088: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5632 +//line sql.y:5622 { yyLOCAL = &FramePoint{Type: ExprFollowingType, Expr: yyDollar[2].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } @@ -18200,7 +18193,7 @@ yydefault: case 1089: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5637 +//line sql.y:5627 { yyLOCAL = nil } @@ -18208,7 +18201,7 @@ yydefault: case 1090: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5641 +//line sql.y:5631 { yyLOCAL = yyDollar[1].frameClauseUnion() } @@ -18216,7 +18209,7 @@ yydefault: case 1091: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5647 +//line sql.y:5637 { yyLOCAL = &FrameClause{Unit: yyDollar[1].frameUnitTypeUnion(), Start: yyDollar[2].framePointUnion()} } @@ -18224,7 +18217,7 @@ yydefault: case 1092: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5651 +//line sql.y:5641 { yyLOCAL = &FrameClause{Unit: yyDollar[1].frameUnitTypeUnion(), Start: yyDollar[3].framePointUnion(), End: yyDollar[5].framePointUnion()} } @@ -18232,7 +18225,7 @@ yydefault: case 1093: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:5656 +//line sql.y:5646 { yyLOCAL = nil } @@ -18240,26 +18233,26 @@ yydefault: case 1094: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Exprs -//line sql.y:5660 +//line sql.y:5650 { yyLOCAL = yyDollar[3].exprsUnion() } yyVAL.union = yyLOCAL case 1095: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5665 +//line sql.y:5655 { } case 1096: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5668 +//line sql.y:5658 { yyVAL.identifierCI = yyDollar[1].identifierCI } case 1097: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *WindowSpecification -//line sql.y:5674 +//line sql.y:5664 { yyLOCAL = &WindowSpecification{Name: yyDollar[1].identifierCI, PartitionClause: yyDollar[2].exprsUnion(), OrderClause: yyDollar[3].orderByUnion(), FrameClause: yyDollar[4].frameClauseUnion()} } @@ -18267,7 +18260,7 @@ yydefault: case 1098: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5680 +//line sql.y:5670 { yyLOCAL = &OverClause{WindowSpec: yyDollar[3].windowSpecificationUnion()} } @@ -18275,7 +18268,7 @@ yydefault: case 1099: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5684 +//line sql.y:5674 { yyLOCAL = &OverClause{WindowName: yyDollar[2].identifierCI} } @@ -18283,7 +18276,7 @@ yydefault: case 1100: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *NullTreatmentClause -//line sql.y:5689 +//line sql.y:5679 { yyLOCAL = nil } @@ -18291,7 +18284,7 @@ yydefault: case 1102: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *NullTreatmentClause -//line sql.y:5696 +//line sql.y:5686 { yyLOCAL = &NullTreatmentClause{yyDollar[1].nullTreatmentTypeUnion()} } @@ -18299,7 +18292,7 @@ yydefault: case 1103: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL NullTreatmentType -//line sql.y:5702 +//line sql.y:5692 { yyLOCAL = RespectNullsType } @@ -18307,7 +18300,7 @@ yydefault: case 1104: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL NullTreatmentType -//line sql.y:5706 +//line sql.y:5696 { yyLOCAL = IgnoreNullsType } @@ -18315,7 +18308,7 @@ yydefault: case 1105: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FirstOrLastValueExprType -//line sql.y:5712 +//line sql.y:5702 { yyLOCAL = FirstValueExprType } @@ -18323,7 +18316,7 @@ yydefault: case 1106: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FirstOrLastValueExprType -//line sql.y:5716 +//line sql.y:5706 { yyLOCAL = LastValueExprType } @@ -18331,7 +18324,7 @@ yydefault: case 1107: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL FromFirstLastType -//line sql.y:5722 +//line sql.y:5712 { yyLOCAL = FromFirstType } @@ -18339,7 +18332,7 @@ yydefault: case 1108: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL FromFirstLastType -//line sql.y:5726 +//line sql.y:5716 { yyLOCAL = FromLastType } @@ -18347,7 +18340,7 @@ yydefault: case 1109: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *FromFirstLastClause -//line sql.y:5731 +//line sql.y:5721 { yyLOCAL = nil } @@ -18355,7 +18348,7 @@ yydefault: case 1111: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *FromFirstLastClause -//line sql.y:5738 +//line sql.y:5728 { yyLOCAL = &FromFirstLastClause{yyDollar[1].fromFirstLastTypeUnion()} } @@ -18363,7 +18356,7 @@ yydefault: case 1112: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LagLeadExprType -//line sql.y:5744 +//line sql.y:5734 { yyLOCAL = LagExprType } @@ -18371,7 +18364,7 @@ yydefault: case 1113: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LagLeadExprType -//line sql.y:5748 +//line sql.y:5738 { yyLOCAL = LeadExprType } @@ -18379,7 +18372,7 @@ yydefault: case 1114: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *WindowDefinition -//line sql.y:5754 +//line sql.y:5744 { yyLOCAL = &WindowDefinition{Name: yyDollar[1].identifierCI, WindowSpec: yyDollar[4].windowSpecificationUnion()} } @@ -18387,34 +18380,34 @@ yydefault: case 1115: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL WindowDefinitions -//line sql.y:5760 +//line sql.y:5750 { yyLOCAL = WindowDefinitions{yyDollar[1].windowDefinitionUnion()} } yyVAL.union = yyLOCAL case 1116: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5764 +//line sql.y:5754 { yySLICE := (*WindowDefinitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].windowDefinitionUnion()) } case 1117: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5770 +//line sql.y:5760 { yyVAL.str = "" } case 1118: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5774 +//line sql.y:5764 { yyVAL.str = string(yyDollar[2].identifierCI.String()) } case 1119: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL BoolVal -//line sql.y:5780 +//line sql.y:5770 { yyLOCAL = BoolVal(true) } @@ -18422,7 +18415,7 @@ yydefault: case 1120: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL BoolVal -//line sql.y:5784 +//line sql.y:5774 { yyLOCAL = BoolVal(false) } @@ -18430,7 +18423,7 @@ yydefault: case 1121: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5791 +//line sql.y:5781 { yyLOCAL = IsTrueOp } @@ -18438,7 +18431,7 @@ yydefault: case 1122: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5795 +//line sql.y:5785 { yyLOCAL = IsNotTrueOp } @@ -18446,7 +18439,7 @@ yydefault: case 1123: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5799 +//line sql.y:5789 { yyLOCAL = IsFalseOp } @@ -18454,7 +18447,7 @@ yydefault: case 1124: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5803 +//line sql.y:5793 { yyLOCAL = IsNotFalseOp } @@ -18462,7 +18455,7 @@ yydefault: case 1125: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5809 +//line sql.y:5799 { yyLOCAL = EqualOp } @@ -18470,7 +18463,7 @@ yydefault: case 1126: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5813 +//line sql.y:5803 { yyLOCAL = LessThanOp } @@ -18478,7 +18471,7 @@ yydefault: case 1127: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5817 +//line sql.y:5807 { yyLOCAL = GreaterThanOp } @@ -18486,7 +18479,7 @@ yydefault: case 1128: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5821 +//line sql.y:5811 { yyLOCAL = LessEqualOp } @@ -18494,7 +18487,7 @@ yydefault: case 1129: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5825 +//line sql.y:5815 { yyLOCAL = GreaterEqualOp } @@ -18502,7 +18495,7 @@ yydefault: case 1130: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5829 +//line sql.y:5819 { yyLOCAL = NotEqualOp } @@ -18510,7 +18503,7 @@ yydefault: case 1131: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5833 +//line sql.y:5823 { yyLOCAL = NullSafeEqualOp } @@ -18518,7 +18511,7 @@ yydefault: case 1132: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5839 +//line sql.y:5829 { yyLOCAL = yyDollar[1].valTupleUnion() } @@ -18526,7 +18519,7 @@ yydefault: case 1133: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5843 +//line sql.y:5833 { yyLOCAL = yyDollar[1].subqueryUnion() } @@ -18534,7 +18527,7 @@ yydefault: case 1134: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5847 +//line sql.y:5837 { yyLOCAL = ListArg(yyDollar[1].str[2:]) markBindVariable(yylex, yyDollar[1].str[2:]) @@ -18543,7 +18536,7 @@ yydefault: case 1135: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Subquery -//line sql.y:5854 +//line sql.y:5844 { yyLOCAL = &Subquery{yyDollar[1].selStmtUnion()} } @@ -18551,14 +18544,14 @@ yydefault: case 1136: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Exprs -//line sql.y:5860 +//line sql.y:5850 { yyLOCAL = Exprs{yyDollar[1].exprUnion()} } yyVAL.union = yyLOCAL case 1137: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5864 +//line sql.y:5854 { yySLICE := (*Exprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].exprUnion()) @@ -18566,7 +18559,7 @@ yydefault: case 1138: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5874 +//line sql.y:5864 { yyLOCAL = &FuncExpr{Name: yyDollar[1].identifierCI, Exprs: yyDollar[3].selectExprsUnion()} } @@ -18574,7 +18567,7 @@ yydefault: case 1139: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5878 +//line sql.y:5868 { yyLOCAL = &FuncExpr{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCI, Exprs: yyDollar[5].selectExprsUnion()} } @@ -18582,7 +18575,7 @@ yydefault: case 1140: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5888 +//line sql.y:5878 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("left"), Exprs: yyDollar[3].selectExprsUnion()} } @@ -18590,7 +18583,7 @@ yydefault: case 1141: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5892 +//line sql.y:5882 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("right"), Exprs: yyDollar[3].selectExprsUnion()} } @@ -18598,7 +18591,7 @@ yydefault: case 1142: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5896 +//line sql.y:5886 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } @@ -18606,7 +18599,7 @@ yydefault: case 1143: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5900 +//line sql.y:5890 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } @@ -18614,7 +18607,7 @@ yydefault: case 1144: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5904 +//line sql.y:5894 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion()} } @@ -18622,7 +18615,7 @@ yydefault: case 1145: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5908 +//line sql.y:5898 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } @@ -18630,7 +18623,7 @@ yydefault: case 1146: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5912 +//line sql.y:5902 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion()} } @@ -18638,7 +18631,7 @@ yydefault: case 1147: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5916 +//line sql.y:5906 { yyLOCAL = &CaseExpr{Expr: yyDollar[2].exprUnion(), Whens: yyDollar[3].whensUnion(), Else: yyDollar[4].exprUnion()} } @@ -18646,7 +18639,7 @@ yydefault: case 1148: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5920 +//line sql.y:5910 { yyLOCAL = &ValuesFuncExpr{Name: yyDollar[3].colNameUnion()} } @@ -18654,7 +18647,7 @@ yydefault: case 1149: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:5924 +//line sql.y:5914 { yyLOCAL = &InsertExpr{Str: yyDollar[3].exprUnion(), Pos: yyDollar[5].exprUnion(), Len: yyDollar[7].exprUnion(), NewStr: yyDollar[9].exprUnion()} } @@ -18662,7 +18655,7 @@ yydefault: case 1150: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5928 +//line sql.y:5918 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI(yyDollar[1].str)} } @@ -18670,7 +18663,7 @@ yydefault: case 1151: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5939 +//line sql.y:5929 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("utc_date")} } @@ -18678,7 +18671,7 @@ yydefault: case 1152: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5943 +//line sql.y:5933 { yyLOCAL = yyDollar[1].exprUnion() } @@ -18686,7 +18679,7 @@ yydefault: case 1153: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5949 +//line sql.y:5939 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("current_date")} } @@ -18694,7 +18687,7 @@ yydefault: case 1154: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5953 +//line sql.y:5943 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("curdate")} } @@ -18702,7 +18695,7 @@ yydefault: case 1155: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5957 +//line sql.y:5947 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("utc_time"), Fsp: yyDollar[2].integerUnion()} } @@ -18710,7 +18703,7 @@ yydefault: case 1156: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5962 +//line sql.y:5952 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("curtime"), Fsp: yyDollar[2].integerUnion()} } @@ -18718,7 +18711,7 @@ yydefault: case 1157: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5967 +//line sql.y:5957 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("current_time"), Fsp: yyDollar[2].integerUnion()} } @@ -18726,7 +18719,7 @@ yydefault: case 1158: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5971 +//line sql.y:5961 { yyLOCAL = &CountStar{} } @@ -18734,7 +18727,7 @@ yydefault: case 1159: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5975 +//line sql.y:5965 { yyLOCAL = &Count{Distinct: yyDollar[3].booleanUnion(), Args: yyDollar[4].exprsUnion()} } @@ -18742,7 +18735,7 @@ yydefault: case 1160: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5979 +//line sql.y:5969 { yyLOCAL = &Max{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } @@ -18750,7 +18743,7 @@ yydefault: case 1161: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5983 +//line sql.y:5973 { yyLOCAL = &Min{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } @@ -18758,7 +18751,7 @@ yydefault: case 1162: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5987 +//line sql.y:5977 { yyLOCAL = &Sum{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } @@ -18766,7 +18759,7 @@ yydefault: case 1163: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5991 +//line sql.y:5981 { yyLOCAL = &Avg{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } @@ -18774,7 +18767,7 @@ yydefault: case 1164: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5995 +//line sql.y:5985 { yyLOCAL = &BitAnd{Arg: yyDollar[3].exprUnion()} } @@ -18782,7 +18775,7 @@ yydefault: case 1165: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5999 +//line sql.y:5989 { yyLOCAL = &BitOr{Arg: yyDollar[3].exprUnion()} } @@ -18790,7 +18783,7 @@ yydefault: case 1166: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6003 +//line sql.y:5993 { yyLOCAL = &BitXor{Arg: yyDollar[3].exprUnion()} } @@ -18798,7 +18791,7 @@ yydefault: case 1167: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6007 +//line sql.y:5997 { yyLOCAL = &Std{Arg: yyDollar[3].exprUnion()} } @@ -18806,7 +18799,7 @@ yydefault: case 1168: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6011 +//line sql.y:6001 { yyLOCAL = &StdDev{Arg: yyDollar[3].exprUnion()} } @@ -18814,7 +18807,7 @@ yydefault: case 1169: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6015 +//line sql.y:6005 { yyLOCAL = &StdPop{Arg: yyDollar[3].exprUnion()} } @@ -18822,7 +18815,7 @@ yydefault: case 1170: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6019 +//line sql.y:6009 { yyLOCAL = &StdSamp{Arg: yyDollar[3].exprUnion()} } @@ -18830,7 +18823,7 @@ yydefault: case 1171: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6023 +//line sql.y:6013 { yyLOCAL = &VarPop{Arg: yyDollar[3].exprUnion()} } @@ -18838,7 +18831,7 @@ yydefault: case 1172: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6027 +//line sql.y:6017 { yyLOCAL = &VarSamp{Arg: yyDollar[3].exprUnion()} } @@ -18846,7 +18839,7 @@ yydefault: case 1173: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6031 +//line sql.y:6021 { yyLOCAL = &Variance{Arg: yyDollar[3].exprUnion()} } @@ -18854,7 +18847,7 @@ yydefault: case 1174: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6035 +//line sql.y:6025 { yyLOCAL = &GroupConcatExpr{Distinct: yyDollar[3].booleanUnion(), Exprs: yyDollar[4].exprsUnion(), OrderBy: yyDollar[5].orderByUnion(), Separator: yyDollar[6].str, Limit: yyDollar[7].limitUnion()} } @@ -18862,7 +18855,7 @@ yydefault: case 1175: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6039 +//line sql.y:6029 { yyLOCAL = &AnyValue{Arg: yyDollar[3].exprUnion()} } @@ -18870,7 +18863,7 @@ yydefault: case 1176: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6043 +//line sql.y:6033 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprTimestampadd, Date: yyDollar[7].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } @@ -18878,7 +18871,7 @@ yydefault: case 1177: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6047 +//line sql.y:6037 { yyLOCAL = &TimestampDiffExpr{Unit: yyDollar[3].intervalTypeUnion(), Expr1: yyDollar[5].exprUnion(), Expr2: yyDollar[7].exprUnion()} } @@ -18886,7 +18879,7 @@ yydefault: case 1178: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6051 +//line sql.y:6041 { yyLOCAL = &ExtractFuncExpr{IntervalType: yyDollar[3].intervalTypeUnion(), Expr: yyDollar[5].exprUnion()} } @@ -18894,7 +18887,7 @@ yydefault: case 1179: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6055 +//line sql.y:6045 { yyLOCAL = &WeightStringFuncExpr{Expr: yyDollar[3].exprUnion(), As: yyDollar[4].convertTypeUnion()} } @@ -18902,7 +18895,7 @@ yydefault: case 1180: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6059 +//line sql.y:6049 { yyLOCAL = &JSONPrettyExpr{JSONVal: yyDollar[3].exprUnion()} } @@ -18910,7 +18903,7 @@ yydefault: case 1181: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6063 +//line sql.y:6053 { yyLOCAL = &JSONStorageFreeExpr{JSONVal: yyDollar[3].exprUnion()} } @@ -18918,7 +18911,7 @@ yydefault: case 1182: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6067 +//line sql.y:6057 { yyLOCAL = &JSONStorageSizeExpr{JSONVal: yyDollar[3].exprUnion()} } @@ -18926,7 +18919,7 @@ yydefault: case 1183: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6071 +//line sql.y:6061 { yyLOCAL = &TrimFuncExpr{TrimFuncType: LTrimType, Type: LeadingTrimType, StringArg: yyDollar[3].exprUnion()} } @@ -18934,7 +18927,7 @@ yydefault: case 1184: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6075 +//line sql.y:6065 { yyLOCAL = &TrimFuncExpr{TrimFuncType: RTrimType, Type: TrailingTrimType, StringArg: yyDollar[3].exprUnion()} } @@ -18942,7 +18935,7 @@ yydefault: case 1185: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:6079 +//line sql.y:6069 { yyLOCAL = &TrimFuncExpr{Type: yyDollar[3].trimTypeUnion(), TrimArg: yyDollar[4].exprUnion(), StringArg: yyDollar[6].exprUnion()} } @@ -18950,7 +18943,7 @@ yydefault: case 1186: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6083 +//line sql.y:6073 { yyLOCAL = &TrimFuncExpr{StringArg: yyDollar[3].exprUnion()} } @@ -18958,7 +18951,7 @@ yydefault: case 1187: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6087 +//line sql.y:6077 { yyLOCAL = &CharExpr{Exprs: yyDollar[3].exprsUnion()} } @@ -18966,7 +18959,7 @@ yydefault: case 1188: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6091 +//line sql.y:6081 { yyLOCAL = &CharExpr{Exprs: yyDollar[3].exprsUnion(), Charset: yyDollar[5].str} } @@ -18974,7 +18967,7 @@ yydefault: case 1189: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6095 +//line sql.y:6085 { yyLOCAL = &TrimFuncExpr{TrimArg: yyDollar[3].exprUnion(), StringArg: yyDollar[5].exprUnion()} } @@ -18982,7 +18975,7 @@ yydefault: case 1190: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6099 +//line sql.y:6089 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion()} } @@ -18990,7 +18983,7 @@ yydefault: case 1191: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6103 +//line sql.y:6093 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion(), Pos: yyDollar[7].exprUnion()} } @@ -18998,7 +18991,7 @@ yydefault: case 1192: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6107 +//line sql.y:6097 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion()} } @@ -19006,7 +18999,7 @@ yydefault: case 1193: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6111 +//line sql.y:6101 { yyLOCAL = &LockingFunc{Type: GetLock, Name: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } @@ -19014,7 +19007,7 @@ yydefault: case 1194: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6115 +//line sql.y:6105 { yyLOCAL = &LockingFunc{Type: IsFreeLock, Name: yyDollar[3].exprUnion()} } @@ -19022,7 +19015,7 @@ yydefault: case 1195: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6119 +//line sql.y:6109 { yyLOCAL = &LockingFunc{Type: IsUsedLock, Name: yyDollar[3].exprUnion()} } @@ -19030,7 +19023,7 @@ yydefault: case 1196: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:6123 +//line sql.y:6113 { yyLOCAL = &LockingFunc{Type: ReleaseAllLocks} } @@ -19038,7 +19031,7 @@ yydefault: case 1197: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6127 +//line sql.y:6117 { yyLOCAL = &LockingFunc{Type: ReleaseLock, Name: yyDollar[3].exprUnion()} } @@ -19046,7 +19039,7 @@ yydefault: case 1198: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6131 +//line sql.y:6121 { yyLOCAL = &JSONSchemaValidFuncExpr{Schema: yyDollar[3].exprUnion(), Document: yyDollar[5].exprUnion()} } @@ -19054,7 +19047,7 @@ yydefault: case 1199: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6135 +//line sql.y:6125 { yyLOCAL = &JSONSchemaValidationReportFuncExpr{Schema: yyDollar[3].exprUnion(), Document: yyDollar[5].exprUnion()} } @@ -19062,7 +19055,7 @@ yydefault: case 1200: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6139 +//line sql.y:6129 { yyLOCAL = &JSONArrayExpr{Params: yyDollar[3].exprsUnion()} } @@ -19070,7 +19063,7 @@ yydefault: case 1201: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6143 +//line sql.y:6133 { yyLOCAL = &GeomFormatExpr{FormatType: BinaryFormat, Geom: yyDollar[3].exprUnion()} } @@ -19078,7 +19071,7 @@ yydefault: case 1202: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6147 +//line sql.y:6137 { yyLOCAL = &GeomFormatExpr{FormatType: BinaryFormat, Geom: yyDollar[3].exprUnion(), AxisOrderOpt: yyDollar[5].exprUnion()} } @@ -19086,7 +19079,7 @@ yydefault: case 1203: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6151 +//line sql.y:6141 { yyLOCAL = &GeomFormatExpr{FormatType: TextFormat, Geom: yyDollar[3].exprUnion()} } @@ -19094,7 +19087,7 @@ yydefault: case 1204: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6155 +//line sql.y:6145 { yyLOCAL = &GeomFormatExpr{FormatType: TextFormat, Geom: yyDollar[3].exprUnion(), AxisOrderOpt: yyDollar[5].exprUnion()} } @@ -19102,7 +19095,7 @@ yydefault: case 1205: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6159 +//line sql.y:6149 { yyLOCAL = &GeomPropertyFuncExpr{Property: IsEmpty, Geom: yyDollar[3].exprUnion()} } @@ -19110,7 +19103,7 @@ yydefault: case 1206: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6163 +//line sql.y:6153 { yyLOCAL = &GeomPropertyFuncExpr{Property: IsSimple, Geom: yyDollar[3].exprUnion()} } @@ -19118,7 +19111,7 @@ yydefault: case 1207: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6167 +//line sql.y:6157 { yyLOCAL = &GeomPropertyFuncExpr{Property: Dimension, Geom: yyDollar[3].exprUnion()} } @@ -19126,7 +19119,7 @@ yydefault: case 1208: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6171 +//line sql.y:6161 { yyLOCAL = &GeomPropertyFuncExpr{Property: Envelope, Geom: yyDollar[3].exprUnion()} } @@ -19134,7 +19127,7 @@ yydefault: case 1209: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6175 +//line sql.y:6165 { yyLOCAL = &GeomPropertyFuncExpr{Property: GeometryType, Geom: yyDollar[3].exprUnion()} } @@ -19142,7 +19135,7 @@ yydefault: case 1210: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6179 +//line sql.y:6169 { yyLOCAL = &PointPropertyFuncExpr{Property: Latitude, Point: yyDollar[3].exprUnion()} } @@ -19150,7 +19143,7 @@ yydefault: case 1211: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6183 +//line sql.y:6173 { yyLOCAL = &PointPropertyFuncExpr{Property: Latitude, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } @@ -19158,7 +19151,7 @@ yydefault: case 1212: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6187 +//line sql.y:6177 { yyLOCAL = &PointPropertyFuncExpr{Property: Longitude, Point: yyDollar[3].exprUnion()} } @@ -19166,7 +19159,7 @@ yydefault: case 1213: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6191 +//line sql.y:6181 { yyLOCAL = &PointPropertyFuncExpr{Property: Longitude, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } @@ -19174,7 +19167,7 @@ yydefault: case 1214: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6195 +//line sql.y:6185 { yyLOCAL = &LinestrPropertyFuncExpr{Property: EndPoint, Linestring: yyDollar[3].exprUnion()} } @@ -19182,7 +19175,7 @@ yydefault: case 1215: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6199 +//line sql.y:6189 { yyLOCAL = &LinestrPropertyFuncExpr{Property: IsClosed, Linestring: yyDollar[3].exprUnion()} } @@ -19190,7 +19183,7 @@ yydefault: case 1216: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6203 +//line sql.y:6193 { yyLOCAL = &LinestrPropertyFuncExpr{Property: Length, Linestring: yyDollar[3].exprUnion()} } @@ -19198,7 +19191,7 @@ yydefault: case 1217: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6207 +//line sql.y:6197 { yyLOCAL = &LinestrPropertyFuncExpr{Property: Length, Linestring: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } @@ -19206,7 +19199,7 @@ yydefault: case 1218: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6211 +//line sql.y:6201 { yyLOCAL = &LinestrPropertyFuncExpr{Property: NumPoints, Linestring: yyDollar[3].exprUnion()} } @@ -19214,7 +19207,7 @@ yydefault: case 1219: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6215 +//line sql.y:6205 { yyLOCAL = &LinestrPropertyFuncExpr{Property: PointN, Linestring: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } @@ -19222,7 +19215,7 @@ yydefault: case 1220: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6219 +//line sql.y:6209 { yyLOCAL = &LinestrPropertyFuncExpr{Property: StartPoint, Linestring: yyDollar[3].exprUnion()} } @@ -19230,7 +19223,7 @@ yydefault: case 1221: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6223 +//line sql.y:6213 { yyLOCAL = &PointPropertyFuncExpr{Property: XCordinate, Point: yyDollar[3].exprUnion()} } @@ -19238,7 +19231,7 @@ yydefault: case 1222: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6227 +//line sql.y:6217 { yyLOCAL = &PointPropertyFuncExpr{Property: XCordinate, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } @@ -19246,7 +19239,7 @@ yydefault: case 1223: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6231 +//line sql.y:6221 { yyLOCAL = &PointPropertyFuncExpr{Property: YCordinate, Point: yyDollar[3].exprUnion()} } @@ -19254,7 +19247,7 @@ yydefault: case 1224: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6235 +//line sql.y:6225 { yyLOCAL = &PointPropertyFuncExpr{Property: YCordinate, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } @@ -19262,7 +19255,7 @@ yydefault: case 1225: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6239 +//line sql.y:6229 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion()} } @@ -19270,7 +19263,7 @@ yydefault: case 1226: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6243 +//line sql.y:6233 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19278,7 +19271,7 @@ yydefault: case 1227: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6247 +//line sql.y:6237 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19286,7 +19279,7 @@ yydefault: case 1228: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6251 +//line sql.y:6241 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion()} } @@ -19294,7 +19287,7 @@ yydefault: case 1229: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6255 +//line sql.y:6245 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19302,7 +19295,7 @@ yydefault: case 1230: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6259 +//line sql.y:6249 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19310,7 +19303,7 @@ yydefault: case 1231: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6263 +//line sql.y:6253 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion()} } @@ -19318,7 +19311,7 @@ yydefault: case 1232: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6267 +//line sql.y:6257 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19326,7 +19319,7 @@ yydefault: case 1233: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6271 +//line sql.y:6261 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19334,7 +19327,7 @@ yydefault: case 1234: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6275 +//line sql.y:6265 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion()} } @@ -19342,7 +19335,7 @@ yydefault: case 1235: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6279 +//line sql.y:6269 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19350,7 +19343,7 @@ yydefault: case 1236: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6283 +//line sql.y:6273 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19358,7 +19351,7 @@ yydefault: case 1237: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6287 +//line sql.y:6277 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion()} } @@ -19366,7 +19359,7 @@ yydefault: case 1238: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6291 +//line sql.y:6281 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19374,7 +19367,7 @@ yydefault: case 1239: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6295 +//line sql.y:6285 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19382,7 +19375,7 @@ yydefault: case 1240: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6299 +//line sql.y:6289 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion()} } @@ -19390,7 +19383,7 @@ yydefault: case 1241: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6303 +//line sql.y:6293 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19398,7 +19391,7 @@ yydefault: case 1242: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6307 +//line sql.y:6297 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19406,7 +19399,7 @@ yydefault: case 1243: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6311 +//line sql.y:6301 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion()} } @@ -19414,7 +19407,7 @@ yydefault: case 1244: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6315 +//line sql.y:6305 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19422,7 +19415,7 @@ yydefault: case 1245: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6319 +//line sql.y:6309 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19430,7 +19423,7 @@ yydefault: case 1246: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6323 +//line sql.y:6313 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion()} } @@ -19438,7 +19431,7 @@ yydefault: case 1247: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6327 +//line sql.y:6317 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19446,7 +19439,7 @@ yydefault: case 1248: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6331 +//line sql.y:6321 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19454,7 +19447,7 @@ yydefault: case 1249: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6335 +//line sql.y:6325 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19462,7 +19455,7 @@ yydefault: case 1250: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6339 +//line sql.y:6329 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19470,7 +19463,7 @@ yydefault: case 1251: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6343 +//line sql.y:6333 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19478,7 +19471,7 @@ yydefault: case 1252: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6347 +//line sql.y:6337 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19486,7 +19479,7 @@ yydefault: case 1253: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6351 +//line sql.y:6341 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19494,7 +19487,7 @@ yydefault: case 1254: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6355 +//line sql.y:6345 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19502,7 +19495,7 @@ yydefault: case 1255: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6359 +//line sql.y:6349 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19510,7 +19503,7 @@ yydefault: case 1256: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6363 +//line sql.y:6353 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19518,7 +19511,7 @@ yydefault: case 1257: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6367 +//line sql.y:6357 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19526,7 +19519,7 @@ yydefault: case 1258: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6371 +//line sql.y:6361 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19534,7 +19527,7 @@ yydefault: case 1259: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6375 +//line sql.y:6365 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19542,7 +19535,7 @@ yydefault: case 1260: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6379 +//line sql.y:6369 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19550,7 +19543,7 @@ yydefault: case 1261: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6383 +//line sql.y:6373 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19558,7 +19551,7 @@ yydefault: case 1262: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6387 +//line sql.y:6377 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19566,7 +19559,7 @@ yydefault: case 1263: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6391 +//line sql.y:6381 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19574,7 +19567,7 @@ yydefault: case 1264: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6395 +//line sql.y:6385 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19582,7 +19575,7 @@ yydefault: case 1265: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6399 +//line sql.y:6389 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19590,7 +19583,7 @@ yydefault: case 1266: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6403 +//line sql.y:6393 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19598,7 +19591,7 @@ yydefault: case 1267: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6407 +//line sql.y:6397 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19606,7 +19599,7 @@ yydefault: case 1268: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6411 +//line sql.y:6401 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19614,7 +19607,7 @@ yydefault: case 1269: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6415 +//line sql.y:6405 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19622,7 +19615,7 @@ yydefault: case 1270: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6419 +//line sql.y:6409 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion()} } @@ -19630,7 +19623,7 @@ yydefault: case 1271: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6423 +//line sql.y:6413 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } @@ -19638,7 +19631,7 @@ yydefault: case 1272: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6427 +//line sql.y:6417 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } @@ -19646,7 +19639,7 @@ yydefault: case 1273: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6431 +//line sql.y:6421 { yyLOCAL = &PolygonPropertyFuncExpr{Property: Area, Polygon: yyDollar[3].exprUnion()} } @@ -19654,7 +19647,7 @@ yydefault: case 1274: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6435 +//line sql.y:6425 { yyLOCAL = &PolygonPropertyFuncExpr{Property: Centroid, Polygon: yyDollar[3].exprUnion()} } @@ -19662,7 +19655,7 @@ yydefault: case 1275: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6439 +//line sql.y:6429 { yyLOCAL = &PolygonPropertyFuncExpr{Property: ExteriorRing, Polygon: yyDollar[3].exprUnion()} } @@ -19670,7 +19663,7 @@ yydefault: case 1276: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6443 +//line sql.y:6433 { yyLOCAL = &PolygonPropertyFuncExpr{Property: InteriorRingN, Polygon: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } @@ -19678,7 +19671,7 @@ yydefault: case 1277: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6447 +//line sql.y:6437 { yyLOCAL = &PolygonPropertyFuncExpr{Property: NumInteriorRings, Polygon: yyDollar[3].exprUnion()} } @@ -19686,7 +19679,7 @@ yydefault: case 1278: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6451 +//line sql.y:6441 { yyLOCAL = &GeomCollPropertyFuncExpr{Property: GeometryN, GeomColl: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } @@ -19694,7 +19687,7 @@ yydefault: case 1279: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6455 +//line sql.y:6445 { yyLOCAL = &GeomCollPropertyFuncExpr{Property: NumGeometries, GeomColl: yyDollar[3].exprUnion()} } @@ -19702,7 +19695,7 @@ yydefault: case 1280: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6459 +//line sql.y:6449 { yyLOCAL = &GeoHashFromLatLongExpr{Longitude: yyDollar[3].exprUnion(), Latitude: yyDollar[5].exprUnion(), MaxLength: yyDollar[7].exprUnion()} } @@ -19710,7 +19703,7 @@ yydefault: case 1281: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6463 +//line sql.y:6453 { yyLOCAL = &GeoHashFromPointExpr{Point: yyDollar[3].exprUnion(), MaxLength: yyDollar[5].exprUnion()} } @@ -19718,7 +19711,7 @@ yydefault: case 1282: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6467 +//line sql.y:6457 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: LatitudeFromHash, GeoHash: yyDollar[3].exprUnion()} } @@ -19726,7 +19719,7 @@ yydefault: case 1283: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6471 +//line sql.y:6461 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: LongitudeFromHash, GeoHash: yyDollar[3].exprUnion()} } @@ -19734,7 +19727,7 @@ yydefault: case 1284: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6475 +//line sql.y:6465 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: PointFromHash, GeoHash: yyDollar[3].exprUnion(), SridOpt: yyDollar[5].exprUnion()} } @@ -19742,7 +19735,7 @@ yydefault: case 1285: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6479 +//line sql.y:6469 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion()} } @@ -19750,7 +19743,7 @@ yydefault: case 1286: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6483 +//line sql.y:6473 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion(), HigherDimHandlerOpt: yyDollar[5].exprUnion()} } @@ -19758,7 +19751,7 @@ yydefault: case 1287: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6487 +//line sql.y:6477 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion(), HigherDimHandlerOpt: yyDollar[5].exprUnion(), Srid: yyDollar[7].exprUnion()} } @@ -19766,7 +19759,7 @@ yydefault: case 1288: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6491 +//line sql.y:6481 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion()} } @@ -19774,7 +19767,7 @@ yydefault: case 1289: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6495 +//line sql.y:6485 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion(), MaxDecimalDigits: yyDollar[5].exprUnion()} } @@ -19782,7 +19775,7 @@ yydefault: case 1290: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6499 +//line sql.y:6489 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion(), MaxDecimalDigits: yyDollar[5].exprUnion(), Bitmask: yyDollar[7].exprUnion()} } @@ -19790,7 +19783,7 @@ yydefault: case 1291: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6503 +//line sql.y:6493 { yyLOCAL = &JSONObjectExpr{Params: yyDollar[3].jsonObjectParamsUnion()} } @@ -19798,7 +19791,7 @@ yydefault: case 1292: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6507 +//line sql.y:6497 { yyLOCAL = &JSONQuoteExpr{StringArg: yyDollar[3].exprUnion()} } @@ -19806,7 +19799,7 @@ yydefault: case 1293: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6511 +//line sql.y:6501 { yyLOCAL = &JSONContainsExpr{Target: yyDollar[3].exprUnion(), Candidate: yyDollar[5].exprsUnion()[0], PathList: yyDollar[5].exprsUnion()[1:]} } @@ -19814,7 +19807,7 @@ yydefault: case 1294: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6515 +//line sql.y:6505 { yyLOCAL = &JSONContainsPathExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), PathList: yyDollar[7].exprsUnion()} } @@ -19822,7 +19815,7 @@ yydefault: case 1295: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6519 +//line sql.y:6509 { yyLOCAL = &JSONExtractExpr{JSONDoc: yyDollar[3].exprUnion(), PathList: yyDollar[5].exprsUnion()} } @@ -19830,7 +19823,7 @@ yydefault: case 1296: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6523 +//line sql.y:6513 { yyLOCAL = &JSONKeysExpr{JSONDoc: yyDollar[3].exprUnion()} } @@ -19838,7 +19831,7 @@ yydefault: case 1297: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6527 +//line sql.y:6517 { yyLOCAL = &JSONKeysExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion()} } @@ -19846,7 +19839,7 @@ yydefault: case 1298: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6531 +//line sql.y:6521 { yyLOCAL = &JSONOverlapsExpr{JSONDoc1: yyDollar[3].exprUnion(), JSONDoc2: yyDollar[5].exprUnion()} } @@ -19854,7 +19847,7 @@ yydefault: case 1299: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6535 +//line sql.y:6525 { yyLOCAL = &JSONSearchExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), SearchStr: yyDollar[7].exprUnion()} } @@ -19862,7 +19855,7 @@ yydefault: case 1300: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6539 +//line sql.y:6529 { yyLOCAL = &JSONSearchExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), SearchStr: yyDollar[7].exprUnion(), EscapeChar: yyDollar[9].exprsUnion()[0], PathList: yyDollar[9].exprsUnion()[1:]} } @@ -19870,7 +19863,7 @@ yydefault: case 1301: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:6543 +//line sql.y:6533 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion()} } @@ -19878,7 +19871,7 @@ yydefault: case 1302: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6547 +//line sql.y:6537 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion()} } @@ -19886,7 +19879,7 @@ yydefault: case 1303: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6551 +//line sql.y:6541 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), ErrorOnResponse: yyDollar[7].jtOnResponseUnion()} } @@ -19894,7 +19887,7 @@ yydefault: case 1304: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6555 +//line sql.y:6545 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion(), ErrorOnResponse: yyDollar[8].jtOnResponseUnion()} } @@ -19902,7 +19895,7 @@ yydefault: case 1305: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6559 +//line sql.y:6549 { yyLOCAL = &JSONAttributesExpr{Type: DepthAttributeType, JSONDoc: yyDollar[3].exprUnion()} } @@ -19910,7 +19903,7 @@ yydefault: case 1306: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6563 +//line sql.y:6553 { yyLOCAL = &JSONAttributesExpr{Type: ValidAttributeType, JSONDoc: yyDollar[3].exprUnion()} } @@ -19918,7 +19911,7 @@ yydefault: case 1307: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6567 +//line sql.y:6557 { yyLOCAL = &JSONAttributesExpr{Type: TypeAttributeType, JSONDoc: yyDollar[3].exprUnion()} } @@ -19926,7 +19919,7 @@ yydefault: case 1308: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6571 +//line sql.y:6561 { yyLOCAL = &JSONAttributesExpr{Type: LengthAttributeType, JSONDoc: yyDollar[3].exprUnion()} } @@ -19934,7 +19927,7 @@ yydefault: case 1309: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6575 +//line sql.y:6565 { yyLOCAL = &JSONAttributesExpr{Type: LengthAttributeType, JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion()} } @@ -19942,7 +19935,7 @@ yydefault: case 1310: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6579 +//line sql.y:6569 { yyLOCAL = &JSONValueModifierExpr{Type: JSONArrayAppendType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } @@ -19950,7 +19943,7 @@ yydefault: case 1311: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6583 +//line sql.y:6573 { yyLOCAL = &JSONValueModifierExpr{Type: JSONArrayInsertType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } @@ -19958,7 +19951,7 @@ yydefault: case 1312: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6587 +//line sql.y:6577 { yyLOCAL = &JSONValueModifierExpr{Type: JSONInsertType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } @@ -19966,7 +19959,7 @@ yydefault: case 1313: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6591 +//line sql.y:6581 { yyLOCAL = &JSONValueModifierExpr{Type: JSONReplaceType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } @@ -19974,7 +19967,7 @@ yydefault: case 1314: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6595 +//line sql.y:6585 { yyLOCAL = &JSONValueModifierExpr{Type: JSONSetType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } @@ -19982,7 +19975,7 @@ yydefault: case 1315: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6599 +//line sql.y:6589 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergeType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } @@ -19990,7 +19983,7 @@ yydefault: case 1316: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6603 +//line sql.y:6593 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergePatchType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } @@ -19998,7 +19991,7 @@ yydefault: case 1317: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6607 +//line sql.y:6597 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergePreserveType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } @@ -20006,7 +19999,7 @@ yydefault: case 1318: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6611 +//line sql.y:6601 { yyLOCAL = &JSONRemoveExpr{JSONDoc: yyDollar[3].exprUnion(), PathList: yyDollar[5].exprsUnion()} } @@ -20014,7 +20007,7 @@ yydefault: case 1319: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6615 +//line sql.y:6605 { yyLOCAL = &JSONUnquoteExpr{JSONValue: yyDollar[3].exprUnion()} } @@ -20022,7 +20015,7 @@ yydefault: case 1320: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6619 +//line sql.y:6609 { yyLOCAL = &MultiPolygonExpr{PolygonParams: yyDollar[3].exprsUnion()} } @@ -20030,7 +20023,7 @@ yydefault: case 1321: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6623 +//line sql.y:6613 { yyLOCAL = &MultiPointExpr{PointParams: yyDollar[3].exprsUnion()} } @@ -20038,7 +20031,7 @@ yydefault: case 1322: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6627 +//line sql.y:6617 { yyLOCAL = &MultiLinestringExpr{LinestringParams: yyDollar[3].exprsUnion()} } @@ -20046,7 +20039,7 @@ yydefault: case 1323: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6631 +//line sql.y:6621 { yyLOCAL = &PolygonExpr{LinestringParams: yyDollar[3].exprsUnion()} } @@ -20054,7 +20047,7 @@ yydefault: case 1324: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6635 +//line sql.y:6625 { yyLOCAL = &LineStringExpr{PointParams: yyDollar[3].exprsUnion()} } @@ -20062,7 +20055,7 @@ yydefault: case 1325: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6639 +//line sql.y:6629 { yyLOCAL = &PointExpr{XCordinate: yyDollar[3].exprUnion(), YCordinate: yyDollar[5].exprUnion()} } @@ -20070,7 +20063,7 @@ yydefault: case 1326: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6643 +//line sql.y:6633 { yyLOCAL = &ArgumentLessWindowExpr{Type: yyDollar[1].argumentLessWindowExprTypeUnion(), OverClause: yyDollar[4].overClauseUnion()} } @@ -20078,7 +20071,7 @@ yydefault: case 1327: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6647 +//line sql.y:6637 { yyLOCAL = &FirstOrLastValueExpr{Type: yyDollar[1].firstOrLastValueExprTypeUnion(), Expr: yyDollar[3].exprUnion(), NullTreatmentClause: yyDollar[5].nullTreatmentClauseUnion(), OverClause: yyDollar[6].overClauseUnion()} } @@ -20086,7 +20079,7 @@ yydefault: case 1328: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6651 +//line sql.y:6641 { yyLOCAL = &NtileExpr{N: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } @@ -20094,7 +20087,7 @@ yydefault: case 1329: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6655 +//line sql.y:6645 { yyLOCAL = &NTHValueExpr{Expr: yyDollar[3].exprUnion(), N: yyDollar[5].exprUnion(), FromFirstLastClause: yyDollar[7].fromFirstLastClauseUnion(), NullTreatmentClause: yyDollar[8].nullTreatmentClauseUnion(), OverClause: yyDollar[9].overClauseUnion()} } @@ -20102,7 +20095,7 @@ yydefault: case 1330: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6659 +//line sql.y:6649 { yyLOCAL = &LagLeadExpr{Type: yyDollar[1].lagLeadExprTypeUnion(), Expr: yyDollar[3].exprUnion(), NullTreatmentClause: yyDollar[5].nullTreatmentClauseUnion(), OverClause: yyDollar[6].overClauseUnion()} } @@ -20110,7 +20103,7 @@ yydefault: case 1331: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6663 +//line sql.y:6653 { yyLOCAL = &LagLeadExpr{Type: yyDollar[1].lagLeadExprTypeUnion(), Expr: yyDollar[3].exprUnion(), N: yyDollar[5].exprUnion(), Default: yyDollar[6].exprUnion(), NullTreatmentClause: yyDollar[8].nullTreatmentClauseUnion(), OverClause: yyDollar[9].overClauseUnion()} } @@ -20118,7 +20111,7 @@ yydefault: case 1332: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6667 +//line sql.y:6657 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprAdddate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } @@ -20126,7 +20119,7 @@ yydefault: case 1333: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6671 +//line sql.y:6661 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprAdddate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: IntervalNone} } @@ -20134,7 +20127,7 @@ yydefault: case 1334: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6675 +//line sql.y:6665 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprDateAdd, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } @@ -20142,7 +20135,7 @@ yydefault: case 1335: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6679 +//line sql.y:6669 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprDateSub, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } @@ -20150,7 +20143,7 @@ yydefault: case 1336: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6683 +//line sql.y:6673 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprSubdate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } @@ -20158,7 +20151,7 @@ yydefault: case 1337: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6687 +//line sql.y:6677 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprSubdate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: IntervalNone} } @@ -20166,7 +20159,7 @@ yydefault: case 1342: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6697 +//line sql.y:6687 { yyLOCAL = yyDollar[1].exprUnion() } @@ -20174,7 +20167,7 @@ yydefault: case 1343: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6701 +//line sql.y:6691 { yyLOCAL = NewIntLiteral(yyDollar[1].str) } @@ -20182,7 +20175,7 @@ yydefault: case 1344: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6705 +//line sql.y:6695 { yyLOCAL = yyDollar[1].variableUnion() } @@ -20190,7 +20183,7 @@ yydefault: case 1345: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6709 +//line sql.y:6699 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } @@ -20198,7 +20191,7 @@ yydefault: case 1346: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:6714 +//line sql.y:6704 { yyLOCAL = nil } @@ -20206,7 +20199,7 @@ yydefault: case 1347: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6718 +//line sql.y:6708 { yyLOCAL = yyDollar[2].exprUnion() } @@ -20214,7 +20207,7 @@ yydefault: case 1348: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6724 +//line sql.y:6714 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } @@ -20222,7 +20215,7 @@ yydefault: case 1349: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6728 +//line sql.y:6718 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion()} } @@ -20230,7 +20223,7 @@ yydefault: case 1350: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6732 +//line sql.y:6722 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion()} } @@ -20238,7 +20231,7 @@ yydefault: case 1351: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6736 +//line sql.y:6726 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), ReturnOption: yyDollar[11].exprUnion()} } @@ -20246,7 +20239,7 @@ yydefault: case 1352: yyDollar = yyS[yypt-14 : yypt+1] var yyLOCAL Expr -//line sql.y:6740 +//line sql.y:6730 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), ReturnOption: yyDollar[11].exprUnion(), MatchType: yyDollar[13].exprUnion()} @@ -20255,7 +20248,7 @@ yydefault: case 1353: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6745 +//line sql.y:6735 { yyLOCAL = &RegexpLikeExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } @@ -20263,7 +20256,7 @@ yydefault: case 1354: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6749 +//line sql.y:6739 { yyLOCAL = &RegexpLikeExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), MatchType: yyDollar[7].exprUnion()} } @@ -20271,7 +20264,7 @@ yydefault: case 1355: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6753 +//line sql.y:6743 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion()} } @@ -20279,7 +20272,7 @@ yydefault: case 1356: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6757 +//line sql.y:6747 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion()} } @@ -20287,7 +20280,7 @@ yydefault: case 1357: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6761 +//line sql.y:6751 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion(), Occurrence: yyDollar[11].exprUnion()} } @@ -20295,7 +20288,7 @@ yydefault: case 1358: yyDollar = yyS[yypt-14 : yypt+1] var yyLOCAL Expr -//line sql.y:6765 +//line sql.y:6755 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion(), Occurrence: yyDollar[11].exprUnion(), MatchType: yyDollar[13].exprUnion()} @@ -20304,7 +20297,7 @@ yydefault: case 1359: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6770 +//line sql.y:6760 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } @@ -20312,7 +20305,7 @@ yydefault: case 1360: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6774 +//line sql.y:6764 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion()} } @@ -20320,7 +20313,7 @@ yydefault: case 1361: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6778 +//line sql.y:6768 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion()} } @@ -20328,7 +20321,7 @@ yydefault: case 1362: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6782 +//line sql.y:6772 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), MatchType: yyDollar[11].exprUnion()} @@ -20337,7 +20330,7 @@ yydefault: case 1363: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6789 +//line sql.y:6779 { yyLOCAL = &ExtractValueExpr{Fragment: yyDollar[3].exprUnion(), XPathExpr: yyDollar[5].exprUnion()} } @@ -20345,7 +20338,7 @@ yydefault: case 1364: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6793 +//line sql.y:6783 { yyLOCAL = &UpdateXMLExpr{Target: yyDollar[3].exprUnion(), XPathExpr: yyDollar[5].exprUnion(), NewXML: yyDollar[7].exprUnion()} } @@ -20353,7 +20346,7 @@ yydefault: case 1365: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6799 +//line sql.y:6789 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: FormatBytesType, Argument: yyDollar[3].exprUnion()} } @@ -20361,7 +20354,7 @@ yydefault: case 1366: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6803 +//line sql.y:6793 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: FormatPicoTimeType, Argument: yyDollar[3].exprUnion()} } @@ -20369,7 +20362,7 @@ yydefault: case 1367: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:6807 +//line sql.y:6797 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: PsCurrentThreadIDType} } @@ -20377,7 +20370,7 @@ yydefault: case 1368: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6811 +//line sql.y:6801 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: PsThreadIDType, Argument: yyDollar[3].exprUnion()} } @@ -20385,7 +20378,7 @@ yydefault: case 1369: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6817 +//line sql.y:6807 { yyLOCAL = >IDFuncExpr{Type: GTIDSubsetType, Set1: yyDollar[3].exprUnion(), Set2: yyDollar[5].exprUnion()} } @@ -20393,7 +20386,7 @@ yydefault: case 1370: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6821 +//line sql.y:6811 { yyLOCAL = >IDFuncExpr{Type: GTIDSubtractType, Set1: yyDollar[3].exprUnion(), Set2: yyDollar[5].exprUnion()} } @@ -20401,7 +20394,7 @@ yydefault: case 1371: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6825 +//line sql.y:6815 { yyLOCAL = >IDFuncExpr{Type: WaitForExecutedGTIDSetType, Set1: yyDollar[3].exprUnion()} } @@ -20409,7 +20402,7 @@ yydefault: case 1372: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6829 +//line sql.y:6819 { yyLOCAL = >IDFuncExpr{Type: WaitForExecutedGTIDSetType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } @@ -20417,7 +20410,7 @@ yydefault: case 1373: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6833 +//line sql.y:6823 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion()} } @@ -20425,7 +20418,7 @@ yydefault: case 1374: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6837 +//line sql.y:6827 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } @@ -20433,7 +20426,7 @@ yydefault: case 1375: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6841 +//line sql.y:6831 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion(), Channel: yyDollar[7].exprUnion()} } @@ -20441,7 +20434,7 @@ yydefault: case 1376: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:6846 +//line sql.y:6836 { yyLOCAL = nil } @@ -20449,7 +20442,7 @@ yydefault: case 1377: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:6850 +//line sql.y:6840 { yyLOCAL = yyDollar[2].convertTypeUnion() } @@ -20457,7 +20450,7 @@ yydefault: case 1378: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6856 +//line sql.y:6846 { yyLOCAL = IntervalDayHour } @@ -20465,7 +20458,7 @@ yydefault: case 1379: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6860 +//line sql.y:6850 { yyLOCAL = IntervalDayMicrosecond } @@ -20473,7 +20466,7 @@ yydefault: case 1380: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6864 +//line sql.y:6854 { yyLOCAL = IntervalDayMinute } @@ -20481,7 +20474,7 @@ yydefault: case 1381: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6868 +//line sql.y:6858 { yyLOCAL = IntervalDaySecond } @@ -20489,7 +20482,7 @@ yydefault: case 1382: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6872 +//line sql.y:6862 { yyLOCAL = IntervalHourMicrosecond } @@ -20497,7 +20490,7 @@ yydefault: case 1383: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6876 +//line sql.y:6866 { yyLOCAL = IntervalHourMinute } @@ -20505,7 +20498,7 @@ yydefault: case 1384: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6880 +//line sql.y:6870 { yyLOCAL = IntervalHourSecond } @@ -20513,7 +20506,7 @@ yydefault: case 1385: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6884 +//line sql.y:6874 { yyLOCAL = IntervalMinuteMicrosecond } @@ -20521,7 +20514,7 @@ yydefault: case 1386: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6888 +//line sql.y:6878 { yyLOCAL = IntervalMinuteSecond } @@ -20529,7 +20522,7 @@ yydefault: case 1387: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6892 +//line sql.y:6882 { yyLOCAL = IntervalSecondMicrosecond } @@ -20537,7 +20530,7 @@ yydefault: case 1388: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6896 +//line sql.y:6886 { yyLOCAL = IntervalYearMonth } @@ -20545,7 +20538,7 @@ yydefault: case 1389: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6900 +//line sql.y:6890 { yyLOCAL = IntervalDay } @@ -20553,7 +20546,7 @@ yydefault: case 1390: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6904 +//line sql.y:6894 { yyLOCAL = IntervalWeek } @@ -20561,7 +20554,7 @@ yydefault: case 1391: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6908 +//line sql.y:6898 { yyLOCAL = IntervalHour } @@ -20569,7 +20562,7 @@ yydefault: case 1392: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6912 +//line sql.y:6902 { yyLOCAL = IntervalMinute } @@ -20577,7 +20570,7 @@ yydefault: case 1393: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6916 +//line sql.y:6906 { yyLOCAL = IntervalMonth } @@ -20585,7 +20578,7 @@ yydefault: case 1394: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6920 +//line sql.y:6910 { yyLOCAL = IntervalQuarter } @@ -20593,7 +20586,7 @@ yydefault: case 1395: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6924 +//line sql.y:6914 { yyLOCAL = IntervalSecond } @@ -20601,7 +20594,7 @@ yydefault: case 1396: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6928 +//line sql.y:6918 { yyLOCAL = IntervalMicrosecond } @@ -20609,7 +20602,7 @@ yydefault: case 1397: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6932 +//line sql.y:6922 { yyLOCAL = IntervalYear } @@ -20617,7 +20610,7 @@ yydefault: case 1398: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6938 +//line sql.y:6928 { yyLOCAL = IntervalDay } @@ -20625,7 +20618,7 @@ yydefault: case 1399: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6942 +//line sql.y:6932 { yyLOCAL = IntervalWeek } @@ -20633,7 +20626,7 @@ yydefault: case 1400: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6946 +//line sql.y:6936 { yyLOCAL = IntervalHour } @@ -20641,7 +20634,7 @@ yydefault: case 1401: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6950 +//line sql.y:6940 { yyLOCAL = IntervalMinute } @@ -20649,7 +20642,7 @@ yydefault: case 1402: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6954 +//line sql.y:6944 { yyLOCAL = IntervalMonth } @@ -20657,7 +20650,7 @@ yydefault: case 1403: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6958 +//line sql.y:6948 { yyLOCAL = IntervalQuarter } @@ -20665,7 +20658,7 @@ yydefault: case 1404: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6962 +//line sql.y:6952 { yyLOCAL = IntervalSecond } @@ -20673,7 +20666,7 @@ yydefault: case 1405: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6966 +//line sql.y:6956 { yyLOCAL = IntervalMicrosecond } @@ -20681,7 +20674,7 @@ yydefault: case 1406: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6970 +//line sql.y:6960 { yyLOCAL = IntervalYear } @@ -20689,7 +20682,7 @@ yydefault: case 1407: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6974 +//line sql.y:6964 { yyLOCAL = IntervalDay } @@ -20697,7 +20690,7 @@ yydefault: case 1408: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6978 +//line sql.y:6968 { yyLOCAL = IntervalWeek } @@ -20705,7 +20698,7 @@ yydefault: case 1409: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6982 +//line sql.y:6972 { yyLOCAL = IntervalHour } @@ -20713,7 +20706,7 @@ yydefault: case 1410: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6986 +//line sql.y:6976 { yyLOCAL = IntervalMinute } @@ -20721,7 +20714,7 @@ yydefault: case 1411: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6990 +//line sql.y:6980 { yyLOCAL = IntervalMonth } @@ -20729,7 +20722,7 @@ yydefault: case 1412: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6994 +//line sql.y:6984 { yyLOCAL = IntervalQuarter } @@ -20737,7 +20730,7 @@ yydefault: case 1413: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6998 +//line sql.y:6988 { yyLOCAL = IntervalSecond } @@ -20745,7 +20738,7 @@ yydefault: case 1414: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7002 +//line sql.y:6992 { yyLOCAL = IntervalMicrosecond } @@ -20753,7 +20746,7 @@ yydefault: case 1415: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7006 +//line sql.y:6996 { yyLOCAL = IntervalYear } @@ -20761,7 +20754,7 @@ yydefault: case 1418: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:7016 +//line sql.y:7006 { yyLOCAL = 0 } @@ -20769,7 +20762,7 @@ yydefault: case 1419: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL int -//line sql.y:7020 +//line sql.y:7010 { yyLOCAL = 0 } @@ -20777,7 +20770,7 @@ yydefault: case 1420: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:7024 +//line sql.y:7014 { yyLOCAL = convertStringToInt(yyDollar[2].str) } @@ -20785,7 +20778,7 @@ yydefault: case 1421: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7034 +//line sql.y:7024 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("if"), Exprs: yyDollar[3].selectExprsUnion()} } @@ -20793,7 +20786,7 @@ yydefault: case 1422: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7038 +//line sql.y:7028 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("database"), Exprs: yyDollar[3].selectExprsUnion()} } @@ -20801,7 +20794,7 @@ yydefault: case 1423: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7042 +//line sql.y:7032 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("schema"), Exprs: yyDollar[3].selectExprsUnion()} } @@ -20809,7 +20802,7 @@ yydefault: case 1424: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7046 +//line sql.y:7036 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("mod"), Exprs: yyDollar[3].selectExprsUnion()} } @@ -20817,7 +20810,7 @@ yydefault: case 1425: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7050 +//line sql.y:7040 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("replace"), Exprs: yyDollar[3].selectExprsUnion()} } @@ -20825,7 +20818,7 @@ yydefault: case 1426: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7056 +//line sql.y:7046 { yyLOCAL = NoOption } @@ -20833,7 +20826,7 @@ yydefault: case 1427: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7060 +//line sql.y:7050 { yyLOCAL = BooleanModeOpt } @@ -20841,7 +20834,7 @@ yydefault: case 1428: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7064 +//line sql.y:7054 { yyLOCAL = NaturalLanguageModeOpt } @@ -20849,7 +20842,7 @@ yydefault: case 1429: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7068 +//line sql.y:7058 { yyLOCAL = NaturalLanguageModeWithQueryExpansionOpt } @@ -20857,33 +20850,33 @@ yydefault: case 1430: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7072 +//line sql.y:7062 { yyLOCAL = QueryExpansionOpt } yyVAL.union = yyLOCAL case 1431: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7078 +//line sql.y:7068 { yyVAL.str = string(yyDollar[1].identifierCI.String()) } case 1432: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7082 +//line sql.y:7072 { yyVAL.str = string(yyDollar[1].str) } case 1433: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7086 +//line sql.y:7076 { yyVAL.str = string(yyDollar[1].str) } case 1434: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7092 +//line sql.y:7082 { yyLOCAL = nil } @@ -20891,39 +20884,39 @@ yydefault: case 1435: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7096 +//line sql.y:7086 { - yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: NewIntLiteral(yyDollar[4].str)} + yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: ptr.Of(convertStringToInt(yyDollar[4].str))} } yyVAL.union = yyLOCAL case 1436: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7100 +//line sql.y:7090 { - yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: NewIntLiteral(yyDollar[4].str)} + yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: ptr.Of(convertStringToInt(yyDollar[4].str))} } yyVAL.union = yyLOCAL case 1437: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7106 +//line sql.y:7096 { - yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL case 1438: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7110 +//line sql.y:7100 { - yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion(), Charset: yyDollar[3].columnCharset} + yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion(), Charset: yyDollar[3].columnCharset} } yyVAL.union = yyLOCAL case 1439: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7114 +//line sql.y:7104 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -20931,15 +20924,15 @@ yydefault: case 1440: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7118 +//line sql.y:7108 { - yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL case 1441: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7122 +//line sql.y:7112 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} yyLOCAL.Length = yyDollar[2].LengthScaleOption.Length @@ -20949,7 +20942,7 @@ yydefault: case 1442: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7128 +//line sql.y:7118 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -20957,15 +20950,15 @@ yydefault: case 1443: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7132 +//line sql.y:7122 { - yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL case 1444: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7136 +//line sql.y:7126 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -20973,7 +20966,7 @@ yydefault: case 1445: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7140 +//line sql.y:7130 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -20981,15 +20974,15 @@ yydefault: case 1446: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7144 +//line sql.y:7134 { - yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL case 1447: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7148 +//line sql.y:7138 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -20997,7 +20990,7 @@ yydefault: case 1448: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7152 +//line sql.y:7142 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -21005,15 +20998,15 @@ yydefault: case 1449: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7156 +//line sql.y:7146 { - yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].literalUnion()} + yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL case 1450: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7160 +//line sql.y:7150 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -21021,7 +21014,7 @@ yydefault: case 1451: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7164 +//line sql.y:7154 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } @@ -21029,7 +21022,7 @@ yydefault: case 1452: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7170 +//line sql.y:7160 { yyLOCAL = false } @@ -21037,7 +21030,7 @@ yydefault: case 1453: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:7174 +//line sql.y:7164 { yyLOCAL = true } @@ -21045,7 +21038,7 @@ yydefault: case 1454: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7179 +//line sql.y:7169 { yyLOCAL = nil } @@ -21053,34 +21046,34 @@ yydefault: case 1455: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7183 +//line sql.y:7173 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL case 1456: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7188 +//line sql.y:7178 { yyVAL.str = string("") } case 1457: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7192 +//line sql.y:7182 { yyVAL.str = encodeSQLString(yyDollar[2].str) } case 1458: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*When -//line sql.y:7198 +//line sql.y:7188 { yyLOCAL = []*When{yyDollar[1].whenUnion()} } yyVAL.union = yyLOCAL case 1459: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7202 +//line sql.y:7192 { yySLICE := (*[]*When)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].whenUnion()) @@ -21088,7 +21081,7 @@ yydefault: case 1460: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *When -//line sql.y:7208 +//line sql.y:7198 { yyLOCAL = &When{Cond: yyDollar[2].exprUnion(), Val: yyDollar[4].exprUnion()} } @@ -21096,7 +21089,7 @@ yydefault: case 1461: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7213 +//line sql.y:7203 { yyLOCAL = nil } @@ -21104,7 +21097,7 @@ yydefault: case 1462: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7217 +//line sql.y:7207 { yyLOCAL = yyDollar[2].exprUnion() } @@ -21112,7 +21105,7 @@ yydefault: case 1463: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ColName -//line sql.y:7223 +//line sql.y:7213 { yyLOCAL = &ColName{Name: yyDollar[1].identifierCI} } @@ -21120,7 +21113,7 @@ yydefault: case 1464: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ColName -//line sql.y:7227 +//line sql.y:7217 { yyLOCAL = &ColName{Name: NewIdentifierCI(string(yyDollar[1].str))} } @@ -21128,7 +21121,7 @@ yydefault: case 1465: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColName -//line sql.y:7231 +//line sql.y:7221 { yyLOCAL = &ColName{Qualifier: TableName{Name: yyDollar[1].identifierCS}, Name: yyDollar[3].identifierCI} } @@ -21136,7 +21129,7 @@ yydefault: case 1466: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ColName -//line sql.y:7235 +//line sql.y:7225 { yyLOCAL = &ColName{Qualifier: TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS}, Name: yyDollar[5].identifierCI} } @@ -21144,7 +21137,7 @@ yydefault: case 1467: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7241 +//line sql.y:7231 { yyLOCAL = yyDollar[1].colNameUnion() } @@ -21152,7 +21145,7 @@ yydefault: case 1468: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7245 +//line sql.y:7235 { yyLOCAL = &Offset{V: convertStringToInt(yyDollar[1].str)} } @@ -21160,7 +21153,7 @@ yydefault: case 1469: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7251 +//line sql.y:7241 { // TODO(sougou): Deprecate this construct. if yyDollar[1].identifierCI.Lowered() != "value" { @@ -21173,7 +21166,7 @@ yydefault: case 1470: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7260 +//line sql.y:7250 { yyLOCAL = NewIntLiteral(yyDollar[1].str) } @@ -21181,7 +21174,7 @@ yydefault: case 1471: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7264 +//line sql.y:7254 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } @@ -21189,7 +21182,7 @@ yydefault: case 1472: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:7269 +//line sql.y:7259 { yyLOCAL = nil } @@ -21197,7 +21190,7 @@ yydefault: case 1473: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Exprs -//line sql.y:7273 +//line sql.y:7263 { yyLOCAL = yyDollar[3].exprsUnion() } @@ -21205,7 +21198,7 @@ yydefault: case 1474: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7278 +//line sql.y:7268 { yyLOCAL = nil } @@ -21213,7 +21206,7 @@ yydefault: case 1475: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7282 +//line sql.y:7272 { yyLOCAL = yyDollar[2].exprUnion() } @@ -21221,7 +21214,7 @@ yydefault: case 1476: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *NamedWindow -//line sql.y:7288 +//line sql.y:7278 { yyLOCAL = &NamedWindow{yyDollar[2].windowDefinitionsUnion()} } @@ -21229,14 +21222,14 @@ yydefault: case 1477: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7294 +//line sql.y:7284 { yyLOCAL = NamedWindows{yyDollar[1].namedWindowUnion()} } yyVAL.union = yyLOCAL case 1478: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7298 +//line sql.y:7288 { yySLICE := (*NamedWindows)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].namedWindowUnion()) @@ -21244,7 +21237,7 @@ yydefault: case 1479: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7303 +//line sql.y:7293 { yyLOCAL = nil } @@ -21252,7 +21245,7 @@ yydefault: case 1480: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7307 +//line sql.y:7297 { yyLOCAL = yyDollar[1].namedWindowsUnion() } @@ -21260,7 +21253,7 @@ yydefault: case 1481: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7312 +//line sql.y:7302 { yyLOCAL = nil } @@ -21268,7 +21261,7 @@ yydefault: case 1482: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7316 +//line sql.y:7306 { yyLOCAL = yyDollar[1].orderByUnion() } @@ -21276,7 +21269,7 @@ yydefault: case 1483: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7322 +//line sql.y:7312 { yyLOCAL = yyDollar[3].orderByUnion() } @@ -21284,14 +21277,14 @@ yydefault: case 1484: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7328 +//line sql.y:7318 { yyLOCAL = OrderBy{yyDollar[1].orderUnion()} } yyVAL.union = yyLOCAL case 1485: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7332 +//line sql.y:7322 { yySLICE := (*OrderBy)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].orderUnion()) @@ -21299,7 +21292,7 @@ yydefault: case 1486: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Order -//line sql.y:7338 +//line sql.y:7328 { yyLOCAL = &Order{Expr: yyDollar[1].exprUnion(), Direction: yyDollar[2].orderDirectionUnion()} } @@ -21307,7 +21300,7 @@ yydefault: case 1487: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7343 +//line sql.y:7333 { yyLOCAL = AscOrder } @@ -21315,7 +21308,7 @@ yydefault: case 1488: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7347 +//line sql.y:7337 { yyLOCAL = AscOrder } @@ -21323,7 +21316,7 @@ yydefault: case 1489: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7351 +//line sql.y:7341 { yyLOCAL = DescOrder } @@ -21331,7 +21324,7 @@ yydefault: case 1490: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *Limit -//line sql.y:7356 +//line sql.y:7346 { yyLOCAL = nil } @@ -21339,7 +21332,7 @@ yydefault: case 1491: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Limit -//line sql.y:7360 +//line sql.y:7350 { yyLOCAL = yyDollar[1].limitUnion() } @@ -21347,7 +21340,7 @@ yydefault: case 1492: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Limit -//line sql.y:7366 +//line sql.y:7356 { yyLOCAL = &Limit{Rowcount: yyDollar[2].exprUnion()} } @@ -21355,7 +21348,7 @@ yydefault: case 1493: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Limit -//line sql.y:7370 +//line sql.y:7360 { yyLOCAL = &Limit{Offset: yyDollar[2].exprUnion(), Rowcount: yyDollar[4].exprUnion()} } @@ -21363,7 +21356,7 @@ yydefault: case 1494: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Limit -//line sql.y:7374 +//line sql.y:7364 { yyLOCAL = &Limit{Offset: yyDollar[4].exprUnion(), Rowcount: yyDollar[2].exprUnion()} } @@ -21371,7 +21364,7 @@ yydefault: case 1495: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7379 +//line sql.y:7369 { yyLOCAL = nil } @@ -21379,7 +21372,7 @@ yydefault: case 1496: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7383 +//line sql.y:7373 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion(), yyDollar[2].alterOptionUnion()} } @@ -21387,7 +21380,7 @@ yydefault: case 1497: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7387 +//line sql.y:7377 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion(), yyDollar[2].alterOptionUnion()} } @@ -21395,7 +21388,7 @@ yydefault: case 1498: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7391 +//line sql.y:7381 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } @@ -21403,7 +21396,7 @@ yydefault: case 1499: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7395 +//line sql.y:7385 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } @@ -21411,7 +21404,7 @@ yydefault: case 1500: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7402 +//line sql.y:7392 { yyLOCAL = &LockOption{Type: DefaultType} } @@ -21419,7 +21412,7 @@ yydefault: case 1501: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7406 +//line sql.y:7396 { yyLOCAL = &LockOption{Type: NoneType} } @@ -21427,7 +21420,7 @@ yydefault: case 1502: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7410 +//line sql.y:7400 { yyLOCAL = &LockOption{Type: SharedType} } @@ -21435,7 +21428,7 @@ yydefault: case 1503: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7414 +//line sql.y:7404 { yyLOCAL = &LockOption{Type: ExclusiveType} } @@ -21443,7 +21436,7 @@ yydefault: case 1504: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7420 +//line sql.y:7410 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } @@ -21451,7 +21444,7 @@ yydefault: case 1505: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7424 +//line sql.y:7414 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } @@ -21459,7 +21452,7 @@ yydefault: case 1506: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7428 +//line sql.y:7418 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } @@ -21467,93 +21460,93 @@ yydefault: case 1507: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7432 +//line sql.y:7422 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL case 1508: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7437 +//line sql.y:7427 { yyVAL.str = "" } case 1509: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7441 +//line sql.y:7431 { yyVAL.str = string(yyDollar[3].str) } case 1510: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7445 +//line sql.y:7435 { yyVAL.str = string(yyDollar[3].str) } case 1511: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7449 +//line sql.y:7439 { yyVAL.str = string(yyDollar[3].str) } case 1512: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7454 +//line sql.y:7444 { yyVAL.str = "" } case 1513: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7458 +//line sql.y:7448 { yyVAL.str = yyDollar[3].str } case 1514: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7464 +//line sql.y:7454 { yyVAL.str = string(yyDollar[1].str) } case 1515: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7468 +//line sql.y:7458 { yyVAL.str = string(yyDollar[1].str) } case 1516: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7473 +//line sql.y:7463 { yyVAL.str = "" } case 1517: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7477 +//line sql.y:7467 { yyVAL.str = yyDollar[2].str } case 1518: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7482 +//line sql.y:7472 { yyVAL.str = "cascaded" } case 1519: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7486 +//line sql.y:7476 { yyVAL.str = string(yyDollar[1].str) } case 1520: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7490 +//line sql.y:7480 { yyVAL.str = string(yyDollar[1].str) } case 1521: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *Definer -//line sql.y:7495 +//line sql.y:7485 { yyLOCAL = nil } @@ -21561,7 +21554,7 @@ yydefault: case 1522: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Definer -//line sql.y:7499 +//line sql.y:7489 { yyLOCAL = yyDollar[3].definerUnion() } @@ -21569,7 +21562,7 @@ yydefault: case 1523: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Definer -//line sql.y:7505 +//line sql.y:7495 { yyLOCAL = &Definer{ Name: string(yyDollar[1].str), @@ -21579,7 +21572,7 @@ yydefault: case 1524: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Definer -//line sql.y:7511 +//line sql.y:7501 { yyLOCAL = &Definer{ Name: string(yyDollar[1].str), @@ -21589,7 +21582,7 @@ yydefault: case 1525: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Definer -//line sql.y:7517 +//line sql.y:7507 { yyLOCAL = &Definer{ Name: yyDollar[1].str, @@ -21599,32 +21592,32 @@ yydefault: yyVAL.union = yyLOCAL case 1526: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7526 +//line sql.y:7516 { yyVAL.str = encodeSQLString(yyDollar[1].str) } case 1527: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7530 +//line sql.y:7520 { yyVAL.str = formatIdentifier(yyDollar[1].str) } case 1528: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7535 +//line sql.y:7525 { yyVAL.str = "" } case 1529: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7539 +//line sql.y:7529 { yyVAL.str = formatAddress(yyDollar[1].str) } case 1530: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Lock -//line sql.y:7545 +//line sql.y:7535 { yyLOCAL = ForUpdateLock } @@ -21632,7 +21625,7 @@ yydefault: case 1531: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Lock -//line sql.y:7549 +//line sql.y:7539 { yyLOCAL = ForUpdateLockNoWait } @@ -21640,7 +21633,7 @@ yydefault: case 1532: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7553 +//line sql.y:7543 { yyLOCAL = ForUpdateLockSkipLocked } @@ -21648,7 +21641,7 @@ yydefault: case 1533: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Lock -//line sql.y:7557 +//line sql.y:7547 { yyLOCAL = ForShareLock } @@ -21656,7 +21649,7 @@ yydefault: case 1534: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Lock -//line sql.y:7561 +//line sql.y:7551 { yyLOCAL = ForShareLockNoWait } @@ -21664,7 +21657,7 @@ yydefault: case 1535: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7565 +//line sql.y:7555 { yyLOCAL = ForShareLockSkipLocked } @@ -21672,7 +21665,7 @@ yydefault: case 1536: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7569 +//line sql.y:7559 { yyLOCAL = ShareModeLock } @@ -21680,7 +21673,7 @@ yydefault: case 1537: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7575 +//line sql.y:7565 { yyLOCAL = &SelectInto{Type: IntoOutfileS3, FileName: encodeSQLString(yyDollar[4].str), Charset: yyDollar[5].columnCharset, FormatOption: yyDollar[6].str, ExportOption: yyDollar[7].str, Manifest: yyDollar[8].str, Overwrite: yyDollar[9].str} } @@ -21688,7 +21681,7 @@ yydefault: case 1538: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7579 +//line sql.y:7569 { yyLOCAL = &SelectInto{Type: IntoDumpfile, FileName: encodeSQLString(yyDollar[3].str), Charset: ColumnCharset{}, FormatOption: "", ExportOption: "", Manifest: "", Overwrite: ""} } @@ -21696,177 +21689,177 @@ yydefault: case 1539: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7583 +//line sql.y:7573 { yyLOCAL = &SelectInto{Type: IntoOutfile, FileName: encodeSQLString(yyDollar[3].str), Charset: yyDollar[4].columnCharset, FormatOption: "", ExportOption: yyDollar[5].str, Manifest: "", Overwrite: ""} } yyVAL.union = yyLOCAL case 1540: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7588 +//line sql.y:7578 { yyVAL.str = "" } case 1541: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7592 +//line sql.y:7582 { yyVAL.str = " format csv" + yyDollar[3].str } case 1542: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7596 +//line sql.y:7586 { yyVAL.str = " format text" + yyDollar[3].str } case 1543: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7601 +//line sql.y:7591 { yyVAL.str = "" } case 1544: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7605 +//line sql.y:7595 { yyVAL.str = " header" } case 1545: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7610 +//line sql.y:7600 { yyVAL.str = "" } case 1546: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7614 +//line sql.y:7604 { yyVAL.str = " manifest on" } case 1547: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7618 +//line sql.y:7608 { yyVAL.str = " manifest off" } case 1548: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7623 +//line sql.y:7613 { yyVAL.str = "" } case 1549: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7627 +//line sql.y:7617 { yyVAL.str = " overwrite on" } case 1550: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7631 +//line sql.y:7621 { yyVAL.str = " overwrite off" } case 1551: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7637 +//line sql.y:7627 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } case 1552: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7642 +//line sql.y:7632 { yyVAL.str = "" } case 1553: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7646 +//line sql.y:7636 { yyVAL.str = " lines" + yyDollar[2].str } case 1554: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7652 +//line sql.y:7642 { yyVAL.str = yyDollar[1].str } case 1555: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7656 +//line sql.y:7646 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } case 1556: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7662 +//line sql.y:7652 { yyVAL.str = " starting by " + encodeSQLString(yyDollar[3].str) } case 1557: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7666 +//line sql.y:7656 { yyVAL.str = " terminated by " + encodeSQLString(yyDollar[3].str) } case 1558: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7671 +//line sql.y:7661 { yyVAL.str = "" } case 1559: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7675 +//line sql.y:7665 { yyVAL.str = " " + yyDollar[1].str + yyDollar[2].str } case 1560: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7681 +//line sql.y:7671 { yyVAL.str = yyDollar[1].str } case 1561: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7685 +//line sql.y:7675 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } case 1562: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7691 +//line sql.y:7681 { yyVAL.str = " terminated by " + encodeSQLString(yyDollar[3].str) } case 1563: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7695 +//line sql.y:7685 { yyVAL.str = yyDollar[1].str + " enclosed by " + encodeSQLString(yyDollar[4].str) } case 1564: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7699 +//line sql.y:7689 { yyVAL.str = " escaped by " + encodeSQLString(yyDollar[3].str) } case 1565: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7704 +//line sql.y:7694 { yyVAL.str = "" } case 1566: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7708 +//line sql.y:7698 { yyVAL.str = " optionally" } case 1567: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Insert -//line sql.y:7721 +//line sql.y:7711 { yyLOCAL = &Insert{Rows: yyDollar[2].valuesUnion()} } @@ -21874,7 +21867,7 @@ yydefault: case 1568: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Insert -//line sql.y:7725 +//line sql.y:7715 { yyLOCAL = &Insert{Rows: yyDollar[1].selStmtUnion()} } @@ -21882,7 +21875,7 @@ yydefault: case 1569: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *Insert -//line sql.y:7729 +//line sql.y:7719 { yyLOCAL = &Insert{Columns: yyDollar[2].columnsUnion(), Rows: yyDollar[5].valuesUnion()} } @@ -21890,7 +21883,7 @@ yydefault: case 1570: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Insert -//line sql.y:7733 +//line sql.y:7723 { yyLOCAL = &Insert{Columns: []IdentifierCI{}, Rows: yyDollar[4].valuesUnion()} } @@ -21898,7 +21891,7 @@ yydefault: case 1571: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Insert -//line sql.y:7737 +//line sql.y:7727 { yyLOCAL = &Insert{Columns: yyDollar[2].columnsUnion(), Rows: yyDollar[4].selStmtUnion()} } @@ -21906,7 +21899,7 @@ yydefault: case 1572: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:7743 +//line sql.y:7733 { yyLOCAL = Columns{yyDollar[1].identifierCI} } @@ -21914,21 +21907,21 @@ yydefault: case 1573: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Columns -//line sql.y:7747 +//line sql.y:7737 { yyLOCAL = Columns{yyDollar[3].identifierCI} } yyVAL.union = yyLOCAL case 1574: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7751 +//line sql.y:7741 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } case 1575: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7755 +//line sql.y:7745 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[5].identifierCI) @@ -21936,7 +21929,7 @@ yydefault: case 1576: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7760 +//line sql.y:7750 { yyLOCAL = nil } @@ -21944,7 +21937,7 @@ yydefault: case 1577: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7764 +//line sql.y:7754 { yyLOCAL = yyDollar[5].updateExprsUnion() } @@ -21952,14 +21945,14 @@ yydefault: case 1578: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Values -//line sql.y:7770 +//line sql.y:7760 { yyLOCAL = Values{yyDollar[1].valTupleUnion()} } yyVAL.union = yyLOCAL case 1579: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7774 +//line sql.y:7764 { yySLICE := (*Values)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].valTupleUnion()) @@ -21967,7 +21960,7 @@ yydefault: case 1580: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7780 +//line sql.y:7770 { yyLOCAL = yyDollar[1].valTupleUnion() } @@ -21975,7 +21968,7 @@ yydefault: case 1581: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7784 +//line sql.y:7774 { yyLOCAL = ValTuple{} } @@ -21983,7 +21976,7 @@ yydefault: case 1582: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7790 +//line sql.y:7780 { yyLOCAL = ValTuple(yyDollar[2].exprsUnion()) } @@ -21991,7 +21984,7 @@ yydefault: case 1583: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7794 +//line sql.y:7784 { yyLOCAL = ValTuple(yyDollar[3].exprsUnion()) } @@ -21999,7 +21992,7 @@ yydefault: case 1584: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7799 +//line sql.y:7789 { if len(yyDollar[1].valTupleUnion()) == 1 { yyLOCAL = yyDollar[1].valTupleUnion()[0] @@ -22011,14 +22004,14 @@ yydefault: case 1585: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7809 +//line sql.y:7799 { yyLOCAL = UpdateExprs{yyDollar[1].updateExprUnion()} } yyVAL.union = yyLOCAL case 1586: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7813 +//line sql.y:7803 { yySLICE := (*UpdateExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].updateExprUnion()) @@ -22026,21 +22019,21 @@ yydefault: case 1587: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *UpdateExpr -//line sql.y:7819 +//line sql.y:7809 { yyLOCAL = &UpdateExpr{Name: yyDollar[1].colNameUnion(), Expr: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL case 1589: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7826 +//line sql.y:7816 { yyVAL.str = "charset" } case 1592: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7836 +//line sql.y:7826 { yyLOCAL = NewStrLiteral(yyDollar[1].identifierCI.String()) } @@ -22048,7 +22041,7 @@ yydefault: case 1593: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7840 +//line sql.y:7830 { yyLOCAL = NewStrLiteral(yyDollar[1].str) } @@ -22056,7 +22049,7 @@ yydefault: case 1594: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7844 +//line sql.y:7834 { yyLOCAL = &Default{} } @@ -22064,7 +22057,7 @@ yydefault: case 1597: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7853 +//line sql.y:7843 { yyLOCAL = false } @@ -22072,7 +22065,7 @@ yydefault: case 1598: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:7855 +//line sql.y:7845 { yyLOCAL = true } @@ -22080,7 +22073,7 @@ yydefault: case 1599: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7858 +//line sql.y:7848 { yyLOCAL = false } @@ -22088,7 +22081,7 @@ yydefault: case 1600: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:7860 +//line sql.y:7850 { yyLOCAL = true } @@ -22096,7 +22089,7 @@ yydefault: case 1601: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7863 +//line sql.y:7853 { yyLOCAL = false } @@ -22104,7 +22097,7 @@ yydefault: case 1602: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL bool -//line sql.y:7865 +//line sql.y:7855 { yyLOCAL = true } @@ -22112,7 +22105,7 @@ yydefault: case 1603: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Ignore -//line sql.y:7868 +//line sql.y:7858 { yyLOCAL = false } @@ -22120,33 +22113,33 @@ yydefault: case 1604: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Ignore -//line sql.y:7870 +//line sql.y:7860 { yyLOCAL = true } yyVAL.union = yyLOCAL case 1605: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7873 +//line sql.y:7863 { yyVAL.empty = struct{}{} } case 1606: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7875 +//line sql.y:7865 { yyVAL.empty = struct{}{} } case 1607: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7877 +//line sql.y:7867 { yyVAL.empty = struct{}{} } case 1608: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:7881 +//line sql.y:7871 { yyLOCAL = &CallProc{Name: yyDollar[2].tableName, Params: yyDollar[4].exprsUnion()} } @@ -22154,7 +22147,7 @@ yydefault: case 1609: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:7886 +//line sql.y:7876 { yyLOCAL = nil } @@ -22162,7 +22155,7 @@ yydefault: case 1610: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Exprs -//line sql.y:7890 +//line sql.y:7880 { yyLOCAL = yyDollar[1].exprsUnion() } @@ -22170,7 +22163,7 @@ yydefault: case 1611: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:7895 +//line sql.y:7885 { yyLOCAL = nil } @@ -22178,7 +22171,7 @@ yydefault: case 1612: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:7897 +//line sql.y:7887 { yyLOCAL = []*IndexOption{yyDollar[1].indexOptionUnion()} } @@ -22186,63 +22179,63 @@ yydefault: case 1613: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:7901 +//line sql.y:7891 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str), String: string(yyDollar[2].identifierCI.String())} } yyVAL.union = yyLOCAL case 1614: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7907 +//line sql.y:7897 { yyVAL.identifierCI = yyDollar[1].identifierCI } case 1615: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7911 +//line sql.y:7901 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } case 1617: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7918 +//line sql.y:7908 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } case 1618: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7924 +//line sql.y:7914 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } case 1619: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7928 +//line sql.y:7918 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } case 1620: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7934 +//line sql.y:7924 { yyVAL.identifierCS = NewIdentifierCS("") } case 1621: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7938 +//line sql.y:7928 { yyVAL.identifierCS = yyDollar[1].identifierCS } case 1623: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7945 +//line sql.y:7935 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } case 1624: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:7951 +//line sql.y:7941 { yyLOCAL = &Kill{Type: yyDollar[2].killTypeUnion(), ProcesslistID: convertStringToUInt64(yyDollar[3].str)} } @@ -22250,7 +22243,7 @@ yydefault: case 1625: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL KillType -//line sql.y:7957 +//line sql.y:7947 { yyLOCAL = ConnectionType } @@ -22258,7 +22251,7 @@ yydefault: case 1626: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL KillType -//line sql.y:7961 +//line sql.y:7951 { yyLOCAL = ConnectionType } @@ -22266,42 +22259,42 @@ yydefault: case 1627: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL KillType -//line sql.y:7965 +//line sql.y:7955 { yyLOCAL = QueryType } yyVAL.union = yyLOCAL case 2244: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8610 +//line sql.y:8600 { } case 2245: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8615 +//line sql.y:8605 { } case 2246: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8619 +//line sql.y:8609 { skipToEnd(yylex) } case 2247: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8624 +//line sql.y:8614 { skipToEnd(yylex) } case 2248: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8628 +//line sql.y:8618 { skipToEnd(yylex) } case 2249: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8632 +//line sql.y:8622 { skipToEnd(yylex) } diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index 26c74b7fe47..38af54c7323 100644 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -16,6 +16,8 @@ limitations under the License. %{ package sqlparser +import "vitess.io/vitess/go/ptr" + func setParseTree(yylex yyLexer, stmt Statement) { yylex.(*Tokenizer).ParseTree = stmt } @@ -191,6 +193,7 @@ func markBindVariable(yylex yyLexer, bvar string) { partitionByType PartitionByType definer *Definer integer int + intPtr *int JSONTableExpr *JSONTableExpr jtColumnDefinition *JtColumnDefinition @@ -546,7 +549,8 @@ func markBindVariable(yylex yyLexer, bvar string) { %type array_opt %type column_type %type int_type decimal_type numeric_type time_type char_type spatial_type -%type length_opt partition_comment partition_data_directory partition_index_directory +%type partition_comment partition_data_directory partition_index_directory +%type length_opt %type func_datetime_precision %type charset_opt %type collate_opt @@ -1473,14 +1477,12 @@ column_attribute_list_opt: } | column_attribute_list_opt NULL { - val := true - $1.Null = &val + $1.Null = ptr.Of(true) $$ = $1 } | column_attribute_list_opt NOT NULL { - val := false - $1.Null = &val + $1.Null = ptr.Of(false) $$ = $1 } | column_attribute_list_opt DEFAULT openb expression closeb @@ -1534,14 +1536,12 @@ column_attribute_list_opt: } | column_attribute_list_opt VISIBLE { - val := false - $1.Invisible = &val + $1.Invisible = ptr.Of(false) $$ = $1 } | column_attribute_list_opt INVISIBLE { - val := true - $1.Invisible = &val + $1.Invisible = ptr.Of(true) $$ = $1 } | column_attribute_list_opt ENGINE_ATTRIBUTE equal_opt STRING @@ -1588,14 +1588,12 @@ generated_column_attribute_list_opt: } | generated_column_attribute_list_opt NULL { - val := true - $1.Null = &val + $1.Null = ptr.Of(true) $$ = $1 } | generated_column_attribute_list_opt NOT NULL { - val := false - $1.Null = &val + $1.Null = ptr.Of(false) $$ = $1 } | generated_column_attribute_list_opt COMMENT_KEYWORD STRING @@ -1610,14 +1608,12 @@ generated_column_attribute_list_opt: } | generated_column_attribute_list_opt VISIBLE { - val := false - $1.Invisible = &val + $1.Invisible = ptr.Of(false) $$ = $1 } | generated_column_attribute_list_opt INVISIBLE { - val := true - $1.Invisible = &val + $1.Invisible = ptr.Of(true) $$ = $1 } @@ -2232,7 +2228,7 @@ length_opt: } | '(' INTEGRAL ')' { - $$ = NewIntLiteral($2) + $$ = ptr.Of(convertStringToInt($2)) } double_length_opt: @@ -2242,8 +2238,8 @@ double_length_opt: | '(' INTEGRAL ',' INTEGRAL ')' { $$ = LengthScaleOption{ - Length: NewIntLiteral($2), - Scale: NewIntLiteral($4), + Length: ptr.Of(convertStringToInt($2)), + Scale: ptr.Of(convertStringToInt($4)), } } @@ -2255,7 +2251,7 @@ double_length_opt | '(' INTEGRAL ')' { $$ = LengthScaleOption{ - Length: NewIntLiteral($2), + Length: ptr.Of(convertStringToInt($2)), } } @@ -2266,14 +2262,14 @@ decimal_length_opt: | '(' INTEGRAL ')' { $$ = LengthScaleOption{ - Length: NewIntLiteral($2), + Length: ptr.Of(convertStringToInt($2)), } } | '(' INTEGRAL ',' INTEGRAL ')' { $$ = LengthScaleOption{ - Length: NewIntLiteral($2), - Scale: NewIntLiteral($4), + Length: ptr.Of(convertStringToInt($2)), + Scale: ptr.Of(convertStringToInt($4)), } } @@ -3021,13 +3017,11 @@ alter_option: } | ALTER column_opt column_name SET VISIBLE { - val := false - $$ = &AlterColumn{Column: $3, Invisible:&val} + $$ = &AlterColumn{Column: $3, Invisible: ptr.Of(false)} } | ALTER column_opt column_name SET INVISIBLE { - val := true - $$ = &AlterColumn{Column: $3, Invisible:&val} + $$ = &AlterColumn{Column: $3, Invisible: ptr.Of(true)} } | ALTER CHECK ci_identifier enforced { @@ -3772,14 +3766,12 @@ partition_definition_attribute_list_opt: } | partition_definition_attribute_list_opt partition_max_rows { - val := $2 - $1.MaxRows = &val + $1.MaxRows = ptr.Of($2) $$ = $1 } | partition_definition_attribute_list_opt partition_min_rows { - val := $2 - $1.MinRows = &val + $1.MinRows = ptr.Of($2) $$ = $1 } | partition_definition_attribute_list_opt partition_tablespace_name @@ -3840,14 +3832,12 @@ subpartition_definition_attribute_list_opt: } | subpartition_definition_attribute_list_opt partition_max_rows { - val := $2 - $1.MaxRows = &val + $1.MaxRows = ptr.Of($2) $$ = $1 } | subpartition_definition_attribute_list_opt partition_min_rows { - val := $2 - $1.MinRows = &val + $1.MinRows = ptr.Of($2) $$ = $1 } | subpartition_definition_attribute_list_opt partition_tablespace_name @@ -7094,11 +7084,11 @@ convert_type_weight_string: } | AS BINARY '(' INTEGRAL ')' { - $$ = &ConvertType{Type: string($2), Length: NewIntLiteral($4)} + $$ = &ConvertType{Type: string($2), Length: ptr.Of(convertStringToInt($4))} } | AS CHAR '(' INTEGRAL ')' { - $$ = &ConvertType{Type: string($2), Length: NewIntLiteral($4)} + $$ = &ConvertType{Type: string($2), Length: ptr.Of(convertStringToInt($4))} } convert_type: diff --git a/go/vt/vtgate/evalengine/cached_size.go b/go/vt/vtgate/evalengine/cached_size.go index 2e57011ca4c..ce90aadea8a 100644 --- a/go/vt/vtgate/evalengine/cached_size.go +++ b/go/vt/vtgate/evalengine/cached_size.go @@ -213,6 +213,10 @@ func (cached *ConvertExpr) CachedSize(alloc bool) int64 { size += cached.UnaryExpr.CachedSize(false) // field Type string size += hack.RuntimeAllocSize(int64(len(cached.Type))) + // field Length *int + size += hack.RuntimeAllocSize(int64(8)) + // field Scale *int + size += hack.RuntimeAllocSize(int64(8)) // field CollationEnv *vitess.io/vitess/go/mysql/collations.Environment size += cached.CollationEnv.CachedSize(true) return size @@ -1813,12 +1817,14 @@ func (cached *builtinWeightString) CachedSize(alloc bool) int64 { } size := int64(0) if alloc { - size += int64(80) + size += int64(64) } // field CallExpr vitess.io/vitess/go/vt/vtgate/evalengine.CallExpr size += cached.CallExpr.CachedSize(false) // field Cast string size += hack.RuntimeAllocSize(int64(len(cached.Cast))) + // field Len *int + size += hack.RuntimeAllocSize(int64(8)) return size } func (cached *builtinYear) CachedSize(alloc bool) int64 { diff --git a/go/vt/vtgate/evalengine/compiler.go b/go/vt/vtgate/evalengine/compiler.go index 0b830568e7b..8c5700d751d 100644 --- a/go/vt/vtgate/evalengine/compiler.go +++ b/go/vt/vtgate/evalengine/compiler.go @@ -534,7 +534,7 @@ func (c *compiler) compileToJSONKey(key ctype) error { if key.Type == sqltypes.VarBinary { return nil } - c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, nil) return nil } diff --git a/go/vt/vtgate/evalengine/compiler_asm.go b/go/vt/vtgate/evalengine/compiler_asm.go index cf7bea44a02..cddf0790ea7 100644 --- a/go/vt/vtgate/evalengine/compiler_asm.go +++ b/go/vt/vtgate/evalengine/compiler_asm.go @@ -1048,15 +1048,16 @@ func (asm *assembler) Convert_ui(offset int) { }, "CONV UINT64(SP-%d), INT64", offset) } -func (asm *assembler) Convert_xb(offset int, t sqltypes.Type, length int, hasLength bool) { - if hasLength { +func (asm *assembler) Convert_xb(offset int, t sqltypes.Type, length *int) { + if length != nil { + l := *length asm.emit(func(env *ExpressionEnv) int { arg := evalToBinary(env.vm.stack[env.vm.sp-offset]) - arg.truncateInPlace(length) + arg.truncateInPlace(l) arg.tt = int16(t) env.vm.stack[env.vm.sp-offset] = arg return 1 - }, "CONV (SP-%d), VARBINARY[%d]", offset, length) + }, "CONV (SP-%d), VARBINARY[%d]", offset, l) } else { asm.emit(func(env *ExpressionEnv) int { arg := evalToBinary(env.vm.stack[env.vm.sp-offset]) @@ -1067,19 +1068,20 @@ func (asm *assembler) Convert_xb(offset int, t sqltypes.Type, length int, hasLen } } -func (asm *assembler) Convert_xc(offset int, t sqltypes.Type, collation collations.ID, length int, hasLength bool) { - if hasLength { +func (asm *assembler) Convert_xc(offset int, t sqltypes.Type, collation collations.ID, length *int) { + if length != nil { + l := *length asm.emit(func(env *ExpressionEnv) int { arg, err := evalToVarchar(env.vm.stack[env.vm.sp-offset], collation, true) if err != nil { env.vm.stack[env.vm.sp-offset] = nil } else { - arg.truncateInPlace(length) + arg.truncateInPlace(l) arg.tt = int16(t) env.vm.stack[env.vm.sp-offset] = arg } return 1 - }, "CONV (SP-%d), VARCHAR[%d]", offset, length) + }, "CONV (SP-%d), VARCHAR[%d]", offset, l) } else { asm.emit(func(env *ExpressionEnv) int { arg, err := evalToVarchar(env.vm.stack[env.vm.sp-offset], collation, true) diff --git a/go/vt/vtgate/evalengine/compiler_fn.go b/go/vt/vtgate/evalengine/compiler_fn.go index d4157929546..72197f6a492 100644 --- a/go/vt/vtgate/evalengine/compiler_fn.go +++ b/go/vt/vtgate/evalengine/compiler_fn.go @@ -76,7 +76,7 @@ func (c *compiler) compileFn_length(arg IR, asm_ins func()) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, nil) } asm_ins() diff --git a/go/vt/vtgate/evalengine/expr_collate.go b/go/vt/vtgate/evalengine/expr_collate.go index b54f679bee3..bab0e5e52f9 100644 --- a/go/vt/vtgate/evalengine/expr_collate.go +++ b/go/vt/vtgate/evalengine/expr_collate.go @@ -118,7 +118,7 @@ func (expr *CollateExpr) compile(c *compiler) (ctype, error) { case sqltypes.VarBinary: c.asm.Collate(expr.TypedCollation.Collation) default: - c.asm.Convert_xc(1, sqltypes.VarChar, expr.TypedCollation.Collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, expr.TypedCollation.Collation, nil) } c.asm.jumpDestination(skip) diff --git a/go/vt/vtgate/evalengine/expr_compare.go b/go/vt/vtgate/evalengine/expr_compare.go index 0cd90c4e9ff..ca4cdd75f74 100644 --- a/go/vt/vtgate/evalengine/expr_compare.go +++ b/go/vt/vtgate/evalengine/expr_compare.go @@ -623,7 +623,7 @@ func (expr *LikeExpr) compile(c *compiler) (ctype, error) { skip := c.compileNullCheck2(lt, rt) if !lt.isTextual() { - c.asm.Convert_xc(2, sqltypes.VarChar, c.collation, 0, false) + c.asm.Convert_xc(2, sqltypes.VarChar, c.collation, nil) lt.Col = collations.TypedCollation{ Collation: c.collation, Coercibility: collations.CoerceCoercible, @@ -632,7 +632,7 @@ func (expr *LikeExpr) compile(c *compiler) (ctype, error) { } if !rt.isTextual() { - c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, nil) rt.Col = collations.TypedCollation{ Collation: c.collation, Coercibility: collations.CoerceCoercible, diff --git a/go/vt/vtgate/evalengine/expr_convert.go b/go/vt/vtgate/evalengine/expr_convert.go index 1dd41b14ad1..a63b8197d77 100644 --- a/go/vt/vtgate/evalengine/expr_convert.go +++ b/go/vt/vtgate/evalengine/expr_convert.go @@ -19,6 +19,7 @@ package evalengine import ( "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/mysql/collations/colldata" + "vitess.io/vitess/go/ptr" "vitess.io/vitess/go/sqltypes" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/vterrors" @@ -27,11 +28,10 @@ import ( type ( ConvertExpr struct { UnaryExpr - Type string - Length, Scale int - HasLength, HasScale bool - Collation collations.ID - CollationEnv *collations.Environment + Type string + Length, Scale *int + Collation collations.ID + CollationEnv *collations.Environment } ConvertUsingExpr struct { @@ -47,10 +47,10 @@ var _ IR = (*ConvertUsingExpr)(nil) func (c *ConvertExpr) returnUnsupportedError() error { var err error switch { - case c.HasLength && c.HasScale: - err = vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "Unsupported type conversion: %s(%d,%d)", c.Type, c.Length, c.Scale) - case c.HasLength: - err = vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "Unsupported type conversion: %s(%d)", c.Type, c.Length) + case c.Length != nil && c.Scale != nil: + err = vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "Unsupported type conversion: %s(%d,%d)", c.Type, *c.Length, *c.Scale) + case c.Length != nil: + err = vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "Unsupported type conversion: %s(%d)", c.Type, *c.Length) default: err = vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "Unsupported type conversion: %s", c.Type) } @@ -60,11 +60,11 @@ func (c *ConvertExpr) returnUnsupportedError() error { func (c *ConvertExpr) decimalPrecision() (int32, int32) { m := 10 d := 0 - if c.HasLength { - m = c.Length + if c.Length != nil { + m = *c.Length } - if c.HasScale { - d = c.Scale + if c.Scale != nil { + d = *c.Scale } if m == 0 && d == 0 { m = 10 @@ -84,8 +84,8 @@ func (c *ConvertExpr) eval(env *ExpressionEnv) (eval, error) { switch c.Type { case "BINARY": b := evalToBinary(e) - if c.HasLength { - b.truncateInPlace(c.Length) + if c.Length != nil { + b.truncateInPlace(*c.Length) } b.tt = int16(c.convertToBinaryType(e.SQLType())) return b, nil @@ -96,8 +96,8 @@ func (c *ConvertExpr) eval(env *ExpressionEnv) (eval, error) { // return NULL on error return nil, nil } - if c.HasLength { - t.truncateInPlace(c.Length) + if c.Length != nil { + t.truncateInPlace(*c.Length) } t.tt = int16(c.convertToCharType(e.SQLType())) return t, nil @@ -108,8 +108,8 @@ func (c *ConvertExpr) eval(env *ExpressionEnv) (eval, error) { f, _ := evalToFloat(e) return f, nil case "FLOAT": - if c.HasLength { - switch p := c.Length; { + if c.Length != nil { + switch p := *c.Length; { case p > 53: return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "Too-big precision %d specified for 'CONVERT'. Maximum is 53.", p) } @@ -122,11 +122,11 @@ func (c *ConvertExpr) eval(env *ExpressionEnv) (eval, error) { case "JSON": return evalToJSON(e) case "DATETIME": - switch p := c.Length; { - case p > 6: + p := ptr.Unwrap(c.Length, 0) + if p > 6 { return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "Too-big precision %d specified for 'CONVERT'. Maximum is 6.", p) } - if dt := evalToDateTime(e, c.Length, env.now, env.sqlmode.AllowZeroDate()); dt != nil { + if dt := evalToDateTime(e, p, env.now, env.sqlmode.AllowZeroDate()); dt != nil { return dt, nil } return nil, nil @@ -136,11 +136,11 @@ func (c *ConvertExpr) eval(env *ExpressionEnv) (eval, error) { } return nil, nil case "TIME": - switch p := c.Length; { - case p > 6: + p := ptr.Unwrap(c.Length, 0) + if p > 6 { return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "Too-big precision %d specified for 'CONVERT'. Maximum is 6.", p) } - if t := evalToTime(e, c.Length); t != nil { + if t := evalToTime(e, p); t != nil { return t, nil } return nil, nil @@ -152,8 +152,8 @@ func (c *ConvertExpr) eval(env *ExpressionEnv) (eval, error) { } func (c *ConvertExpr) convertToBinaryType(tt sqltypes.Type) sqltypes.Type { - if c.HasLength { - if c.Length > 64*1024 { + if c.Length != nil { + if *c.Length > 64*1024 { return sqltypes.Blob } } else if tt == sqltypes.Blob || tt == sqltypes.TypeJSON { @@ -163,9 +163,9 @@ func (c *ConvertExpr) convertToBinaryType(tt sqltypes.Type) sqltypes.Type { } func (c *ConvertExpr) convertToCharType(tt sqltypes.Type) sqltypes.Type { - if c.HasLength { + if c.Length != nil { col := colldata.Lookup(c.Collation) - length := c.Length * col.Charset().MaxWidth() + length := *c.Length * col.Charset().MaxWidth() if length > 64*1024 { return sqltypes.Text } @@ -187,18 +187,18 @@ func (conv *ConvertExpr) compile(c *compiler) (ctype, error) { switch conv.Type { case "BINARY": convt = ctype{Type: conv.convertToBinaryType(arg.Type), Col: collationBinary} - c.asm.Convert_xb(1, convt.Type, conv.Length, conv.HasLength) + c.asm.Convert_xb(1, convt.Type, conv.Length) case "CHAR", "NCHAR": convt = ctype{ Type: conv.convertToCharType(arg.Type), Col: collations.TypedCollation{Collation: conv.Collation}, } - c.asm.Convert_xc(1, convt.Type, convt.Col.Collation, conv.Length, conv.HasLength) + c.asm.Convert_xc(1, convt.Type, convt.Col.Collation, conv.Length) case "DECIMAL": - convt = ctype{Type: sqltypes.Decimal, Col: collationNumeric} m, d := conv.decimalPrecision() + convt = ctype{Type: sqltypes.Decimal, Col: collationNumeric, Size: m, Scale: d} c.asm.Convert_xd(1, m, d) case "DOUBLE", "REAL": @@ -224,18 +224,18 @@ func (conv *ConvertExpr) compile(c *compiler) (ctype, error) { convt = c.compileToDate(arg, 1) case "DATETIME": - switch p := conv.Length; { - case p > 6: + p := ptr.Unwrap(conv.Length, 0) + if p > 6 { return ctype{}, c.unsupported(conv) } - convt = c.compileToDateTime(arg, 1, conv.Length) + convt = c.compileToDateTime(arg, 1, p) case "TIME": - switch p := conv.Length; { - case p > 6: + p := ptr.Unwrap(conv.Length, 0) + if p > 6 { return ctype{}, c.unsupported(conv) } - convt = c.compileToTime(arg, 1, conv.Length) + convt = c.compileToTime(arg, 1, p) default: return ctype{}, c.unsupported(conv) @@ -269,7 +269,7 @@ func (conv *ConvertUsingExpr) compile(c *compiler) (ctype, error) { } skip := c.compileNullCheck1(ct) - c.asm.Convert_xc(1, sqltypes.VarChar, conv.Collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, conv.Collation, nil) c.asm.jumpDestination(skip) col := collations.TypedCollation{ diff --git a/go/vt/vtgate/evalengine/fn_base64.go b/go/vt/vtgate/evalengine/fn_base64.go index a785000ca5d..77baf060eb9 100644 --- a/go/vt/vtgate/evalengine/fn_base64.go +++ b/go/vt/vtgate/evalengine/fn_base64.go @@ -103,7 +103,7 @@ func (call *builtinToBase64) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(1, t, 0, false) + c.asm.Convert_xb(1, t, nil) } col := typedCoercionCollation(t, c.collation) @@ -149,7 +149,7 @@ func (call *builtinFromBase64) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(1, t, 0, false) + c.asm.Convert_xb(1, t, nil) } c.asm.Fn_FROM_BASE64(t) diff --git a/go/vt/vtgate/evalengine/fn_crypto.go b/go/vt/vtgate/evalengine/fn_crypto.go index 8adbea6332c..8a3765028d9 100644 --- a/go/vt/vtgate/evalengine/fn_crypto.go +++ b/go/vt/vtgate/evalengine/fn_crypto.go @@ -62,7 +62,7 @@ func (call *builtinMD5) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.Binary, 0, false) + c.asm.Convert_xb(1, sqltypes.Binary, nil) } col := typedCoercionCollation(sqltypes.VarChar, c.collation) @@ -105,7 +105,7 @@ func (call *builtinSHA1) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.Binary, 0, false) + c.asm.Convert_xb(1, sqltypes.Binary, nil) } col := typedCoercionCollation(sqltypes.VarChar, c.collation) c.asm.Fn_SHA1(col) @@ -174,7 +174,7 @@ func (call *builtinSHA2) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(2, sqltypes.Binary, 0, false) + c.asm.Convert_xb(2, sqltypes.Binary, nil) } switch bits.Type { diff --git a/go/vt/vtgate/evalengine/fn_hex.go b/go/vt/vtgate/evalengine/fn_hex.go index c52aa4ed756..90d3bd1a208 100644 --- a/go/vt/vtgate/evalengine/fn_hex.go +++ b/go/vt/vtgate/evalengine/fn_hex.go @@ -73,7 +73,7 @@ func (call *builtinHex) compile(c *compiler) (ctype, error) { case str.isTextual(): c.asm.Fn_HEX_c(t, col) default: - c.asm.Convert_xc(1, t, c.collation, 0, false) + c.asm.Convert_xc(1, t, c.collation, nil) c.asm.Fn_HEX_c(t, col) } @@ -191,7 +191,7 @@ func (call *builtinUnhex) compile(c *compiler) (ctype, error) { case str.Type == sqltypes.TypeJSON: c.asm.Fn_UNHEX_j(t) default: - c.asm.Convert_xb(1, t, 0, false) + c.asm.Convert_xb(1, t, nil) c.asm.Fn_UNHEX_b(t) } diff --git a/go/vt/vtgate/evalengine/fn_misc.go b/go/vt/vtgate/evalengine/fn_misc.go index cfa14cafa80..8813b62f823 100644 --- a/go/vt/vtgate/evalengine/fn_misc.go +++ b/go/vt/vtgate/evalengine/fn_misc.go @@ -120,7 +120,7 @@ func (call *builtinInetAton) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } c.asm.Fn_INET_ATON() @@ -185,7 +185,7 @@ func (call *builtinInet6Aton) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } c.asm.Fn_INET6_ATON() @@ -291,7 +291,7 @@ func (call *builtinIsIPV4) compile(c *compiler) (ctype, error) { switch { case arg.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } c.asm.Fn_IS_IPV4() @@ -385,7 +385,7 @@ func (call *builtinIsIPV6) compile(c *compiler) (ctype, error) { switch { case arg.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } c.asm.Fn_IS_IPV6() @@ -459,7 +459,7 @@ func (call *builtinBinToUUID) compile(c *compiler) (ctype, error) { switch { case arg.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } col := typedCoercionCollation(sqltypes.VarChar, call.collate) @@ -512,7 +512,7 @@ func (call *builtinIsUUID) compile(c *compiler) (ctype, error) { switch { case arg.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } c.asm.Fn_IS_UUID() @@ -580,7 +580,7 @@ func (call *builtinUUIDToBin) compile(c *compiler) (ctype, error) { switch { case arg.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } ct := ctype{Type: sqltypes.VarBinary, Flag: nullableFlags(arg.Flag), Col: collationBinary} diff --git a/go/vt/vtgate/evalengine/fn_numeric.go b/go/vt/vtgate/evalengine/fn_numeric.go index c4a77b80fb8..bd835d88d78 100644 --- a/go/vt/vtgate/evalengine/fn_numeric.go +++ b/go/vt/vtgate/evalengine/fn_numeric.go @@ -1267,7 +1267,7 @@ func (expr *builtinCrc32) compile(c *compiler) (ctype, error) { switch { case arg.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.Binary, 0, false) + c.asm.Convert_xb(1, sqltypes.Binary, nil) } c.asm.Fn_CRC32() @@ -1374,7 +1374,7 @@ func (expr *builtinConv) compile(c *compiler) (ctype, error) { switch { case n.isTextual(): default: - c.asm.Convert_xb(3, t, 0, false) + c.asm.Convert_xb(3, t, nil) } if n.isHexOrBitLiteral() { diff --git a/go/vt/vtgate/evalengine/fn_regexp.go b/go/vt/vtgate/evalengine/fn_regexp.go index d0d11e4bc57..a94b9a83aee 100644 --- a/go/vt/vtgate/evalengine/fn_regexp.go +++ b/go/vt/vtgate/evalengine/fn_regexp.go @@ -551,7 +551,7 @@ func (r *builtinRegexpInstr) compile(c *compiler) (ctype, error) { switch { case matchType.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } } @@ -728,7 +728,7 @@ func (r *builtinRegexpSubstr) compile(c *compiler) (ctype, error) { switch { case matchType.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } } @@ -968,7 +968,7 @@ func (r *builtinRegexpReplace) compile(c *compiler) (ctype, error) { switch { case matchType.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } } diff --git a/go/vt/vtgate/evalengine/fn_string.go b/go/vt/vtgate/evalengine/fn_string.go index 05df198f1f2..11a18c95300 100644 --- a/go/vt/vtgate/evalengine/fn_string.go +++ b/go/vt/vtgate/evalengine/fn_string.go @@ -78,9 +78,8 @@ type ( builtinWeightString struct { CallExpr - Cast string - Len int - HasLen bool + Cast string + Len *int } builtinLeftRight struct { @@ -291,7 +290,7 @@ func (call *builtinChangeCase) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, nil) } c.asm.Fn_LUCASE(call.upcase) @@ -384,7 +383,7 @@ func (call *builtinASCII) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } c.asm.Fn_ASCII() @@ -438,7 +437,7 @@ func (call *builtinReverse) compile(c *compiler) (ctype, error) { switch { case arg.isTextual(): default: - c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, c.collation, nil) } c.asm.Fn_REVERSE() @@ -533,7 +532,7 @@ func (call *builtinOrd) compile(c *compiler) (ctype, error) { case str.isTextual(): col = str.Col.Collation default: - c.asm.Convert_xc(1, sqltypes.VarChar, call.collate, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, call.collate, nil) } c.asm.Fn_ORD(col) @@ -616,7 +615,7 @@ func (expr *builtinRepeat) compile(c *compiler) (ctype, error) { switch { case str.isTextual(): default: - c.asm.Convert_xc(2, sqltypes.VarChar, c.collation, 0, false) + c.asm.Convert_xc(2, sqltypes.VarChar, c.collation, nil) } _ = c.compileToInt64(repeat, 1) @@ -668,7 +667,7 @@ func (c *builtinWeightString) eval(env *ExpressionEnv) (eval, error) { typ = sqltypes.Blob } - weights, _, err = evalWeightString(weights, evalToBinary(input), c.Len, 0) + weights, _, err = evalWeightString(weights, evalToBinary(input), *c.Len, 0) if err != nil { return nil, err } @@ -703,7 +702,7 @@ func (c *builtinWeightString) eval(env *ExpressionEnv) (eval, error) { } else { var strLen int if c.Cast == "char" { - strLen = c.Len + strLen = *c.Len } weights, _, err = evalWeightString(weights, val, strLen, 0) } @@ -733,14 +732,14 @@ func (call *builtinWeightString) compile(c *compiler) (ctype, error) { skip := c.compileNullCheck1(str) if call.Cast == "binary" { if !sqltypes.IsBinary(str.Type) { - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } switch str.Type { case sqltypes.Blob, sqltypes.Text, sqltypes.TypeJSON: typ = sqltypes.Blob } - c.asm.Fn_WEIGHT_STRING(typ, call.Len) + c.asm.Fn_WEIGHT_STRING(typ, *call.Len) c.asm.jumpDestination(skip) return ctype{Type: sqltypes.VarBinary, Flag: flagNullable | flagNull, Col: collationBinary}, nil } @@ -761,7 +760,7 @@ func (call *builtinWeightString) compile(c *compiler) (ctype, error) { } var strLen int if call.Cast == "char" { - strLen = call.Len + strLen = *call.Len } c.asm.Fn_WEIGHT_STRING(typ, strLen) @@ -831,7 +830,7 @@ func (call *builtinLeftRight) compile(c *compiler) (ctype, error) { case str.isTextual(): col = str.Col default: - c.asm.Convert_xc(2, sqltypes.VarChar, col.Collation, 0, false) + c.asm.Convert_xc(2, sqltypes.VarChar, col.Collation, nil) } _ = c.compileToInt64(l, 1) @@ -1124,7 +1123,7 @@ func (call *builtinTrim) compile(c *compiler) (ctype, error) { case str.isTextual(): col = str.Col default: - c.asm.Convert_xc(1, sqltypes.VarChar, col.Collation, 0, false) + c.asm.Convert_xc(1, sqltypes.VarChar, col.Collation, nil) } if len(call.Arguments) == 1 { @@ -1248,7 +1247,7 @@ func (call *builtinSubstring) compile(c *compiler) (ctype, error) { col = str.Col default: tt = sqltypes.VarChar - c.asm.Convert_xc(2, tt, col.Collation, 0, false) + c.asm.Convert_xc(2, tt, col.Collation, nil) } _ = c.compileToInt64(p, 1) diff --git a/go/vt/vtgate/evalengine/fn_time.go b/go/vt/vtgate/evalengine/fn_time.go index 430e4e123ac..57edf29e2a4 100644 --- a/go/vt/vtgate/evalengine/fn_time.go +++ b/go/vt/vtgate/evalengine/fn_time.go @@ -320,7 +320,7 @@ func (call *builtinDateFormat) compile(c *compiler) (ctype, error) { switch format.Type { case sqltypes.VarChar, sqltypes.VarBinary: default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } col := typedCoercionCollation(sqltypes.VarChar, c.collation) @@ -410,13 +410,13 @@ func (call *builtinConvertTz) compile(c *compiler) (ctype, error) { switch { case from.isTextual(): default: - c.asm.Convert_xb(2, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(2, sqltypes.VarBinary, nil) } switch { case to.isTextual(): default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } switch n.Type { @@ -729,7 +729,7 @@ func (call *builtinFromUnixtime) compile(c *compiler) (ctype, error) { switch format.Type { case sqltypes.VarChar, sqltypes.VarBinary: default: - c.asm.Convert_xb(1, sqltypes.VarBinary, 0, false) + c.asm.Convert_xb(1, sqltypes.VarBinary, nil) } col := typedCoercionCollation(sqltypes.VarChar, c.collation) diff --git a/go/vt/vtgate/evalengine/format.go b/go/vt/vtgate/evalengine/format.go index dddf538b37c..7576a8b0cda 100644 --- a/go/vt/vtgate/evalengine/format.go +++ b/go/vt/vtgate/evalengine/format.go @@ -273,7 +273,7 @@ func (c *builtinWeightString) format(buf *sqlparser.TrackedBuffer) { if c.Cast != "" { buf.WriteLiteral(" as ") buf.WriteLiteral(c.Cast) - _, _ = fmt.Fprintf(buf, "(%d)", c.Len) + _, _ = fmt.Fprintf(buf, "(%d)", *c.Len) } buf.WriteByte(')') } @@ -297,10 +297,10 @@ func (c *ConvertExpr) format(buf *sqlparser.TrackedBuffer) { formatExpr(buf, c, c.Inner, true) switch { - case c.HasLength && c.HasScale: - _, _ = fmt.Fprintf(buf, ", %s(%d,%d)", c.Type, c.Length, c.Scale) - case c.HasLength: - _, _ = fmt.Fprintf(buf, ", %s(%d)", c.Type, c.Length) + case c.Length != nil && c.Scale != nil: + _, _ = fmt.Fprintf(buf, ", %s(%d,%d)", c.Type, *c.Length, *c.Scale) + case c.Length != nil: + _, _ = fmt.Fprintf(buf, ", %s(%d)", c.Type, *c.Length) default: _, _ = fmt.Fprintf(buf, ", %s", c.Type) } diff --git a/go/vt/vtgate/evalengine/translate_builtin.go b/go/vt/vtgate/evalengine/translate_builtin.go index d4d979a8708..71eff66bc2b 100644 --- a/go/vt/vtgate/evalengine/translate_builtin.go +++ b/go/vt/vtgate/evalengine/translate_builtin.go @@ -656,10 +656,7 @@ func (ast *astCompiler) translateCallable(call sqlparser.Callable) (IR, error) { } if call.As != nil { ws.Cast = strings.ToLower(call.As.Type) - ws.Len, ws.HasLen, err = ast.translateIntegral(call.As.Length) - if err != nil { - return nil, err - } + ws.Len = call.As.Length } return ws, nil diff --git a/go/vt/vtgate/evalengine/translate_convert.go b/go/vt/vtgate/evalengine/translate_convert.go index 353d4d70c86..b47aa6f1fd9 100644 --- a/go/vt/vtgate/evalengine/translate_convert.go +++ b/go/vt/vtgate/evalengine/translate_convert.go @@ -72,34 +72,30 @@ func (ast *astCompiler) translateConvertExpr(expr sqlparser.Expr, convertType *s return nil, err } - convert.Length, convert.HasLength, err = ast.translateIntegral(convertType.Length) - if err != nil { - return nil, err - } - - convert.Scale, convert.HasScale, err = ast.translateIntegral(convertType.Scale) - if err != nil { - return nil, err - } - + convert.Length = convertType.Length + convert.Scale = convertType.Scale convert.Type = strings.ToUpper(convertType.Type) switch convert.Type { case "DECIMAL": - if convert.Length < convert.Scale { - return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, - "For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column '%s').", - "", // TODO: column name - ) - } - if convert.Length > decimal.MyMaxPrecision { - return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, - "Too-big precision %d specified for '%s'. Maximum is %d.", - convert.Length, sqlparser.String(expr), decimal.MyMaxPrecision) - } - if convert.Scale > decimal.MyMaxScale { - return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, - "Too big scale %d specified for column '%s'. Maximum is %d.", - convert.Scale, sqlparser.String(expr), decimal.MyMaxScale) + if convert.Length != nil { + if *convert.Length > decimal.MyMaxPrecision { + return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, + "Too-big precision %d specified for '%s'. Maximum is %d.", + *convert.Length, sqlparser.String(expr), decimal.MyMaxPrecision) + } + if convert.Scale != nil { + if *convert.Scale > decimal.MyMaxScale { + return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, + "Too big scale %d specified for column '%s'. Maximum is %d.", + *convert.Scale, sqlparser.String(expr), decimal.MyMaxScale) + } + if *convert.Length < *convert.Scale { + return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, + "For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column '%s').", + "", // TODO: column name + ) + } + } } case "NCHAR": convert.Collation = collations.CollationUtf8mb3ID diff --git a/go/vt/vtgate/schema/tracker.go b/go/vt/vtgate/schema/tracker.go index b5622c413c3..f7b46521b68 100644 --- a/go/vt/vtgate/schema/tracker.go +++ b/go/vt/vtgate/schema/tracker.go @@ -19,11 +19,11 @@ package schema import ( "context" "maps" - "strconv" "strings" "sync" "time" + "vitess.io/vitess/go/ptr" "vitess.io/vitess/go/vt/discovery" "vitess.io/vitess/go/vt/log" querypb "vitess.io/vitess/go/vt/proto/query" @@ -315,9 +315,9 @@ func getColumns(tblSpec *sqlparser.TableSpec) []vindexes.Column { cols := make([]vindexes.Column, 0, len(tblSpec.Columns)) for _, column := range tblSpec.Columns { colCollation := getColumnCollation(tblCollation, column) - size := getColumnNumber(column.Type.Length) - scale := getColumnNumber(column.Type.Scale) - nullable := getColumnNullable(column.Type.Options.Null) + size := ptr.Unwrap(column.Type.Length, 0) + scale := ptr.Unwrap(column.Type.Scale, 0) + nullable := ptr.Unwrap(column.Type.Options.Null, true) cols = append(cols, vindexes.Column{ Name: column.Name, @@ -325,8 +325,8 @@ func getColumns(tblSpec *sqlparser.TableSpec) []vindexes.Column { CollationName: colCollation, Default: column.Type.Options.Default, Invisible: column.Type.Invisible(), - Size: size, - Scale: scale, + Size: int32(size), + Scale: int32(scale), Nullable: nullable, Values: column.Type.EnumValues, }) @@ -334,27 +334,6 @@ func getColumns(tblSpec *sqlparser.TableSpec) []vindexes.Column { return cols } -func getColumnNullable(null *bool) bool { - if null == nil { - return true - } - return *null -} - -func getColumnNumber(lit *sqlparser.Literal) int32 { - if lit == nil { - return 0 - } - if lit.Type != sqlparser.IntVal { - return 0 - } - val, err := strconv.ParseInt(lit.Val, 10, 32) - if err != nil { - return 0 - } - return int32(val) -} - func getForeignKeys(tblSpec *sqlparser.TableSpec) []*sqlparser.ForeignKeyDefinition { if tblSpec.Constraints == nil { return nil From daba1a0740c996959b98c0f5049b60626b4864e2 Mon Sep 17 00:00:00 2001 From: Harshit Gangal Date: Fri, 16 Feb 2024 21:57:06 +0530 Subject: [PATCH 26/79] Delete with subquery support (#15219) Signed-off-by: Harshit Gangal --- changelog/20.0/20.0.0/summary.md | 8 + .../endtoend/vtgate/queries/dml/dml_test.go | 89 ++++++ go/vt/vtgate/planbuilder/delete.go | 14 - .../planbuilder/operator_transformers.go | 4 + go/vt/vtgate/planbuilder/operators/delete.go | 46 +-- .../planbuilder/operators/dml_planning.go | 4 - go/vt/vtgate/planbuilder/operators/update.go | 15 +- go/vt/vtgate/planbuilder/plan_test.go | 1 + .../planbuilder/testdata/dml_cases.json | 293 +++++++++++++++++- .../testdata/unsupported_cases.json | 20 -- 10 files changed, 427 insertions(+), 67 deletions(-) diff --git a/changelog/20.0/20.0.0/summary.md b/changelog/20.0/20.0.0/summary.md index b30ec93d400..54179429bd5 100644 --- a/changelog/20.0/20.0.0/summary.md +++ b/changelog/20.0/20.0.0/summary.md @@ -7,6 +7,7 @@ - [Vindex Hints](#vindex-hints) - [Update with Limit Support](#update-limit) - [Update with Multi Table Support](#multi-table-update) + - [Delete with Subquery Support](#delete-subquery) - **[Flag changes](#flag-changes)** - [`pprof-http` default change](#pprof-http-default) - **[Minor Changes](#minor-changes)** @@ -45,6 +46,13 @@ Example: `update t1 join t2 on t1.id = t2.id join t3 on t1.col = t3.col set t1.b More details about how it works is available in [MySQL Docs](https://dev.mysql.com/doc/refman/8.0/en/update.html) +#### Delete with Subquery Support + +Support is added for sharded table delete with subquery + +Example: `delete from t1 where id in (select col from t2 where foo = 32 and bar = 43)` + + ### Flag Changes #### `pprof-http` Default Change diff --git a/go/test/endtoend/vtgate/queries/dml/dml_test.go b/go/test/endtoend/vtgate/queries/dml/dml_test.go index f23320a3fe9..561d73f44d5 100644 --- a/go/test/endtoend/vtgate/queries/dml/dml_test.go +++ b/go/test/endtoend/vtgate/queries/dml/dml_test.go @@ -204,3 +204,92 @@ func TestUpdateWithLimit(t *testing.T) { require.EqualValues(t, 0, qr.RowsAffected) } + +// TestMultiTableUpdate executed multi-table update queries +func TestMultiTableUpdate(t *testing.T) { + utils.SkipIfBinaryIsBelowVersion(t, 20, "vtgate") + + mcmp, closer := start(t) + defer closer() + + // initial rows + mcmp.Exec("insert into order_tbl(region_id, oid, cust_no) values (1,1,4), (1,2,2), (2,3,5), (2,4,55)") + mcmp.Exec("insert into oevent_tbl(oid, ename) values (1,'a'), (2,'b'), (3,'a'), (4,'c')") + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[[INT64(1) VARCHAR("a")] [INT64(2) VARCHAR("b")] [INT64(3) VARCHAR("a")] [INT64(4) VARCHAR("c")]]`) + + // multi table delete + qr := mcmp.Exec(`update order_tbl o join oevent_tbl ev on o.oid = ev.oid set ev.ename = 'a' where ev.oid > 3`) + assert.EqualValues(t, 1, qr.RowsAffected) + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[[INT64(1) VARCHAR("a")] [INT64(2) VARCHAR("b")] [INT64(3) VARCHAR("a")] [INT64(4) VARCHAR("a")]]`) + + qr = mcmp.Exec(`update order_tbl o, oevent_tbl ev set ev.ename = 'xyz' where o.cust_no = ev.oid`) + assert.EqualValues(t, 2, qr.RowsAffected) + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[[INT64(1) VARCHAR("a")] [INT64(2) VARCHAR("xyz")] [INT64(3) VARCHAR("a")] [INT64(4) VARCHAR("xyz")]]`) +} + +// TestDeleteWithSubquery executed delete queries with subqueries +func TestDeleteWithSubquery(t *testing.T) { + utils.SkipIfBinaryIsBelowVersion(t, 20, "vtgate") + + mcmp, closer := start(t) + defer closer() + + // initial rows + mcmp.Exec("insert into s_tbl(id, num) values (1,10), (2,10), (3,10), (4,20), (5,5), (6,15), (7,17), (8,80)") + mcmp.Exec("insert into order_tbl(region_id, oid, cust_no) values (1,1,4), (1,2,2), (2,3,5), (2,4,55)") + + // check rows + mcmp.AssertMatches(`select id, num from s_tbl order by id`, + `[[INT64(1) INT64(10)] [INT64(2) INT64(10)] [INT64(3) INT64(10)] [INT64(4) INT64(20)] [INT64(5) INT64(5)] [INT64(6) INT64(15)] [INT64(7) INT64(17)] [INT64(8) INT64(80)]]`) + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + + // delete with subquery on s_tbl + qr := mcmp.Exec(`delete from s_tbl where id in (select oid from order_tbl)`) + require.EqualValues(t, 4, qr.RowsAffected) + + // check rows + mcmp.AssertMatches(`select id, num from s_tbl order by id`, + `[[INT64(5) INT64(5)] [INT64(6) INT64(15)] [INT64(7) INT64(17)] [INT64(8) INT64(80)]]`) + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + + // delete with subquery on order_tbl + qr = mcmp.Exec(`delete from order_tbl where cust_no > (select num from s_tbl where id = 7)`) + require.EqualValues(t, 1, qr.RowsAffected) + + // check rows + mcmp.AssertMatches(`select id, num from s_tbl order by id`, + `[[INT64(5) INT64(5)] [INT64(6) INT64(15)] [INT64(7) INT64(17)] [INT64(8) INT64(80)]]`) + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)]]`) + + // delete with subquery from same table (fails on mysql) - subquery get's merged so fails for vitess + _, err := mcmp.ExecAllowAndCompareError(`delete from s_tbl where id in (select id from s_tbl)`) + require.ErrorContains(t, err, "You can't specify target table 's_tbl' for update in FROM clause (errno 1093) (sqlstate HY000)") + + // delete with subquery from same table (fails on mysql) - subquery not merged so passes for vitess + qr = utils.Exec(t, mcmp.VtConn, `delete from order_tbl where region_id in (select cust_no from order_tbl)`) + require.EqualValues(t, 1, qr.RowsAffected) + + // check rows + utils.AssertMatches(t, mcmp.VtConn, `select id, num from s_tbl order by id`, + `[[INT64(5) INT64(5)] [INT64(6) INT64(15)] [INT64(7) INT64(17)] [INT64(8) INT64(80)]]`) + utils.AssertMatches(t, mcmp.VtConn, `select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)]]`) +} diff --git a/go/vt/vtgate/planbuilder/delete.go b/go/vt/vtgate/planbuilder/delete.go index 3fb4937ff97..a613c158ab7 100644 --- a/go/vt/vtgate/planbuilder/delete.go +++ b/go/vt/vtgate/planbuilder/delete.go @@ -144,19 +144,5 @@ func checkIfDeleteSupported(del *sqlparser.Delete, semTable *semantics.SemTable) return vterrors.VT12001("multi-table DELETE statement with multi-target") } - err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) { - switch node.(type) { - case *sqlparser.Subquery, *sqlparser.DerivedTable: - // We have a subquery, so we must fail the planning. - // If this subquery and the table expression were all belonging to the same unsharded keyspace, - // we would have already created a plan for them before doing these checks. - return false, vterrors.VT12001("subqueries in DML") - } - return true, nil - }, del) - if err != nil { - return err - } - return nil } diff --git a/go/vt/vtgate/planbuilder/operator_transformers.go b/go/vt/vtgate/planbuilder/operator_transformers.go index 674849ffc61..577e585351d 100644 --- a/go/vt/vtgate/planbuilder/operator_transformers.go +++ b/go/vt/vtgate/planbuilder/operator_transformers.go @@ -688,6 +688,8 @@ func buildUpdateLogicalPlan( var vindexes []*vindexes.ColumnVindex vQuery := "" if len(upd.ChangedVindexValues) > 0 { + upd.OwnedVindexQuery.From = stmt.GetFrom() + upd.OwnedVindexQuery.Where = stmt.Where vQuery = sqlparser.String(upd.OwnedVindexQuery) vindexes = upd.Target.VTable.ColumnVindexes if upd.OwnedVindexQuery.Limit != nil && len(upd.OwnedVindexQuery.OrderBy) == 0 { @@ -709,6 +711,8 @@ func buildDeleteLogicalPlan(ctx *plancontext.PlanningContext, rb *operators.Rout var vindexes []*vindexes.ColumnVindex vQuery := "" if del.OwnedVindexQuery != nil { + del.OwnedVindexQuery.From = stmt.GetFrom() + del.OwnedVindexQuery.Where = stmt.Where vQuery = sqlparser.String(del.OwnedVindexQuery) vindexes = del.Target.VTable.Owned } diff --git a/go/vt/vtgate/planbuilder/operators/delete.go b/go/vt/vtgate/planbuilder/operators/delete.go index 7a497d5511c..c22da14c35f 100644 --- a/go/vt/vtgate/planbuilder/operators/delete.go +++ b/go/vt/vtgate/planbuilder/operators/delete.go @@ -74,7 +74,15 @@ func (d *Delete) GetOrdering(*plancontext.PlanningContext) []OrderBy { func (d *Delete) ShortDescription() string { ovq := "" if d.OwnedVindexQuery != nil { - ovq = " vindexQuery:%s" + sqlparser.String(d.OwnedVindexQuery) + var cols, orderby, limit string + cols = fmt.Sprintf("COLUMNS: [%s]", sqlparser.String(d.OwnedVindexQuery.SelectExprs)) + if len(d.OwnedVindexQuery.OrderBy) > 0 { + orderby = fmt.Sprintf(" ORDERBY: [%s]", sqlparser.String(d.OwnedVindexQuery.OrderBy)) + } + if d.OwnedVindexQuery.Limit != nil { + limit = fmt.Sprintf(" LIMIT: [%s]", sqlparser.String(d.OwnedVindexQuery.Limit)) + } + ovq = fmt.Sprintf(" vindexQuery(%s%s%s)", cols, orderby, limit) } return fmt.Sprintf("%s.%s%s", d.Target.VTable.Keyspace.Name, d.Target.VTable.Name.String(), ovq) } @@ -90,8 +98,8 @@ func createOperatorFromDelete(ctx *plancontext.PlanningContext, deleteStmt *sqlp } delClone := sqlparser.CloneRefOfDelete(deleteStmt) - delOp := createDeleteOperator(ctx, deleteStmt) - op = delOp + var vTbl *vindexes.Table + op, vTbl = createDeleteOperator(ctx, deleteStmt) if deleteStmt.Comments != nil { op = &LockAndComment{ @@ -105,7 +113,7 @@ func createOperatorFromDelete(ctx *plancontext.PlanningContext, deleteStmt *sqlp return op } - return createFkCascadeOpForDelete(ctx, op, delClone, childFks, delOp.Target.VTable) + return createFkCascadeOpForDelete(ctx, op, delClone, childFks, vTbl) } func deleteWithInputPlanningRequired(childFks []vindexes.ChildFKInfo, deleteStmt *sqlparser.Delete) bool { @@ -170,11 +178,12 @@ func deleteWithInputPlanningForFk(ctx *plancontext.PlanningContext, del *sqlpars } } -func createDeleteOperator(ctx *plancontext.PlanningContext, del *sqlparser.Delete) *Delete { +func createDeleteOperator(ctx *plancontext.PlanningContext, del *sqlparser.Delete) (Operator, *vindexes.Table) { op := crossJoin(ctx, del.TableExprs) + sqc := &SubQueryBuilder{} if del.Where != nil { - op = addWherePredicates(ctx, del.Where.Expr, op) + op = addWherePredsToSubQueryBuilder(ctx, del.Where.Expr, op, sqc) } target := del.Targets[0] @@ -207,9 +216,8 @@ func createDeleteOperator(ctx *plancontext.PlanningContext, del *sqlparser.Delet var ovq *sqlparser.Select if vTbl.Keyspace.Sharded && vTbl.Type == vindexes.TypeTable { primaryVindex, _ := getVindexInformation(tblID, vTbl) - ate := tblInfo.GetAliasedTableExpr() if len(vTbl.Owned) > 0 { - ovq = generateOwnedVindexQuery(ate, del, targetTbl, primaryVindex.Columns) + ovq = generateOwnedVindexQuery(del, targetTbl, primaryVindex.Columns) } } @@ -222,21 +230,18 @@ func createDeleteOperator(ctx *plancontext.PlanningContext, del *sqlparser.Delet }, } - if del.Limit == nil { - return delOp - } - - addOrdering(ctx, del.OrderBy, delOp) - - delOp.Source = &Limit{ - Source: delOp.Source, - AST: del.Limit, + if del.Limit != nil { + addOrdering(ctx, del.OrderBy, delOp) + delOp.Source = &Limit{ + Source: delOp.Source, + AST: del.Limit, + } } - return delOp + return sqc.getRootOperator(delOp, nil), vTbl } -func generateOwnedVindexQuery(tblExpr sqlparser.TableExpr, del *sqlparser.Delete, table TargetTable, ksidCols []sqlparser.IdentifierCI) *sqlparser.Select { +func generateOwnedVindexQuery(del *sqlparser.Delete, table TargetTable, ksidCols []sqlparser.IdentifierCI) *sqlparser.Select { var selExprs sqlparser.SelectExprs for _, col := range ksidCols { colName := makeColName(col, table, sqlparser.MultiTable(del.TableExprs)) @@ -248,11 +253,8 @@ func generateOwnedVindexQuery(tblExpr sqlparser.TableExpr, del *sqlparser.Delete selExprs = append(selExprs, aeWrap(colName)) } } - sqlparser.RemoveKeyspaceInTables(tblExpr) return &sqlparser.Select{ SelectExprs: selExprs, - From: del.TableExprs, - Where: del.Where, OrderBy: del.OrderBy, Limit: del.Limit, Lock: sqlparser.ForUpdateLock, diff --git a/go/vt/vtgate/planbuilder/operators/dml_planning.go b/go/vt/vtgate/planbuilder/operators/dml_planning.go index ed777428381..6f71b41162e 100644 --- a/go/vt/vtgate/planbuilder/operators/dml_planning.go +++ b/go/vt/vtgate/planbuilder/operators/dml_planning.go @@ -109,7 +109,6 @@ func buildChangedVindexesValues( ctx *plancontext.PlanningContext, update *sqlparser.Update, table *vindexes.Table, - ate *sqlparser.AliasedTableExpr, ksidCols []sqlparser.IdentifierCI, assignments []SetExpr, ) (vv map[string]*engine.VindexValues, ownedVindexQuery *sqlparser.Select, subQueriesArgOnChangedVindex []string) { @@ -145,11 +144,8 @@ func buildChangedVindexesValues( return nil, nil, nil } // generate rest of the owned vindex query. - tblExpr := sqlparser.NewAliasedTableExpr(sqlparser.TableName{Name: table.Name}, ate.As.String()) ovq := &sqlparser.Select{ - From: []sqlparser.TableExpr{tblExpr}, SelectExprs: selExprs, - Where: update.Where, OrderBy: update.OrderBy, Limit: update.Limit, Lock: sqlparser.ForUpdateLock, diff --git a/go/vt/vtgate/planbuilder/operators/update.go b/go/vt/vtgate/planbuilder/operators/update.go index 5fc7dc0d4a7..cf55f91fddd 100644 --- a/go/vt/vtgate/planbuilder/operators/update.go +++ b/go/vt/vtgate/planbuilder/operators/update.go @@ -97,7 +97,15 @@ func (u *Update) TablesUsed() []string { func (u *Update) ShortDescription() string { ovq := "" if u.OwnedVindexQuery != nil { - ovq = " vindexQuery:%s" + sqlparser.String(u.OwnedVindexQuery) + var cols, orderby, limit string + cols = fmt.Sprintf("COLUMNS: [%s]", sqlparser.String(u.OwnedVindexQuery.SelectExprs)) + if len(u.OwnedVindexQuery.OrderBy) > 0 { + orderby = fmt.Sprintf(" ORDERBY: [%s]", sqlparser.String(u.OwnedVindexQuery.OrderBy)) + } + if u.OwnedVindexQuery.Limit != nil { + limit = fmt.Sprintf(" LIMIT: [%s]", sqlparser.String(u.OwnedVindexQuery.Limit)) + } + ovq = fmt.Sprintf(" vindexQuery(%s%s%s)", cols, orderby, limit) } return fmt.Sprintf("%s.%s%s", u.Target.VTable.Keyspace.Name, u.Target.VTable.Name.String(), ovq) } @@ -217,7 +225,7 @@ func createUpdateOperator(ctx *plancontext.PlanningContext, updStmt *sqlparser.U Name: name, } - _, cvv, ovq, subQueriesArgOnChangedVindex := getUpdateVindexInformation(ctx, updStmt, targetTbl, tblInfo.GetAliasedTableExpr(), assignments) + _, cvv, ovq, subQueriesArgOnChangedVindex := getUpdateVindexInformation(ctx, updStmt, targetTbl, assignments) updOp := &Update{ DMLCommon: &DMLCommon{ @@ -249,7 +257,6 @@ func getUpdateVindexInformation( ctx *plancontext.PlanningContext, updStmt *sqlparser.Update, table TargetTable, - ate *sqlparser.AliasedTableExpr, assignments []SetExpr, ) ([]*VindexPlusPredicates, map[string]*engine.VindexValues, *sqlparser.Select, []string) { if !table.VTable.Keyspace.Sharded { @@ -257,7 +264,7 @@ func getUpdateVindexInformation( } primaryVindex, vindexAndPredicates := getVindexInformation(table.ID, table.VTable) - changedVindexValues, ownedVindexQuery, subQueriesArgOnChangedVindex := buildChangedVindexesValues(ctx, updStmt, table.VTable, ate, primaryVindex.Columns, assignments) + changedVindexValues, ownedVindexQuery, subQueriesArgOnChangedVindex := buildChangedVindexesValues(ctx, updStmt, table.VTable, primaryVindex.Columns, assignments) return vindexAndPredicates, changedVindexValues, ownedVindexQuery, subQueriesArgOnChangedVindex } diff --git a/go/vt/vtgate/planbuilder/plan_test.go b/go/vt/vtgate/planbuilder/plan_test.go index 8d339eb52ee..e7c18af1d4c 100644 --- a/go/vt/vtgate/planbuilder/plan_test.go +++ b/go/vt/vtgate/planbuilder/plan_test.go @@ -279,6 +279,7 @@ func TestOne(t *testing.T) { lv := loadSchema(t, "vschemas/schema.json", true) setFks(t, lv) addPKs(t, lv, "user", []string{"user", "music"}) + addPKs(t, lv, "main", []string{"unsharded"}) vschema := &vschemawrapper.VSchemaWrapper{ V: lv, TestBuilder: TestBuilder, diff --git a/go/vt/vtgate/planbuilder/testdata/dml_cases.json b/go/vt/vtgate/planbuilder/testdata/dml_cases.json index 18ba14db06e..6fbc31eb84d 100644 --- a/go/vt/vtgate/planbuilder/testdata/dml_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/dml_cases.json @@ -5012,7 +5012,7 @@ "TargetTabletType": "PRIMARY", "KsidLength": 1, "KsidVindex": "user_index", - "OwnedVindexQuery": "select u.Id, u.`Name`, u.Costly from `user` as u join ref_with_source as r on u.col = r.col for update", + "OwnedVindexQuery": "select u.Id, u.`Name`, u.Costly from `user` as u, ref_with_source as r where u.col = r.col for update", "Query": "delete u from `user` as u, ref_with_source as r where u.col = r.col", "Table": "user" }, @@ -5038,7 +5038,7 @@ "TargetTabletType": "PRIMARY", "KsidLength": 1, "KsidVindex": "user_index", - "OwnedVindexQuery": "select u.Id, u.`Name`, u.Costly from `user` as u join music as m on u.id = m.user_id for update", + "OwnedVindexQuery": "select u.Id, u.`Name`, u.Costly from `user` as u, music as m where u.id = m.user_id for update", "Query": "delete u from `user` as u, music as m where u.id = m.user_id", "Table": "user" }, @@ -5284,7 +5284,7 @@ "TargetTabletType": "PRIMARY", "KsidLength": 1, "KsidVindex": "user_index", - "OwnedVindexQuery": "select u.Id, u.`Name`, u.Costly from `user` as u join music as m where u.id = m.user_id and m.foo = 42 for update", + "OwnedVindexQuery": "select u.Id, u.`Name`, u.Costly from `user` as u, music as m where m.foo = 42 and u.id = m.user_id for update", "Query": "delete u from `user` as u, music as m where m.foo = 42 and u.id = m.user_id", "Table": "user" }, @@ -5901,5 +5901,292 @@ "user.music" ] } + }, + { + "comment": "sharded subquery in sharded delete", + "query": "delete from user where id = (select id from music where user_id = 1)", + "plan": { + "QueryType": "DELETE", + "Original": "delete from user where id = (select id from music where user_id = 1)", + "Instructions": { + "OperatorType": "UncorrelatedSubquery", + "Variant": "PulloutValue", + "PulloutVars": [ + "__sq1" + ], + "Inputs": [ + { + "InputName": "SubQuery", + "OperatorType": "Route", + "Variant": "EqualUnique", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select id from music where 1 != 1", + "Query": "select id from music where user_id = 1", + "Table": "music", + "Values": [ + "1" + ], + "Vindex": "user_index" + }, + { + "InputName": "Outer", + "OperatorType": "Delete", + "Variant": "EqualUnique", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly from `user` where id = :__sq1 for update", + "Query": "delete from `user` where id = :__sq1", + "Table": "user", + "Values": [ + ":__sq1" + ], + "Vindex": "user_index" + } + ] + }, + "TablesUsed": [ + "user.music", + "user.user" + ] + } + }, + { + "comment": "unsharded subquery in sharded delete", + "query": "delete from user where col = (select id from unsharded)", + "plan": { + "QueryType": "DELETE", + "Original": "delete from user where col = (select id from unsharded)", + "Instructions": { + "OperatorType": "UncorrelatedSubquery", + "Variant": "PulloutValue", + "PulloutVars": [ + "__sq1" + ], + "Inputs": [ + { + "InputName": "SubQuery", + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "FieldQuery": "select id from unsharded where 1 != 1", + "Query": "select id from unsharded", + "Table": "unsharded" + }, + { + "InputName": "Outer", + "OperatorType": "Delete", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly from `user` where col = :__sq1 for update", + "Query": "delete from `user` where col = :__sq1", + "Table": "user" + } + ] + }, + "TablesUsed": [ + "main.unsharded", + "user.user" + ] + } + }, + { + "comment": "sharded subquery in unsharded delete", + "query": "delete from unsharded where col = (select id from user)", + "plan": { + "QueryType": "DELETE", + "Original": "delete from unsharded where col = (select id from user)", + "Instructions": { + "OperatorType": "UncorrelatedSubquery", + "Variant": "PulloutValue", + "PulloutVars": [ + "__sq1" + ], + "Inputs": [ + { + "InputName": "SubQuery", + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select id from `user` where 1 != 1", + "Query": "select id from `user`", + "Table": "`user`" + }, + { + "InputName": "Outer", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from unsharded where col = :__sq1", + "Table": "unsharded" + } + ] + }, + "TablesUsed": [ + "main.unsharded", + "user.user" + ] + } + }, + { + "comment": "sharded subquery in unsharded subquery in unsharded delete", + "query": "delete from unsharded where col = (select id from unsharded where id = (select id from user))", + "plan": { + "QueryType": "DELETE", + "Original": "delete from unsharded where col = (select id from unsharded where id = (select id from user))", + "Instructions": { + "OperatorType": "UncorrelatedSubquery", + "Variant": "PulloutValue", + "PulloutVars": [ + "__sq1" + ], + "Inputs": [ + { + "InputName": "SubQuery", + "OperatorType": "UncorrelatedSubquery", + "Variant": "PulloutValue", + "PulloutVars": [ + "__sq2" + ], + "Inputs": [ + { + "InputName": "SubQuery", + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select id from `user` where 1 != 1", + "Query": "select id from `user`", + "Table": "`user`" + }, + { + "InputName": "Outer", + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "FieldQuery": "select id from unsharded where 1 != 1", + "Query": "select id from unsharded where id = :__sq2", + "Table": "unsharded" + } + ] + }, + { + "InputName": "Outer", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from unsharded where col = :__sq1", + "Table": "unsharded" + } + ] + }, + "TablesUsed": [ + "main.unsharded", + "user.user" + ] + } + }, + { + "comment": "sharded join unsharded subquery in unsharded delete", + "query": "delete from unsharded where col = (select id from unsharded join user on unsharded.id = user.id)", + "plan": { + "QueryType": "DELETE", + "Original": "delete from unsharded where col = (select id from unsharded join user on unsharded.id = user.id)", + "Instructions": { + "OperatorType": "UncorrelatedSubquery", + "Variant": "PulloutValue", + "PulloutVars": [ + "__sq1" + ], + "Inputs": [ + { + "InputName": "SubQuery", + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "R:0", + "JoinVars": { + "unsharded_id": 0 + }, + "TableName": "unsharded_`user`", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "FieldQuery": "select unsharded.id from unsharded where 1 != 1", + "Query": "select unsharded.id from unsharded", + "Table": "unsharded" + }, + { + "OperatorType": "Route", + "Variant": "EqualUnique", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select id from `user` where 1 != 1", + "Query": "select id from `user` where `user`.id = :unsharded_id", + "Table": "`user`", + "Values": [ + ":unsharded_id" + ], + "Vindex": "user_index" + } + ] + }, + { + "InputName": "Outer", + "OperatorType": "Delete", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from unsharded where col = :__sq1", + "Table": "unsharded" + } + ] + }, + "TablesUsed": [ + "main.unsharded", + "user.user" + ] + } } ] diff --git a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json index 4214a396499..5c8bcad0c57 100644 --- a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json @@ -19,26 +19,6 @@ "query": "select id from user group by id, (select id from user_extra)", "plan": "VT12001: unsupported: subqueries in GROUP BY" }, - { - "comment": "subqueries in delete", - "query": "delete from user where col = (select id from unsharded)", - "plan": "VT12001: unsupported: subqueries in DML" - }, - { - "comment": "sharded subqueries in unsharded delete", - "query": "delete from unsharded where col = (select id from user)", - "plan": "VT12001: unsupported: subqueries in DML" - }, - { - "comment": "sharded subquery in unsharded subquery in unsharded delete", - "query": "delete from unsharded where col = (select id from unsharded where id = (select id from user))", - "plan": "VT12001: unsupported: subqueries in DML" - }, - { - "comment": "sharded join unsharded subqueries in unsharded delete", - "query": "delete from unsharded where col = (select id from unsharded join user on unsharded.id = user.id)", - "plan": "VT12001: unsupported: subqueries in DML" - }, { "comment": "update changes primary vindex column", "query": "update user set id = 1 where id = 1", From 2929deecbcdad21ca991cff62db8205e78cc4452 Mon Sep 17 00:00:00 2001 From: Rohit Nayak <57520317+rohit-nayak-ps@users.noreply.github.com> Date: Fri, 16 Feb 2024 18:32:03 +0100 Subject: [PATCH 27/79] VStreamer Unit Tests: framework to remove the need to specify serialized strings in row events for unit tests (#14903) Signed-off-by: Rohit Nayak --- go.mod | 2 +- go/cmd/vtadmin/main.go | 2 - go/vt/vtgate/executor.go | 9 +- .../vreplication/vplayer_flaky_test.go | 3 - .../vstreamer/helper_event_test.go | 589 ++++++++++++++++ .../tabletserver/vstreamer/testenv/testenv.go | 6 +- .../vstreamer/uvstreamer_flaky_test.go | 4 +- ...reamer_flaky_test.go => vstreamer_test.go} | 652 +++++++----------- tools/rowlog/rowlog.go | 1 - 9 files changed, 862 insertions(+), 406 deletions(-) create mode 100644 go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go rename go/vt/vttablet/tabletserver/vstreamer/{vstreamer_flaky_test.go => vstreamer_test.go} (82%) diff --git a/go.mod b/go.mod index 9963f901765..f0fc8237ed8 100644 --- a/go.mod +++ b/go.mod @@ -50,7 +50,7 @@ require ( github.com/planetscale/pargzip v0.0.0-20201116224723-90c7fc03ea8a github.com/planetscale/vtprotobuf v0.5.0 github.com/prometheus/client_golang v1.18.0 - github.com/prometheus/common v0.46.0 // indirect + github.com/prometheus/common v0.46.0 github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 github.com/sjmudd/stopwatch v0.1.1 github.com/soheilhy/cmux v0.1.5 diff --git a/go/cmd/vtadmin/main.go b/go/cmd/vtadmin/main.go index 2548986c2ba..6cc3b9065b5 100644 --- a/go/cmd/vtadmin/main.go +++ b/go/cmd/vtadmin/main.go @@ -221,8 +221,6 @@ func main() { if err := rootCmd.Execute(); err != nil { log.Fatal(err) } - - log.Flush() } type noopCloser struct{} diff --git a/go/vt/vtgate/executor.go b/go/vt/vtgate/executor.go index 867685b8fec..520214d65fd 100644 --- a/go/vt/vtgate/executor.go +++ b/go/vt/vtgate/executor.go @@ -30,15 +30,12 @@ import ( "github.com/spf13/pflag" - "vitess.io/vitess/go/cache/theine" - "vitess.io/vitess/go/streamlog" - "vitess.io/vitess/go/vt/vtenv" - "vitess.io/vitess/go/vt/vthash" - "vitess.io/vitess/go/acl" + "vitess.io/vitess/go/cache/theine" "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/stats" + "vitess.io/vitess/go/streamlog" "vitess.io/vitess/go/trace" "vitess.io/vitess/go/vt/callerid" "vitess.io/vitess/go/vt/key" @@ -53,6 +50,7 @@ import ( "vitess.io/vitess/go/vt/srvtopo" "vitess.io/vitess/go/vt/sysvars" "vitess.io/vitess/go/vt/topo/topoproto" + "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vtgate/engine" "vitess.io/vitess/go/vt/vtgate/evalengine" @@ -62,6 +60,7 @@ import ( "vitess.io/vitess/go/vt/vtgate/vindexes" "vitess.io/vitess/go/vt/vtgate/vschemaacl" "vitess.io/vitess/go/vt/vtgate/vtgateservice" + "vitess.io/vitess/go/vt/vthash" ) var ( diff --git a/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go b/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go index dd51fb6c042..d9b68d052c3 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vplayer_flaky_test.go @@ -186,7 +186,6 @@ func TestPlayerInvisibleColumns(t *testing.T) { output := qh.Expect(tcases.output) expectNontxQueries(t, output) time.Sleep(1 * time.Second) - log.Flush() if tcases.table != "" { expectData(t, tcases.table, tcases.data) } @@ -3094,7 +3093,6 @@ func TestPlayerNoBlob(t *testing.T) { output := qh.Expect(tcases.output) expectNontxQueries(t, output) time.Sleep(1 * time.Second) - log.Flush() if tcases.table != "" { expectData(t, tcases.table, tcases.data) } @@ -3333,7 +3331,6 @@ func TestPlayerBatchMode(t *testing.T) { } expectNontxQueries(t, output) time.Sleep(1 * time.Second) - log.Flush() if tcase.table != "" { expectData(t, tcase.table, tcase.data) } diff --git a/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go b/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go new file mode 100644 index 00000000000..cc586756fe8 --- /dev/null +++ b/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go @@ -0,0 +1,589 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package vstreamer + +// This file contains the test framework for testing the event generation logic in vstreamer. +// The test framework is designed to be used in the following way: +// 1. Define a TestSpec with the following fields: +// - ddls: a list of create table statements for the tables to be used in the test +// - tests: a list of test cases, each test case is a list of TestQuery +// - options: test-specific options, if any +// 2. Call ts.Init() to initialize the test. +// 3. Call ts.Run() to run the test. This will run the queries and validate the events. +// 4. Call ts.Close() to clean up the tables created in the test. +// The test framework will take care of creating the tables, running the queries, and validating the events for +// simpler cases. For more complex cases, the test framework provides hooks to customize the event generation. + +// Note: To simplify the initial implementation, the test framework is designed to be used in the vstreamer package only. +// It makes several assumptions about how the test cases are written. For example, queries are expected to +// use single quotes for string literals, for example: +// `"insert into t1 values (1, 'blob1', 'aaa')"`. +// The test framework will not work if the queries use double quotes for string literals at the moment. + +import ( + "context" + "fmt" + "slices" + "strconv" + "strings" + "testing" + + "github.com/stretchr/testify/require" + + "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/vt/log" + "vitess.io/vitess/go/vt/proto/binlogdata" + "vitess.io/vitess/go/vt/proto/query" + "vitess.io/vitess/go/vt/schemadiff" + "vitess.io/vitess/go/vt/sqlparser" + "vitess.io/vitess/go/vt/vttablet/tabletserver/vstreamer/testenv" +) + +const ( + lengthInt = 11 + lengthBlob = 65535 + lengthText = 262140 + lengthSet = 56 +) + +func getDefaultCollationID() int64 { + return 45 +} + +var ( + // noEvents is used to indicate that a query is expected to generate no events. + noEvents = []TestRowEvent{} +) + +// TestColumn has all the attributes of a column required for the test cases. +type TestColumn struct { + name, dataType, colType string + len, collationID int64 + dataTypeLowered string + skip bool + collationName string +} + +// TestFieldEvent has all the attributes of a table required for creating a field event. +type TestFieldEvent struct { + table, db string + cols []*TestColumn +} + +// TestQuery represents a database query and the expected events it generates. +type TestQuery struct { + query string + events []TestRowEvent +} + +// TestRowChange represents the before and after state of a row due to a dml +type TestRowChange struct { + before []string + after []string +} + +// TestRowEventSpec is used for defining a custom row event. +type TestRowEventSpec struct { + table string + changes []TestRowChange +} + +// Generates a string representation for a custom row event. +func (s *TestRowEventSpec) String() string { + ev := &binlogdata.RowEvent{ + TableName: s.table, + } + var rowChanges []*binlogdata.RowChange + if s.changes != nil && len(s.changes) > 0 { + for _, c := range s.changes { + rowChange := binlogdata.RowChange{} + if c.before != nil && len(c.before) > 0 { + rowChange.Before = &query.Row{} + for _, val := range c.before { + rowChange.Before.Lengths = append(rowChange.Before.Lengths, int64(len(val))) + rowChange.Before.Values = append(rowChange.Before.Values, []byte(val)...) + } + } + if c.after != nil && len(c.after) > 0 { + rowChange.After = &query.Row{} + for _, val := range c.after { + rowChange.After.Lengths = append(rowChange.After.Lengths, int64(len(val))) + rowChange.After.Values = append(rowChange.After.Values, []byte(val)...) + } + } + rowChanges = append(rowChanges, &rowChange) + } + ev.RowChanges = rowChanges + } + vEvent := &binlogdata.VEvent{ + Type: binlogdata.VEventType_ROW, + RowEvent: ev, + } + return vEvent.String() +} + +// TestRowEvent is used to define either the actual row event string (the `event` field) or a custom row event +// (the `spec` field). Only one should be specified. If a test validates `flags` of a RowEvent then it is set. +type TestRowEvent struct { + event string + spec *TestRowEventSpec + flags int +} + +// TestSpecOptions has any non-standard test-specific options which can modify the event generation behaviour. +type TestSpecOptions struct { + noblob bool + filter *binlogdata.Filter +} + +// TestSpec is defined one per unit test. +type TestSpec struct { + // test=specific parameters + t *testing.T + ddls []string // create table statements + tests [][]*TestQuery // list of input queries and expected events for each query + options *TestSpecOptions // test-specific options + + // internal state + inited bool // whether the test has been initialized + tables []string // list of tables in the schema (created in `ddls`) + pkColumns map[string][]string // map of table name to primary key columns + schema *schemadiff.Schema // parsed schema from `ddls` using `schemadiff` + fieldEvents map[string]*TestFieldEvent // map of table name to field event for the table + fieldEventsSent map[string]bool // whether the field event has been sent for the table in the test + state map[string]*query.Row // last row inserted for each table. Useful to generate events only for inserts + metadata map[string][]string // list of enum/set values for enum/set columns +} + +func (ts *TestSpec) getCurrentState(table string) *query.Row { + return ts.state[table] +} + +func (ts *TestSpec) setCurrentState(table string, row *query.Row) { + ts.state[table] = row +} + +// Init() initializes the test. It creates the tables and sets up the internal state. +func (ts *TestSpec) Init() error { + var err error + if ts.inited { + return nil + } + defer func() { ts.inited = true }() + if ts.options == nil { + ts.options = &TestSpecOptions{} + } + ts.schema, err = schemadiff.NewSchemaFromQueries(schemadiff.NewTestEnv(), ts.ddls) + if err != nil { + return err + } + ts.fieldEvents = make(map[string]*TestFieldEvent) + ts.fieldEventsSent = make(map[string]bool) + ts.state = make(map[string]*query.Row) + ts.metadata = make(map[string][]string) + ts.pkColumns = make(map[string][]string) + // create tables + require.Equal(ts.t, len(ts.ddls), len(ts.schema.Tables()), "number of tables in ddls and schema do not match") + for i, t := range ts.schema.Tables() { + execStatement(ts.t, ts.ddls[i]) + fe := ts.getFieldEvent(t) + ts.fieldEvents[t.Name()] = fe + + var pkColumns []string + var hasPK bool + for _, index := range t.TableSpec.Indexes { + require.NotNil(ts.t, index.Info, "index.Info is nil") + if index.Info.Type == sqlparser.IndexTypePrimary { + for _, col := range index.Columns { + pkColumns = append(pkColumns, col.Column.String()) + } + hasPK = true + } + } + if !hasPK { + // add all columns as pk columns + for _, col := range t.TableSpec.Columns { + pkColumns = append(pkColumns, col.Name.String()) + } + } + ts.pkColumns[t.Name()] = pkColumns + } + engine.se.Reload(context.Background()) + return nil +} + +// Close() should be called (via defer) at the end of the test to clean up the tables created in the test. +func (ts *TestSpec) Close() { + dropStatement := fmt.Sprintf("drop tables %s", strings.Join(ts.schema.TableNames(), ", ")) + execStatement(ts.t, dropStatement) +} + +func (ts *TestSpec) getBindVarsForInsert(stmt sqlparser.Statement) (string, map[string]string) { + bv := make(map[string]string) + ins := stmt.(*sqlparser.Insert) + tn, err := ins.Table.TableName() + require.NoError(ts.t, err) + table := tn.Name.String() + fe := ts.fieldEvents[table] + vals, ok := ins.Rows.(sqlparser.Values) + require.True(ts.t, ok, "insert statement does not have values") + for _, val := range vals { + for i, v := range val { + bufV := sqlparser.NewTrackedBuffer(nil) + v.Format(bufV) + s := bufV.String() + switch fe.cols[i].dataTypeLowered { + case "varchar", "char", "binary", "varbinary", "blob", "text": + s = strings.Trim(s, "'") + case "set", "enum": + s = ts.getMetadataMap(table, fe.cols[i], s) + } + bv[fe.cols[i].name] = s + } + } + return table, bv +} + +func (ts *TestSpec) getBindVarsForUpdate(stmt sqlparser.Statement) (string, map[string]string) { + bv := make(map[string]string) + upd := stmt.(*sqlparser.Update) + //buf := sqlparser.NewTrackedBuffer(nil) + table := sqlparser.String(upd.TableExprs[0].(*sqlparser.AliasedTableExpr).Expr) + //upd.TableExprs[0].(*sqlparser.AliasedTableExpr).Expr.Format(buf) + //table := buf.String() + fe, ok := ts.fieldEvents[table] + require.True(ts.t, ok, "field event for table %s not found", table) + index := int64(0) + state := ts.getCurrentState(table) + for i, col := range fe.cols { + bv[col.name] = string(state.Values[index : index+state.Lengths[i]]) + index += state.Lengths[i] + } + for _, expr := range upd.Exprs { + bufV := sqlparser.NewTrackedBuffer(nil) + bufN := sqlparser.NewTrackedBuffer(nil) + expr.Expr.Format(bufV) + expr.Name.Format(bufN) + bv[bufN.String()] = strings.Trim(bufV.String(), "'") + } + return table, bv +} + +// Run() runs the test. It first initializes the test, then runs the queries and validates the events. +func (ts *TestSpec) Run() { + require.NoError(ts.t, engine.se.Reload(context.Background())) + if !ts.inited { + require.NoError(ts.t, ts.Init()) + } + var testcases []testcase + for _, t := range ts.tests { + var tc testcase + var input []string + var output []string + for _, tq := range t { + var table string + input = append(input, tq.query) + switch { + case tq.events != nil && len(tq.events) == 0: // when an input query is expected to generate no events + continue + case tq.events != nil && // when we define the actual events either as a serialized string or as a TestRowEvent + (len(tq.events) > 0 && + !(len(tq.events) == 1 && tq.events[0].event == "" && tq.events[0].spec == nil)): + for _, e := range tq.events { + if e.event != "" { + output = append(output, e.event) + } else if e.spec != nil { + output = append(output, e.spec.String()) + } else { + panic("invalid event") + } + } + continue + default: + // when we don't define the actual events, we generate them based on the input query + flags := 0 + if len(tq.events) == 1 { + flags = tq.events[0].flags + } + stmt, err := sqlparser.NewTestParser().Parse(tq.query) + require.NoError(ts.t, err) + bv := make(map[string]string) + isRowEvent := false + switch stmt.(type) { + case *sqlparser.Begin: + output = append(output, "begin") + case *sqlparser.Commit: + output = append(output, "gtid", "commit") + case *sqlparser.Insert: + isRowEvent = true + table, bv = ts.getBindVarsForInsert(stmt) + case *sqlparser.Update: + isRowEvent = true + table, bv = ts.getBindVarsForUpdate(stmt) + case *sqlparser.Delete: + isRowEvent = true + del := stmt.(*sqlparser.Delete) + table = del.TableExprs[0].(*sqlparser.AliasedTableExpr).As.String() + default: + require.FailNowf(ts.t, "unsupported statement type", "stmt: %s", stmt) + } + if isRowEvent { + fe := ts.fieldEvents[table] + if fe == nil { + require.FailNowf(ts.t, "field event for table %s not found", table) + } + if !ts.fieldEventsSent[table] { + output = append(output, fe.String()) + ts.fieldEventsSent[table] = true + } + output = append(output, ts.getRowEvent(table, bv, fe, stmt, uint32(flags))) + } + } + + } + tc.input = input + tc.output = append(tc.output, output) + testcases = append(testcases, tc) + } + runCases(ts.t, ts.options.filter, testcases, "current", nil) +} + +func (ts *TestSpec) getFieldEvent(table *schemadiff.CreateTableEntity) *TestFieldEvent { + var tfe TestFieldEvent + tfe.table = table.Name() + tfe.db = testenv.DBName + for _, col := range table.TableSpec.Columns { + tc := TestColumn{} + tc.name = col.Name.String() + sqlType := col.Type.SQLType() + tc.dataType = sqlType.String() + tc.dataTypeLowered = strings.ToLower(tc.dataType) + tc.collationName = col.Type.Options.Collate + switch tc.dataTypeLowered { + case "int32": + tc.len = lengthInt + tc.collationID = collations.CollationBinaryID + tc.colType = "int(11)" + case "varchar", "varbinary", "char", "binary": + l := *col.Type.Length + switch tc.dataTypeLowered { + case "binary", "varbinary": + tc.len = int64(l) + tc.collationID = collations.CollationBinaryID + default: + tc.len = 4 * int64(l) + tc.collationID = getDefaultCollationID() + if tc.dataTypeLowered == "char" && strings.Contains(tc.collationName, "bin") { + tc.dataType = "BINARY" + } + } + tc.colType = fmt.Sprintf("%s(%d)", tc.dataTypeLowered, l) + case "blob": + tc.len = lengthBlob + tc.collationID = collations.CollationBinaryID + tc.colType = "blob" + case "text": + tc.len = lengthText + tc.collationID = getDefaultCollationID() + tc.colType = "text" + case "set": + tc.len = lengthSet + tc.collationID = getDefaultCollationID() + tc.colType = fmt.Sprintf("%s(%s)", tc.dataTypeLowered, strings.Join(col.Type.EnumValues, ",")) + ts.metadata[getMetadataKey(table.Name(), tc.name)] = col.Type.EnumValues + case "enum": + tc.len = int64(len(col.Type.EnumValues) + 1) + tc.collationID = getDefaultCollationID() + tc.colType = fmt.Sprintf("%s(%s)", tc.dataTypeLowered, strings.Join(col.Type.EnumValues, ",")) + ts.metadata[getMetadataKey(table.Name(), tc.name)] = col.Type.EnumValues + default: + log.Infof(fmt.Sprintf("unknown sqlTypeString %s", tc.dataTypeLowered)) + } + tfe.cols = append(tfe.cols, &tc) + } + return &tfe +} + +func getMetadataKey(table, col string) string { + return fmt.Sprintf("%s:%s", table, col) +} + +func (ts *TestSpec) setMetadataMap(table, col, value string) { + values := strings.Split(value, ",") + valuesReversed := slices.Clone(values) + slices.Reverse(valuesReversed) + ts.metadata[getMetadataKey(table, col)] = valuesReversed +} + +func (ts *TestSpec) getMetadataMap(table string, col *TestColumn, value string) string { + var bits int64 + value = strings.Trim(value, "'") + meta := ts.metadata[getMetadataKey(table, col.name)] + values := strings.Split(value, ",") + for _, v := range values { + v2 := strings.Trim(v, "'") + for i, m := range meta { + m2 := strings.Trim(m, "'") + if m2 == v2 { + switch col.dataTypeLowered { + case "set": + bits |= 1 << uint(i) + case "enum": + bits = int64(i) + 1 + } + } + } + } + return strconv.FormatInt(bits, 10) +} + +func (ts *TestSpec) getRowEvent(table string, bv map[string]string, fe *TestFieldEvent, stmt sqlparser.Statement, flags uint32) string { + ev := &binlogdata.RowEvent{ + TableName: table, + RowChanges: []*binlogdata.RowChange{ + { + Before: nil, + After: nil, + }, + }, + Flags: flags, + } + var row query.Row + for i, col := range fe.cols { + if fe.cols[i].skip { + continue + } + if col.dataTypeLowered == "binary" { + bv[col.name] = strings.TrimSuffix(bv[col.name], "\\0") + } + val := []byte(bv[col.name]) + l := int64(len(val)) + if col.dataTypeLowered == "binary" { + for l < col.len { + val = append(val, "\x00"...) + l++ + } + } + row.Values = append(row.Values, val...) + row.Lengths = append(row.Lengths, l) + } + ev.RowChanges = ts.getRowChanges(table, stmt, &row) + vEvent := &binlogdata.VEvent{ + Type: binlogdata.VEventType_ROW, + RowEvent: ev, + } + return vEvent.String() +} + +func (ts *TestSpec) getRowChanges(table string, stmt sqlparser.Statement, row *query.Row) []*binlogdata.RowChange { + var rowChanges []*binlogdata.RowChange + var rowChange binlogdata.RowChange + switch stmt.(type) { + case *sqlparser.Insert: + rowChange.After = row + ts.setCurrentState(table, row) + case *sqlparser.Update: + rowChange = *ts.getRowChangeForUpdate(table, row) + ts.setCurrentState(table, row) + case *sqlparser.Delete: + rowChange.Before = row + ts.setCurrentState(table, nil) + } + rowChanges = append(rowChanges, &rowChange) + return rowChanges +} + +func (ts *TestSpec) getRowChangeForUpdate(table string, newState *query.Row) *binlogdata.RowChange { + var rowChange binlogdata.RowChange + var bitmap byte + var before, after query.Row + + currentState := ts.getCurrentState(table) + if currentState == nil { + return nil + } + var currentValueIndex int64 + var hasSkip bool + for i, l := range currentState.Lengths { + skip := false + isPKColumn := false + for _, pkColumn := range ts.pkColumns[table] { + if pkColumn == ts.fieldEvents[table].cols[i].name { + isPKColumn = true + break + } + } + if ts.options.noblob { + switch ts.fieldEvents[table].cols[i].dataTypeLowered { + case "blob", "text": + currentValue := currentState.Values[currentValueIndex : currentValueIndex+l] + newValue := newState.Values[currentValueIndex : currentValueIndex+l] + if string(currentValue) == string(newValue) { + skip = true + hasSkip = true + } + } + } + if skip && !isPKColumn { + before.Lengths = append(before.Lengths, -1) + } else { + before.Values = append(before.Values, currentState.Values[currentValueIndex:currentValueIndex+l]...) + before.Lengths = append(before.Lengths, l) + } + if skip { + after.Lengths = append(after.Lengths, -1) + } else { + after.Values = append(after.Values, newState.Values[currentValueIndex:currentValueIndex+l]...) + after.Lengths = append(after.Lengths, l) + bitmap |= 1 << uint(i) + } + currentValueIndex += l + } + rowChange.Before = &before + rowChange.After = &after + if hasSkip { + rowChange.DataColumns = &binlogdata.RowChange_Bitmap{ + Count: int64(len(currentState.Lengths)), + Cols: []byte{bitmap}, + } + } + return &rowChange +} + +func (ts *TestSpec) getBefore(table string) *query.Row { + currentState := ts.getCurrentState(table) + if currentState == nil { + return nil + } + var row query.Row + var currentValueIndex int64 + for i, l := range currentState.Lengths { + dataTypeIsRedacted := false + switch ts.fieldEvents[table].cols[i].dataTypeLowered { + case "blob", "text": + dataTypeIsRedacted = true + } + if ts.options.noblob && dataTypeIsRedacted { + row.Lengths = append(row.Lengths, -1) + } else { + row.Values = append(row.Values, currentState.Values[currentValueIndex:currentValueIndex+l]...) + row.Lengths = append(row.Lengths, l) + } + currentValueIndex += l + } + return &row +} diff --git a/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go b/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go index c056ef1d7e1..9c77ca18594 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go +++ b/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go @@ -41,6 +41,8 @@ import ( vttestpb "vitess.io/vitess/go/vt/proto/vttest" ) +const DBName = "vttest" + // Env contains all the env vars for a test against a mysql instance. type Env struct { cluster *vttest.LocalCluster @@ -65,7 +67,7 @@ type Env struct { // Init initializes an Env. func Init(ctx context.Context) (*Env, error) { te := &Env{ - KeyspaceName: "vttest", + KeyspaceName: DBName, ShardName: "0", Cells: []string{"cell1"}, } @@ -89,7 +91,7 @@ func Init(ctx context.Context) (*Env, error) { Shards: []*vttestpb.Shard{ { Name: "0", - DbNameOverride: "vttest", + DbNameOverride: DBName, }, }, }, diff --git a/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go b/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go index ea6e0fb76aa..c515357a4ec 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/uvstreamer_flaky_test.go @@ -71,11 +71,11 @@ const ( numInitialRows = 10 ) -type state struct { +type TestState struct { tables []string } -var testState = &state{} +var testState = &TestState{} var positions map[string]string var allEvents []*binlogdatapb.VEvent diff --git a/go/vt/vttablet/tabletserver/vstreamer/vstreamer_flaky_test.go b/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go similarity index 82% rename from go/vt/vttablet/tabletserver/vstreamer/vstreamer_flaky_test.go rename to go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go index 0eda0d6c52e..5a1a786513f 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/vstreamer_flaky_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go @@ -26,6 +26,8 @@ import ( "testing" "time" + "github.com/prometheus/common/version" + "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/vt/vttablet/tabletserver/throttle/throttlerapp" "vitess.io/vitess/go/vt/vttablet/tabletserver/vstreamer/testenv" @@ -57,22 +59,15 @@ func checkIfOptionIsSupported(t *testing.T, variable string) bool { return false } -type TestColumn struct { - name, dataType, colType string - len, charset int64 -} - -type TestFieldEvent struct { - table, db string - cols []*TestColumn -} - func (tfe *TestFieldEvent) String() string { s := fmt.Sprintf("type:FIELD field_event:{table_name:\"%s\"", tfe.table) fld := "" for _, col := range tfe.cols { + if col.skip { + continue + } fld += fmt.Sprintf(" fields:{name:\"%s\" type:%s table:\"%s\" org_table:\"%s\" database:\"%s\" org_name:\"%s\" column_length:%d charset:%d", - col.name, col.dataType, tfe.table, tfe.table, tfe.db, col.name, col.len, col.charset) + col.name, col.dataType, tfe.table, tfe.table, tfe.db, col.name, col.len, col.collationID) if col.colType != "" { fld += fmt.Sprintf(" column_type:\"%s\"", col.colType) } @@ -97,163 +92,94 @@ func TestNoBlob(t *testing.T) { engine = oldEngine env = oldEnv }() - execStatements(t, []string{ - "create table t1(id int, blb blob, val varchar(4), primary key(id))", - "create table t2(id int, txt text, val varchar(4), unique key(id, val))", - }) - defer execStatements(t, []string{ - "drop table t1", - "drop table t2", - }) - engine.se.Reload(context.Background()) - queries := []string{ - "begin", - "insert into t1 values (1, 'blob1', 'aaa')", - "update t1 set val = 'bbb'", - "commit", - "begin", - "insert into t2 values (1, 'text1', 'aaa')", - "update t2 set val = 'bbb'", - "commit", - } - fe1 := &TestFieldEvent{ - table: "t1", - db: "vttest", - cols: []*TestColumn{ - {name: "id", dataType: "INT32", colType: "int(11)", len: 11, charset: 63}, - {name: "blb", dataType: "BLOB", colType: "blob", len: 65535, charset: 63}, - {name: "val", dataType: "VARCHAR", colType: "varchar(4)", len: 16, charset: 45}, + ts := &TestSpec{ + t: t, + ddls: []string{ + // t1 has a blob column and a primary key. The blob column will not be in update row events. + "create table t1(id int, blb blob, val varchar(4), primary key(id))", + // t2 has a text column and no primary key. The text column will be in update row events. + "create table t2(id int, txt text, val varchar(4), unique key(id, val))", + // t3 has a text column and a primary key. The text column will not be in update row events. + "create table t3(id int, txt text, val varchar(4), primary key(id))", }, - } - fe2 := &TestFieldEvent{ - table: "t2", - db: "vttest", - cols: []*TestColumn{ - {name: "id", dataType: "INT32", colType: "int(11)", len: 11, charset: 63}, - {name: "txt", dataType: "TEXT", colType: "text", len: 262140, charset: 45}, - {name: "val", dataType: "VARCHAR", colType: "varchar(4)", len: 16, charset: 45}, + options: &TestSpecOptions{ + noblob: true, }, } - - testcases := []testcase{{ - input: queries, - output: [][]string{{ - "begin", - fe1.String(), - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:5 lengths:3 values:"1blob1aaa"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:-1 lengths:3 values:"1aaa"} after:{lengths:1 lengths:-1 lengths:3 values:"1bbb"} data_columns:{count:3 cols:"\x05"}}}`, - "gtid", - "commit", - }, { - "begin", - fe2.String(), - `type:ROW row_event:{table_name:"t2" row_changes:{after:{lengths:1 lengths:5 lengths:3 values:"1text1aaa"}}}`, - `type:ROW row_event:{table_name:"t2" row_changes:{before:{lengths:1 lengths:5 lengths:3 values:"1text1aaa"} after:{lengths:1 lengths:-1 lengths:3 values:"1bbb"} data_columns:{count:3 cols:"\x05"}}}`, - "gtid", - "commit", - }}, + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into t1 values (1, 'blob1', 'aaa')", nil}, + {"update t1 set val = 'bbb'", nil}, + {"commit", nil}, + }, {{"begin", nil}, + {"insert into t2 values (1, 'text1', 'aaa')", nil}, + {"update t2 set val = 'bbb'", nil}, + {"commit", nil}, + }, {{"begin", nil}, + {"insert into t3 values (1, 'text1', 'aaa')", nil}, + {"update t3 set val = 'bbb'", nil}, + {"commit", nil}, }} - runCases(t, nil, testcases, "current", nil) + ts.Run() } +// TestSetAndEnum confirms that the events for set and enum columns are correct. func TestSetAndEnum(t *testing.T) { - execStatements(t, []string{ - "create table t1(id int, val binary(4), color set('red','green','blue'), size enum('S','M','L'), primary key(id))", - }) - defer execStatements(t, []string{ - "drop table t1", - }) - engine.se.Reload(context.Background()) - queries := []string{ - "begin", - "insert into t1 values (1, 'aaa', 'red,blue', 'S')", - "insert into t1 values (2, 'bbb', 'green', 'M')", - "insert into t1 values (3, 'ccc', 'red,blue,green', 'L')", - "commit", - } - - fe := &TestFieldEvent{ - table: "t1", - db: "vttest", - cols: []*TestColumn{ - {name: "id", dataType: "INT32", colType: "int(11)", len: 11, charset: 63}, - {name: "val", dataType: "BINARY", colType: "binary(4)", len: 4, charset: 63}, - {name: "color", dataType: "SET", colType: "set('red','green','blue')", len: 56, charset: 45}, - {name: "size", dataType: "ENUM", colType: "enum('S','M','L')", len: 4, charset: 45}, + ts := &TestSpec{ + t: t, + ddls: []string{ + "create table t1(id int, val binary(4), color set('red','green','blue'), size enum('S','M','L'), primary key(id))", }, } - - testcases := []testcase{{ - input: queries, - output: [][]string{{ - `begin`, - fe.String(), - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 lengths:1 lengths:1 values:"1aaa\x0051"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 lengths:1 lengths:1 values:"2bbb\x0022"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 lengths:1 lengths:1 values:"3ccc\x0073"}}}`, - `gtid`, - `commit`, - }}, + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into t1 values (1, 'aaa', 'red,blue', 'S')", nil}, + {"insert into t1 values (2, 'bbb', 'green', 'M')", nil}, + {"insert into t1 values (3, 'ccc', 'red,blue,green', 'L')", nil}, + {"commit", nil}, }} - runCases(t, nil, testcases, "current", nil) + ts.Run() } +// TestCellValuePadding tests that the events are correctly padded for binary columns. func TestCellValuePadding(t *testing.T) { - - execStatements(t, []string{ - "create table t1(id int, val binary(4), primary key(val))", - "create table t2(id int, val char(4), primary key(val))", - "create table t3(id int, val char(4) collate utf8mb4_bin, primary key(val))", - }) - defer execStatements(t, []string{ - "drop table t1", - "drop table t2", - "drop table t3", - }) - engine.se.Reload(context.Background()) - queries := []string{ - "begin", - "insert into t1 values (1, 'aaa\000')", - "insert into t1 values (2, 'bbb\000')", - "update t1 set id = 11 where val = 'aaa\000'", - "insert into t2 values (1, 'aaa')", - "insert into t2 values (2, 'bbb')", - "update t2 set id = 11 where val = 'aaa'", - "insert into t3 values (1, 'aaa')", - "insert into t3 values (2, 'bb')", - "update t3 set id = 11 where val = 'aaa'", - "commit", - } - - testcases := []testcase{{ - input: queries, - output: [][]string{{ - `begin`, - `type:FIELD field_event:{table_name:"t1" fields:{name:"id" type:INT32 table:"t1" org_table:"t1" database:"vttest" org_name:"id" column_length:11 charset:63 column_type:"int(11)"} fields:{name:"val" type:BINARY table:"t1" org_table:"t1" database:"vttest" org_name:"val" column_length:4 charset:63 column_type:"binary(4)"}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 values:"1aaa\x00"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 values:"2bbb\x00"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:4 values:"1aaa\x00"} after:{lengths:2 lengths:4 values:"11aaa\x00"}}}`, - `type:FIELD field_event:{table_name:"t2" fields:{name:"id" type:INT32 table:"t2" org_table:"t2" database:"vttest" org_name:"id" column_length:11 charset:63 column_type:"int(11)"} fields:{name:"val" type:CHAR table:"t2" org_table:"t2" database:"vttest" org_name:"val" column_length:16 charset:45 column_type:"char(4)"}}`, - `type:ROW row_event:{table_name:"t2" row_changes:{after:{lengths:1 lengths:3 values:"1aaa"}}}`, - `type:ROW row_event:{table_name:"t2" row_changes:{after:{lengths:1 lengths:3 values:"2bbb"}}}`, - `type:ROW row_event:{table_name:"t2" row_changes:{before:{lengths:1 lengths:3 values:"1aaa"} after:{lengths:2 lengths:3 values:"11aaa"}}}`, - `type:FIELD field_event:{table_name:"t3" fields:{name:"id" type:INT32 table:"t3" org_table:"t3" database:"vttest" org_name:"id" column_length:11 charset:63 column_type:"int(11)"} fields:{name:"val" type:BINARY table:"t3" org_table:"t3" database:"vttest" org_name:"val" column_length:16 charset:45 column_type:"char(4)"}}`, - `type:ROW row_event:{table_name:"t3" row_changes:{after:{lengths:1 lengths:3 values:"1aaa"}}}`, - `type:ROW row_event:{table_name:"t3" row_changes:{after:{lengths:1 lengths:2 values:"2bb"}}}`, - `type:ROW row_event:{table_name:"t3" row_changes:{before:{lengths:1 lengths:3 values:"1aaa"} after:{lengths:2 lengths:3 values:"11aaa"}}}`, - `gtid`, - `commit`, + ts := &TestSpec{ + t: t, + ddls: []string{ + "create table t1(id int, val binary(4), primary key(val))", + "create table t2(id int, val char(4), primary key(val))", + "create table t3(id int, val char(4) collate utf8mb4_bin, primary key(val))"}, + } + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into t1 values (1, 'aaa\000')", nil}, + {"insert into t1 values (2, 'bbb\000')", nil}, + {"update t1 set id = 11 where val = 'aaa\000'", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"1", "aaa\x00"}, after: []string{"11", "aaa\x00"}}}}}, }}, + {"insert into t2 values (1, 'aaa')", nil}, + {"insert into t2 values (2, 'bbb')", nil}, + {"update t2 set id = 11 where val = 'aaa'", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t2", changes: []TestRowChange{{before: []string{"1", "aaa"}, after: []string{"11", "aaa"}}}}}, + }}, + {"insert into t3 values (1, 'aaa')", nil}, + {"insert into t3 values (2, 'bb')", nil}, + {"update t3 set id = 11 where val = 'aaa'", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t3", changes: []TestRowChange{{before: []string{"1", "aaa"}, after: []string{"11", "aaa"}}}}}, + }}, + {"commit", nil}, }} - runCases(t, nil, testcases, "current", nil) + ts.Run() } func TestSetStatement(t *testing.T) { - - if testing.Short() { - t.Skip() - } if !checkIfOptionIsSupported(t, "log_builtin_as_identified_by_password") { // the combination of setting this option and support for "set password" only works on a few flavors log.Info("Cannot test SetStatement on this flavor") @@ -296,45 +222,25 @@ func TestSetForeignKeyCheck(t *testing.T) { testRowEventFlags = true defer func() { testRowEventFlags = false }() - execStatements(t, []string{ - "create table t1(id int, val binary(4), primary key(id))", - }) - defer execStatements(t, []string{ - "drop table t1", - }) - engine.se.Reload(context.Background()) - queries := []string{ - "begin", - "insert into t1 values (1, 'aaa')", - "set @@session.foreign_key_checks=1", - "insert into t1 values (2, 'bbb')", - "set @@session.foreign_key_checks=0", - "insert into t1 values (3, 'ccc')", - "commit", - } - - fe := &TestFieldEvent{ - table: "t1", - db: "vttest", - cols: []*TestColumn{ - {name: "id", dataType: "INT32", colType: "int(11)", len: 11, charset: 63}, - {name: "val", dataType: "BINARY", colType: "binary(4)", len: 4, charset: 63}, + ts := &TestSpec{ + t: t, + ddls: []string{ + "create table t1(id int, val binary(4), primary key(id))", }, } - - testcases := []testcase{{ - input: queries, - output: [][]string{{ - `begin`, - fe.String(), - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 values:"1aaa\x00"}} flags:1}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 values:"2bbb\x00"}} flags:1}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:4 values:"3ccc\x00"}} flags:3}`, - `gtid`, - `commit`, - }}, + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into t1 values (1, 'aaa')", []TestRowEvent{{flags: 1}}}, + {"set @@session.foreign_key_checks=1", noEvents}, + {"insert into t1 values (2, 'bbb')", []TestRowEvent{{flags: 1}}}, + {"set @@session.foreign_key_checks=0", noEvents}, + {"insert into t1 values (3, 'ccc')", []TestRowEvent{{flags: 3}}}, + {"commit", nil}, }} - runCases(t, nil, testcases, "current", nil) + ts.Run() + } func TestStmtComment(t *testing.T) { @@ -711,225 +617,179 @@ func TestVStreamCopyWithDifferentFilters(t *testing.T) { } } +// TestFilteredVarBinary confirms that adding a filter using a varbinary column results in the correct set of events. func TestFilteredVarBinary(t *testing.T) { - if testing.Short() { - t.Skip() + ts := &TestSpec{ + t: t, + ddls: []string{ + "create table t1(id1 int, val varbinary(128), primary key(id1))", + }, + options: &TestSpecOptions{ + filter: &binlogdatapb.Filter{ + Rules: []*binlogdatapb.Rule{{ + Match: "t1", + Filter: "select id1, val from t1 where val = 'newton'", + }}, + }, + }, } - - execStatements(t, []string{ - "create table t1(id1 int, val varbinary(128), primary key(id1))", - }) - defer execStatements(t, []string{ - "drop table t1", - }) - engine.se.Reload(context.Background()) - - filter := &binlogdatapb.Filter{ - Rules: []*binlogdatapb.Rule{{ - Match: "t1", - Filter: "select id1, val from t1 where val = 'newton'", + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into t1 values (1, 'kepler')", noEvents}, + {"insert into t1 values (2, 'newton')", nil}, + {"insert into t1 values (3, 'newton')", nil}, + {"insert into t1 values (4, 'kepler')", noEvents}, + {"insert into t1 values (5, 'newton')", nil}, + {"update t1 set val = 'newton' where id1 = 1", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{after: []string{"1", "newton"}}}}}, }}, - } - - testcases := []testcase{{ - input: []string{ - "begin", - "insert into t1 values (1, 'kepler')", - "insert into t1 values (2, 'newton')", - "insert into t1 values (3, 'newton')", - "insert into t1 values (4, 'kepler')", - "insert into t1 values (5, 'newton')", - "update t1 set val = 'newton' where id1 = 1", - "update t1 set val = 'kepler' where id1 = 2", - "update t1 set val = 'newton' where id1 = 2", - "update t1 set val = 'kepler' where id1 = 1", - "delete from t1 where id1 in (2,3)", - "commit", - }, - output: [][]string{{ - `begin`, - `type:FIELD field_event:{table_name:"t1" fields:{name:"id1" type:INT32 table:"t1" org_table:"t1" database:"vttest" org_name:"id1" column_length:11 charset:63 column_type:"int(11)"} fields:{name:"val" type:VARBINARY table:"t1" org_table:"t1" database:"vttest" org_name:"val" column_length:128 charset:63 column_type:"varbinary(128)"}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:6 values:"2newton"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:6 values:"3newton"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:6 values:"5newton"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:6 values:"1newton"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:6 values:"2newton"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:6 values:"2newton"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:6 values:"1newton"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:6 values:"2newton"}} row_changes:{before:{lengths:1 lengths:6 values:"3newton"}}}`, - `gtid`, - `commit`, + {"update t1 set val = 'kepler' where id1 = 2", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"2", "newton"}}}}}, + }}, + {"update t1 set val = 'newton' where id1 = 2", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{after: []string{"2", "newton"}}}}}, + }}, + {"update t1 set val = 'kepler' where id1 = 1", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"1", "newton"}}}}}, }}, + {"delete from t1 where id1 in (2,3)", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"2", "newton"}}, {before: []string{"3", "newton"}}}}}, + }}, + {"commit", nil}, }} - runCases(t, filter, testcases, "", nil) + ts.Run() } +// TestFilteredInt confirms that adding a filter using an int column results in the correct set of events. func TestFilteredInt(t *testing.T) { - if testing.Short() { - t.Skip() + ts := &TestSpec{ + t: t, + ddls: []string{ + "create table t1(id1 int, id2 int, val varbinary(128), primary key(id1))", + }, + options: &TestSpecOptions{ + filter: &binlogdatapb.Filter{ + Rules: []*binlogdatapb.Rule{{ + Match: "t1", + Filter: "select id1, val from t1 where id2 = 200", + }}, + }, + }, } - engine.se.Reload(context.Background()) - - execStatements(t, []string{ - "create table t1(id1 int, id2 int, val varbinary(128), primary key(id1))", - }) - defer execStatements(t, []string{ - "drop table t1", - }) - engine.se.Reload(context.Background()) - - filter := &binlogdatapb.Filter{ - Rules: []*binlogdatapb.Rule{{ - Match: "t1", - Filter: "select id1, val from t1 where id2 = 200", + defer ts.Close() + require.NoError(t, ts.Init()) + ts.fieldEvents["t1"].cols[1].skip = true + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into t1 values (1, 100, 'aaa')", noEvents}, + {"insert into t1 values (2, 200, 'bbb')", nil}, + {"insert into t1 values (3, 100, 'ccc')", noEvents}, + {"insert into t1 values (4, 200, 'ddd')", nil}, + {"insert into t1 values (5, 200, 'eee')", nil}, + {"update t1 set val = 'newddd' where id1 = 4", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"4", "ddd"}, after: []string{"4", "newddd"}}}}}, }}, - } - - testcases := []testcase{{ - input: []string{ - "begin", - "insert into t1 values (1, 100, 'aaa')", - "insert into t1 values (2, 200, 'bbb')", - "insert into t1 values (3, 100, 'ccc')", - "insert into t1 values (4, 200, 'ddd')", - "insert into t1 values (5, 200, 'eee')", - "update t1 set val = 'newddd' where id1 = 4", - "update t1 set id2 = 200 where id1 = 1", - "update t1 set id2 = 100 where id1 = 2", - "update t1 set id2 = 100 where id1 = 1", - "update t1 set id2 = 200 where id1 = 2", - "commit", - }, - output: [][]string{{ - `begin`, - `type:FIELD field_event:{table_name:"t1" fields:{name:"id1" type:INT32 table:"t1" org_table:"t1" database:"vttest" org_name:"id1" column_length:11 charset:63 column_type:"int(11)"} fields:{name:"val" type:VARBINARY table:"t1" org_table:"t1" database:"vttest" org_name:"val" column_length:128 charset:63 column_type:"varbinary(128)"}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:3 values:"2bbb"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:3 values:"4ddd"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:3 values:"5eee"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:3 values:"4ddd"} after:{lengths:1 lengths:6 values:"4newddd"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:3 values:"1aaa"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:3 values:"2bbb"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{before:{lengths:1 lengths:3 values:"1aaa"}}}`, - `type:ROW row_event:{table_name:"t1" row_changes:{after:{lengths:1 lengths:3 values:"2bbb"}}}`, - `gtid`, - `commit`, + {"update t1 set id2 = 200 where id1 = 1", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{after: []string{"1", "aaa"}}}}}, }}, + {"update t1 set id2 = 100 where id1 = 2", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"2", "bbb"}}}}}, + }}, + {"update t1 set id2 = 100 where id1 = 1", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"1", "aaa"}}}}}, + }}, + {"update t1 set id2 = 200 where id1 = 2", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{after: []string{"2", "bbb"}}}}}, + }}, + {"commit", nil}, }} - runCases(t, filter, testcases, "", nil) + ts.Run() } +// TestSavepoint confirms that rolling back to a savepoint drops the dmls that were executed during the savepoint. func TestSavepoint(t *testing.T) { - if testing.Short() { - t.Skip() - } - - execStatements(t, []string{ - "create table stream1(id int, val varbinary(128), primary key(id))", - "create table stream2(id int, val varbinary(128), primary key(id))", - }) - defer execStatements(t, []string{ - "drop table stream1", - "drop table stream2", - }) - engine.se.Reload(context.Background()) - testcases := []testcase{{ - input: []string{ - "begin", - "insert into stream1 values (1, 'aaa')", - "savepoint a", - "insert into stream1 values (2, 'aaa')", - "rollback work to savepoint a", - "savepoint b", - "update stream1 set val='bbb' where id = 1", - "release savepoint b", - "commit", + ts := &TestSpec{ + t: t, + ddls: []string{ + "create table stream1(id int, val varbinary(128), primary key(id))", }, - output: [][]string{{ - `begin`, - `type:FIELD field_event:{table_name:"stream1" fields:{name:"id" type:INT32 table:"stream1" org_table:"stream1" database:"vttest" org_name:"id" column_length:11 charset:63 column_type:"int(11)"} fields:{name:"val" type:VARBINARY table:"stream1" org_table:"stream1" database:"vttest" org_name:"val" column_length:128 charset:63 column_type:"varbinary(128)"}}`, - `type:ROW row_event:{table_name:"stream1" row_changes:{after:{lengths:1 lengths:3 values:"1aaa"}}}`, - `type:ROW row_event:{table_name:"stream1" row_changes:{before:{lengths:1 lengths:3 values:"1aaa"} after:{lengths:1 lengths:3 values:"1bbb"}}}`, - `gtid`, - `commit`, + } + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into stream1 values (1, 'aaa')", nil}, + {"savepoint a", noEvents}, + {"insert into stream1 values (2, 'aaa')", noEvents}, + {"rollback work to savepoint a", noEvents}, + {"savepoint b", noEvents}, + {"update stream1 set val='bbb' where id = 1", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "stream1", changes: []TestRowChange{{before: []string{"1", "aaa"}, after: []string{"1", "bbb"}}}}}, }}, + {"release savepoint b", noEvents}, + {"commit", nil}, }} - runCases(t, nil, testcases, "current", nil) + ts.Run() } +// TestSavepointWithFilter tests that using savepoints with both filtered and unfiltered tables works as expected. func TestSavepointWithFilter(t *testing.T) { - if testing.Short() { - t.Skip() - } - - execStatements(t, []string{ - "create table stream1(id int, val varbinary(128), primary key(id))", - "create table stream2(id int, val varbinary(128), primary key(id))", - }) - defer execStatements(t, []string{ - "drop table stream1", - "drop table stream2", - }) - engine.se.Reload(context.Background()) - testcases := []testcase{{ - input: []string{ - "begin", - "insert into stream1 values (1, 'aaa')", - "savepoint a", - "insert into stream1 values (2, 'aaa')", - "savepoint b", - "insert into stream1 values (3, 'aaa')", - "savepoint c", - "insert into stream1 values (4, 'aaa')", - "savepoint d", - "commit", - - "begin", - "insert into stream1 values (5, 'aaa')", - "savepoint d", - "insert into stream1 values (6, 'aaa')", - "savepoint c", - "insert into stream1 values (7, 'aaa')", - "savepoint b", - "insert into stream1 values (8, 'aaa')", - "savepoint a", - "commit", - - "begin", - "insert into stream1 values (9, 'aaa')", - "savepoint a", - "insert into stream2 values (1, 'aaa')", - "savepoint b", - "insert into stream1 values (10, 'aaa')", - "savepoint c", - "insert into stream2 values (2, 'aaa')", - "savepoint d", - "commit", + ts := &TestSpec{ + t: t, + ddls: []string{ + "create table stream1(id int, val varbinary(128), primary key(id))", + "create table stream2(id int, val varbinary(128), primary key(id))", }, - output: [][]string{{ - `begin`, - `gtid`, - `commit`, - }, { - `begin`, - `gtid`, - `commit`, - }, { - `begin`, - `type:FIELD field_event:{table_name:"stream2" fields:{name:"id" type:INT32 table:"stream2" org_table:"stream2" database:"vttest" org_name:"id" column_length:11 charset:63 column_type:"int(11)"} fields:{name:"val" type:VARBINARY table:"stream2" org_table:"stream2" database:"vttest" org_name:"val" column_length:128 charset:63 column_type:"varbinary(128)"}}`, - `type:ROW row_event:{table_name:"stream2" row_changes:{after:{lengths:1 lengths:3 values:"1aaa"}}}`, - `type:ROW row_event:{table_name:"stream2" row_changes:{after:{lengths:1 lengths:3 values:"2aaa"}}}`, - `gtid`, - `commit`, + options: &TestSpecOptions{ + filter: &binlogdatapb.Filter{ + Rules: []*binlogdatapb.Rule{{ + Match: "stream2", + Filter: "select * from stream2", + }}, + }, + }, + } + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into stream1 values (1, 'aaa')", noEvents}, + {"savepoint a", noEvents}, + {"insert into stream1 values (2, 'aaa')", noEvents}, + {"savepoint b", noEvents}, + {"insert into stream1 values (3, 'aaa')", noEvents}, + {"savepoint c", noEvents}, + {"insert into stream1 values (4, 'aaa')", noEvents}, + {"savepoint d", noEvents}, + {"commit", nil}, + }, { + {"begin", nil}, + {"insert into stream1 values (5, 'aaa')", noEvents}, + {"savepoint d", noEvents}, + {"insert into stream1 values (6, 'aaa')", noEvents}, + {"savepoint c", noEvents}, + {"insert into stream1 values (7, 'aaa')", noEvents}, + {"savepoint b", noEvents}, + {"insert into stream1 values (8, 'aaa')", noEvents}, + {"savepoint a", noEvents}, + {"commit", nil}, + }, { + {"begin", nil}, + {"insert into stream1 values (9, 'aaa')", noEvents}, + {"savepoint a", noEvents}, + {"insert into stream2 values (1, 'aaa')", nil}, + {"savepoint b", noEvents}, + {"insert into stream1 values (10, 'aaa')", noEvents}, + {"savepoint c", noEvents}, + {"insert into stream2 values (2, 'aaa')", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "stream2", changes: []TestRowChange{{after: []string{"2", "aaa"}}}}}, }}, + {"savepoint d", noEvents}, + {"commit", nil}, }} - - filter := &binlogdatapb.Filter{ - Rules: []*binlogdatapb.Rule{{ - Match: "stream2", - Filter: "select * from stream2", - }}, - } - runCases(t, filter, testcases, "current", nil) + ts.Run() } func TestStatements(t *testing.T) { @@ -1685,6 +1545,9 @@ func TestBestEffortNameInFieldEvent(t *testing.T) { // test that vstreamer ignores tables created by OnlineDDL func TestInternalTables(t *testing.T) { + if version.GoOS == "darwin" { + t.Skip("internal online ddl table matching doesn't work on Mac because it is case insensitive") + } if testing.Short() { t.Skip() } @@ -2158,11 +2021,11 @@ func TestGeneratedColumns(t *testing.T) { table: "t1", db: "vttest", cols: []*TestColumn{ - {name: "id", dataType: "INT32", colType: "int(11)", len: 11, charset: 63}, - {name: "val", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, charset: 63}, - {name: "val2", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, charset: 63}, - {name: "val3", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, charset: 63}, - {name: "id2", dataType: "INT32", colType: "int(11)", len: 11, charset: 63}, + {name: "id", dataType: "INT32", colType: "int(11)", len: 11, collationID: 63}, + {name: "val", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, collationID: 63}, + {name: "val2", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, collationID: 63}, + {name: "val3", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, collationID: 63}, + {name: "id2", dataType: "INT32", colType: "int(11)", len: 11, collationID: 63}, }, } @@ -2205,8 +2068,8 @@ func TestGeneratedInvisiblePrimaryKey(t *testing.T) { table: "t1", db: "vttest", cols: []*TestColumn{ - {name: "my_row_id", dataType: "UINT64", colType: "bigint unsigned", len: 20, charset: 63}, - {name: "val", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, charset: 63}, + {name: "my_row_id", dataType: "UINT64", colType: "bigint unsigned", len: 20, collationID: 63}, + {name: "val", dataType: "VARBINARY", colType: "varbinary(6)", len: 6, collationID: 63}, }, } @@ -2288,10 +2151,16 @@ func expectLog(ctx context.Context, t *testing.T, input any, ch <-chan []*binlog break } } + + numEventsToMatch := len(evs) if len(wantset) != len(evs) { - t.Fatalf("%v: evs\n%v, want\n%v, >> got length %d, wanted length %d", input, evs, wantset, len(evs), len(wantset)) + log.Warningf("%v: evs\n%v, want\n%v, >> got length %d, wanted length %d", input, evs, wantset, len(evs), len(wantset)) + if len(wantset) < len(evs) { + numEventsToMatch = len(wantset) + } } - for i, want := range wantset { + for i := 0; i < numEventsToMatch; i++ { + want := wantset[i] // CurrentTime is not testable. evs[i].CurrentTime = 0 evs[i].Keyspace = "" @@ -2350,6 +2219,9 @@ func expectLog(ctx context.Context, t *testing.T, input any, ch <-chan []*binlog } } } + if len(wantset) != len(evs) { + t.Fatalf("%v: evs\n%v, want\n%v, got length %d, wanted length %d", input, evs, wantset, len(evs), len(wantset)) + } } } @@ -2385,7 +2257,7 @@ func vstream(ctx context.Context, t *testing.T, pos string, tablePKs []*binlogda timer := time.NewTimer(2 * time.Second) defer timer.Stop() - t.Logf("Received events: %v", evs) + log.Infof("Received events: %v", evs) select { case ch <- evs: case <-ctx.Done(): diff --git a/tools/rowlog/rowlog.go b/tools/rowlog/rowlog.go index 475006b2b59..8092159c6b6 100644 --- a/tools/rowlog/rowlog.go +++ b/tools/rowlog/rowlog.go @@ -71,7 +71,6 @@ func usage() { func main() { usage() - defer log.Flush() ctx := context.Background() config := parseCommandLine() if !config.Validate() { From 54c6dfc05c5ca5d88a4f2b23ad7a8914832e855c Mon Sep 17 00:00:00 2001 From: Max Englander Date: Fri, 16 Feb 2024 13:05:01 -0500 Subject: [PATCH 28/79] queryserving, observability: instrument vttablet query cache plan hits/misses (#14947) Signed-off-by: Max Englander Signed-off-by: Florent Poinsard Co-authored-by: Florent Poinsard --- changelog/20.0/20.0.0/summary.md | 12 ++++++++++-- go/vt/vttablet/tabletserver/query_engine.go | 7 +++++++ go/vt/vttablet/tabletserver/query_engine_test.go | 16 ++++++++++++++++ 3 files changed, 33 insertions(+), 2 deletions(-) diff --git a/changelog/20.0/20.0.0/summary.md b/changelog/20.0/20.0.0/summary.md index 54179429bd5..bb376c6e721 100644 --- a/changelog/20.0/20.0.0/summary.md +++ b/changelog/20.0/20.0.0/summary.md @@ -11,11 +11,11 @@ - **[Flag changes](#flag-changes)** - [`pprof-http` default change](#pprof-http-default) - **[Minor Changes](#minor-changes)** - + - **[New Stats](#new-stats)** + - [VTTablet Query Cache Hits and Misses](#vttablet-query-cache-hits-and-misses) ## Major Changes - ### Query Compatibility #### Vindex Hints @@ -64,3 +64,11 @@ To continue enabling these endpoints, explicitly set `--pprof-http` when startin ## Minor Changes +### New Stats + +#### VTTablet Query Cache Hits and Misses + +VTTablet exposes two new counter stats: + + * `QueryCacheHits`: Query engine query cache hits + * `QueryCacheMisses`: Query engine query cache misses diff --git a/go/vt/vttablet/tabletserver/query_engine.go b/go/vt/vttablet/tabletserver/query_engine.go index b87c5cf97ba..f009a72ceee 100644 --- a/go/vt/vttablet/tabletserver/query_engine.go +++ b/go/vt/vttablet/tabletserver/query_engine.go @@ -188,6 +188,7 @@ type QueryEngine struct { // stats // Note: queryErrorCountsWithCode is similar to queryErrorCounts except it contains error code as an additional dimension queryCounts, queryCountsWithTabletType, queryTimes, queryErrorCounts, queryErrorCountsWithCode, queryRowsAffected, queryRowsReturned *stats.CountersWithMultiLabels + queryCacheHits, queryCacheMisses *stats.CounterFunc // stats flags enablePerWorkloadTableMetrics bool @@ -280,6 +281,12 @@ func NewQueryEngine(env tabletenv.Env, se *schema.Engine) *QueryEngine { env.Exporter().NewCounterFunc("QueryCacheEvictions", "Query engine query cache evictions", func() int64 { return qe.plans.Metrics.Evicted() }) + qe.queryCacheHits = env.Exporter().NewCounterFunc("QueryCacheHits", "Query engine query cache hits", func() int64 { + return qe.plans.Metrics.Hits() + }) + qe.queryCacheMisses = env.Exporter().NewCounterFunc("QueryCacheMisses", "Query engine query cache misses", func() int64 { + return qe.plans.Metrics.Misses() + }) labels := []string{"Table", "Plan"} if config.EnablePerWorkloadTableMetrics { diff --git a/go/vt/vttablet/tabletserver/query_engine_test.go b/go/vt/vttablet/tabletserver/query_engine_test.go index 8dbe18ef13c..604f65f3311 100644 --- a/go/vt/vttablet/tabletserver/query_engine_test.go +++ b/go/vt/vttablet/tabletserver/query_engine_test.go @@ -186,11 +186,27 @@ func TestQueryPlanCache(t *testing.T) { ctx := context.Background() logStats := tabletenv.NewLogStats(ctx, "GetPlanStats") + initialHits := qe.queryCacheHits.Get() + initialMisses := qe.queryCacheMisses.Get() + firstPlan, err := qe.GetPlan(ctx, logStats, firstQuery, false) require.NoError(t, err) require.NotNil(t, firstPlan, "plan should not be nil") assertPlanCacheSize(t, qe, 1) + + require.Equal(t, int64(0), qe.queryCacheHits.Get()-initialHits) + require.Equal(t, int64(1), qe.queryCacheMisses.Get()-initialMisses) + + secondPlan, err := qe.GetPlan(ctx, logStats, firstQuery, false) + require.NoError(t, err) + require.NotNil(t, secondPlan, "plan should not be nil") + + assertPlanCacheSize(t, qe, 1) + + require.Equal(t, int64(1), qe.queryCacheHits.Get()-initialHits) + require.Equal(t, int64(1), qe.queryCacheMisses.Get()-initialMisses) + qe.ClearQueryPlanCache() } From f38dab348783a6a73e83c5ed07892e9cf5dab7d5 Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Mon, 19 Feb 2024 12:12:15 +0200 Subject: [PATCH 29/79] Mysqld: capture mysqlbinlog std error output (#15278) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- go/vt/mysqlctl/mysqld.go | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/go/vt/mysqlctl/mysqld.go b/go/vt/mysqlctl/mysqld.go index 5c11c6055e8..5b2d4fc19b7 100644 --- a/go/vt/mysqlctl/mysqld.go +++ b/go/vt/mysqlctl/mysqld.go @@ -1250,11 +1250,18 @@ func (mysqld *Mysqld) ApplyBinlogFile(ctx context.Context, req *mysqlctlpb.Apply if err != nil { return err } + var mysqlbinlogErrFile *os.File { name, err := binaryPath(dir, "mysqlbinlog") if err != nil { return err } + mysqlbinlogErrFile, err = os.CreateTemp("", "err-mysqlbinlog-") + if err != nil { + return err + } + defer os.Remove(mysqlbinlogErrFile.Name()) + args := []string{} if gtids := req.BinlogRestorePosition; gtids != "" { args = append(args, @@ -1274,7 +1281,8 @@ func (mysqld *Mysqld) ApplyBinlogFile(ctx context.Context, req *mysqlctlpb.Apply mysqlbinlogCmd = exec.Command(name, args...) mysqlbinlogCmd.Dir = dir mysqlbinlogCmd.Env = env - log.Infof("ApplyBinlogFile: running mysqlbinlog command: %#v", mysqlbinlogCmd) + mysqlbinlogCmd.Stderr = mysqlbinlogErrFile + log.Infof("ApplyBinlogFile: running mysqlbinlog command: %#v with errfile=%v", mysqlbinlogCmd, mysqlbinlogErrFile.Name()) pipe, err = mysqlbinlogCmd.StdoutPipe() // to be piped into mysql if err != nil { return err @@ -1344,6 +1352,12 @@ func (mysqld *Mysqld) ApplyBinlogFile(ctx context.Context, req *mysqlctlpb.Apply } // Wait for both to complete: if err := mysqlbinlogCmd.Wait(); err != nil { + if mysqlbinlogErrFile != nil { + errFileContent, _ := os.ReadFile(mysqlbinlogErrFile.Name()) + if len(errFileContent) > 0 { + err = vterrors.Wrapf(err, "with error output: %s", string(errFileContent)) + } + } return vterrors.Wrapf(err, "mysqlbinlog command failed") } if err := mysqlCmd.Wait(); err != nil { From 9a78e7d3dd90c53396fbb97e4c561826d6f1180a Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Mon, 19 Feb 2024 11:23:42 +0100 Subject: [PATCH 30/79] vtexplain: Fix setting up the column information (#15275) Signed-off-by: Dirkjan Bussink --- go/vt/mysqlctl/schema.go | 18 ++++++------------ go/vt/vtexplain/vtexplain_vttablet.go | 8 ++++---- go/vt/vtexplain/vtexplain_vttablet_test.go | 4 ++++ 3 files changed, 14 insertions(+), 16 deletions(-) diff --git a/go/vt/mysqlctl/schema.go b/go/vt/mysqlctl/schema.go index c7ca98c4917..a5ac38670e7 100644 --- a/go/vt/mysqlctl/schema.go +++ b/go/vt/mysqlctl/schema.go @@ -66,12 +66,6 @@ func (mysqld *Mysqld) executeSchemaCommands(ctx context.Context, sql string) err return mysqld.executeMysqlScript(ctx, params, sql) } -func encodeEntityName(name string) string { - var buf strings.Builder - sqltypes.NewVarChar(name).EncodeSQL(&buf) - return buf.String() -} - // tableListSQL returns an IN clause "('t1', 't2'...) for a list of tables." func tableListSQL(tables []string) (string, error) { if len(tables) == 0 { @@ -80,7 +74,7 @@ func tableListSQL(tables []string) (string, error) { encodedTables := make([]string, len(tables)) for i, tableName := range tables { - encodedTables[i] = encodeEntityName(tableName) + encodedTables[i] = sqltypes.EncodeStringSQL(tableName) } return "(" + strings.Join(encodedTables, ", ") + ")", nil @@ -307,13 +301,13 @@ func GetColumnsList(dbName, tableName string, exec func(string, int, bool) (*sql if dbName == "" { dbName2 = "database()" } else { - dbName2 = encodeEntityName(dbName) + dbName2 = sqltypes.EncodeStringSQL(dbName) } sanitizedTableName, err := sqlescape.UnescapeID(tableName) if err != nil { return "", err } - query := fmt.Sprintf(GetColumnNamesQuery, dbName2, encodeEntityName(sanitizedTableName)) + query := fmt.Sprintf(GetColumnNamesQuery, dbName2, sqltypes.EncodeStringSQL(sanitizedTableName)) qr, err := exec(query, -1, true) if err != nil { return "", err @@ -407,7 +401,7 @@ func (mysqld *Mysqld) getPrimaryKeyColumns(ctx context.Context, dbName string, t FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = %s AND TABLE_NAME IN %s AND LOWER(INDEX_NAME) = 'primary' ORDER BY table_name, SEQ_IN_INDEX` - sql = fmt.Sprintf(sql, encodeEntityName(dbName), tableList) + sql = fmt.Sprintf(sql, sqltypes.EncodeStringSQL(dbName), tableList) qr, err := conn.Conn.ExecuteFetch(sql, len(tables)*100, true) if err != nil { return nil, err @@ -631,8 +625,8 @@ func GetPrimaryKeyEquivalentColumns(ctx context.Context, exec func(string, int, ) AS pke ON index_cols.INDEX_NAME = pke.INDEX_NAME WHERE index_cols.TABLE_SCHEMA = %s AND index_cols.TABLE_NAME = %s AND NON_UNIQUE = 0 AND NULLABLE != 'YES' ORDER BY SEQ_IN_INDEX ASC` - encodedDbName := encodeEntityName(dbName) - encodedTable := encodeEntityName(table) + encodedDbName := sqltypes.EncodeStringSQL(dbName) + encodedTable := sqltypes.EncodeStringSQL(table) sql = fmt.Sprintf(sql, encodedDbName, encodedTable, encodedDbName, encodedTable, encodedDbName, encodedTable) qr, err := exec(sql, 1000, true) if err != nil { diff --git a/go/vt/vtexplain/vtexplain_vttablet.go b/go/vt/vtexplain/vtexplain_vttablet.go index b04365a3d0a..9ac81000f3d 100644 --- a/go/vt/vtexplain/vtexplain_vttablet.go +++ b/go/vt/vtexplain/vtexplain_vttablet.go @@ -474,8 +474,8 @@ func newTabletEnvironment(ddls []sqlparser.DDLStatement, opts *Options, collatio } tEnv.addResult(query, tEnv.getResult(likeQuery)) - likeQuery = fmt.Sprintf(mysqlctl.GetColumnNamesQuery, "database()", sanitizedLikeTable) - query = fmt.Sprintf(mysqlctl.GetColumnNamesQuery, "database()", sanitizedTable) + likeQuery = fmt.Sprintf(mysqlctl.GetColumnNamesQuery, "database()", sqltypes.EncodeStringSQL(sanitizedLikeTable)) + query = fmt.Sprintf(mysqlctl.GetColumnNamesQuery, "database()", sqltypes.EncodeStringSQL(sanitizedTable)) if tEnv.getResult(likeQuery) == nil { return nil, fmt.Errorf("check your schema, table[%s] doesn't exist", likeTable) } @@ -516,7 +516,7 @@ func newTabletEnvironment(ddls []sqlparser.DDLStatement, opts *Options, collatio tEnv.addResult("SELECT * FROM "+backtickedTable+" WHERE 1 != 1", &sqltypes.Result{ Fields: rowTypes, }) - query := fmt.Sprintf(mysqlctl.GetColumnNamesQuery, "database()", sanitizedTable) + query := fmt.Sprintf(mysqlctl.GetColumnNamesQuery, "database()", sqltypes.EncodeStringSQL(sanitizedTable)) tEnv.addResult(query, &sqltypes.Result{ Fields: colTypes, Rows: colValues, @@ -618,7 +618,7 @@ func (t *explainTablet) handleSelect(query string) (*sqltypes.Result, error) { // Gen4 supports more complex queries so we now need to // handle multiple FROM clauses - tables := make([]*sqlparser.AliasedTableExpr, len(selStmt.From)) + tables := make([]*sqlparser.AliasedTableExpr, 0, len(selStmt.From)) for _, from := range selStmt.From { tables = append(tables, getTables(from)...) } diff --git a/go/vt/vtexplain/vtexplain_vttablet_test.go b/go/vt/vtexplain/vtexplain_vttablet_test.go index 8de1a146ce6..fc3785a907a 100644 --- a/go/vt/vtexplain/vtexplain_vttablet_test.go +++ b/go/vt/vtexplain/vtexplain_vttablet_test.go @@ -77,6 +77,10 @@ create table t2 ( require.NoError(t, err) defer vte.Stop() + // Check if the correct schema query is registered. + _, found := vte.globalTabletEnv.schemaQueries["SELECT COLUMN_NAME as column_name\n\t\tFROM INFORMATION_SCHEMA.COLUMNS\n\t\tWHERE TABLE_SCHEMA = database() AND TABLE_NAME = 't1'\n\t\tORDER BY ORDINAL_POSITION"] + assert.True(t, found) + sql := "SELECT * FROM t1 INNER JOIN t2 ON t1.id = t2.id" _, err = vte.Run(sql) From d13123050bfc747f4cb6ff867b15edd2ef877be6 Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Mon, 19 Feb 2024 13:15:19 +0100 Subject: [PATCH 31/79] evalengine: Implement REPLACE (#15274) Signed-off-by: Dirkjan Bussink --- go/vt/vtgate/evalengine/cached_size.go | 12 ++ go/vt/vtgate/evalengine/compiler_asm.go | 13 ++ go/vt/vtgate/evalengine/compiler_test.go | 4 + go/vt/vtgate/evalengine/fn_string.go | 171 ++++++++++++++++--- go/vt/vtgate/evalengine/testcases/cases.go | 28 +++ go/vt/vtgate/evalengine/translate_builtin.go | 5 + 6 files changed, 211 insertions(+), 22 deletions(-) diff --git a/go/vt/vtgate/evalengine/cached_size.go b/go/vt/vtgate/evalengine/cached_size.go index ce90aadea8a..b386d3dc915 100644 --- a/go/vt/vtgate/evalengine/cached_size.go +++ b/go/vt/vtgate/evalengine/cached_size.go @@ -1463,6 +1463,18 @@ func (cached *builtinRepeat) CachedSize(alloc bool) int64 { size += cached.CallExpr.CachedSize(false) return size } +func (cached *builtinReplace) CachedSize(alloc bool) int64 { + if cached == nil { + return int64(0) + } + size := int64(0) + if alloc { + size += int64(48) + } + // field CallExpr vitess.io/vitess/go/vt/vtgate/evalengine.CallExpr + size += cached.CallExpr.CachedSize(false) + return size +} func (cached *builtinReverse) CachedSize(alloc bool) int64 { if cached == nil { return int64(0) diff --git a/go/vt/vtgate/evalengine/compiler_asm.go b/go/vt/vtgate/evalengine/compiler_asm.go index cddf0790ea7..5eeb9a6300d 100644 --- a/go/vt/vtgate/evalengine/compiler_asm.go +++ b/go/vt/vtgate/evalengine/compiler_asm.go @@ -3022,6 +3022,19 @@ func (asm *assembler) Locate2(collation colldata.Collation) { }, "LOCATE VARCHAR(SP-2), VARCHAR(SP-1) COLLATE '%s'", collation.Name()) } +func (asm *assembler) Replace() { + asm.adjustStack(-2) + + asm.emit(func(env *ExpressionEnv) int { + str := env.vm.stack[env.vm.sp-3].(*evalBytes) + from := env.vm.stack[env.vm.sp-2].(*evalBytes) + to := env.vm.stack[env.vm.sp-1].(*evalBytes) + env.vm.sp -= 2 + str.bytes = replace(str.bytes, from.bytes, to.bytes) + return 1 + }, "REPLACE VARCHAR(SP-3), VARCHAR(SP-2) VARCHAR(SP-1)") +} + func (asm *assembler) Strcmp(collation collations.TypedCollation) { asm.adjustStack(-1) diff --git a/go/vt/vtgate/evalengine/compiler_test.go b/go/vt/vtgate/evalengine/compiler_test.go index 09e08ad0d48..f101bf61c64 100644 --- a/go/vt/vtgate/evalengine/compiler_test.go +++ b/go/vt/vtgate/evalengine/compiler_test.go @@ -627,6 +627,10 @@ func TestCompilerSingle(t *testing.T) { expression: `locate("", "😊😂🤢", 3)`, result: `INT64(3)`, }, + { + expression: `REPLACE('www.mysql.com', '', 'Ww')`, + result: `VARCHAR("www.mysql.com")`, + }, } tz, _ := time.LoadLocation("Europe/Madrid") diff --git a/go/vt/vtgate/evalengine/fn_string.go b/go/vt/vtgate/evalengine/fn_string.go index 11a18c95300..e0887037c0a 100644 --- a/go/vt/vtgate/evalengine/fn_string.go +++ b/go/vt/vtgate/evalengine/fn_string.go @@ -114,6 +114,31 @@ type ( CallExpr collate collations.ID } + + builtinChar struct { + CallExpr + collate collations.ID + } + + builtinRepeat struct { + CallExpr + collate collations.ID + } + + builtinConcat struct { + CallExpr + collate collations.ID + } + + builtinConcatWs struct { + CallExpr + collate collations.ID + } + + builtinReplace struct { + CallExpr + collate collations.ID + } ) var _ IR = (*builtinInsert)(nil) @@ -129,7 +154,15 @@ var _ IR = (*builtinCollation)(nil) var _ IR = (*builtinWeightString)(nil) var _ IR = (*builtinLeftRight)(nil) var _ IR = (*builtinPad)(nil) +var _ IR = (*builtinStrcmp)(nil) var _ IR = (*builtinTrim)(nil) +var _ IR = (*builtinSubstring)(nil) +var _ IR = (*builtinLocate)(nil) +var _ IR = (*builtinChar)(nil) +var _ IR = (*builtinRepeat)(nil) +var _ IR = (*builtinConcat)(nil) +var _ IR = (*builtinConcatWs)(nil) +var _ IR = (*builtinReplace)(nil) func insert(str, newstr *evalBytes, pos, l int) []byte { pos-- @@ -555,11 +588,6 @@ func (call *builtinOrd) compile(c *compiler) (ctype, error) { // - `> max_allowed_packet`, no error and returns `NULL`. const maxRepeatLength = 1073741824 -type builtinRepeat struct { - CallExpr - collate collations.ID -} - func (call *builtinRepeat) eval(env *ExpressionEnv) (eval, error) { arg1, arg2, err := call.arg2(env) if err != nil { @@ -1374,11 +1402,6 @@ func (call *builtinLocate) compile(c *compiler) (ctype, error) { return ctype{Type: sqltypes.Int64, Col: collationNumeric, Flag: flagNullable}, nil } -type builtinConcat struct { - CallExpr - collate collations.ID -} - func concatSQLType(arg sqltypes.Type, tt sqltypes.Type) sqltypes.Type { if arg == sqltypes.TypeJSON { return sqltypes.Blob @@ -1507,11 +1530,6 @@ func (call *builtinConcat) compile(c *compiler) (ctype, error) { return ctype{Type: tt, Flag: f, Col: tc}, nil } -type builtinConcatWs struct { - CallExpr - collate collations.ID -} - func (call *builtinConcatWs) eval(env *ExpressionEnv) (eval, error) { var ca collationAggregation tt := sqltypes.VarChar @@ -1643,13 +1661,6 @@ func (call *builtinConcatWs) compile(c *compiler) (ctype, error) { return ctype{Type: tt, Flag: args[0].Flag, Col: tc}, nil } -type builtinChar struct { - CallExpr - collate collations.ID -} - -var _ IR = (*builtinChar)(nil) - func (call *builtinChar) eval(env *ExpressionEnv) (eval, error) { vals := make([]eval, 0, len(call.Arguments)) for _, arg := range call.Arguments { @@ -1726,3 +1737,119 @@ func encodeChar(buf []byte, i uint32) []byte { } return buf } + +func (call *builtinReplace) eval(env *ExpressionEnv) (eval, error) { + str, err := call.Arguments[0].eval(env) + if err != nil || str == nil { + return nil, err + } + + fromStr, err := call.Arguments[1].eval(env) + if err != nil || fromStr == nil { + return nil, err + } + + toStr, err := call.Arguments[2].eval(env) + if err != nil || toStr == nil { + return nil, err + } + + if _, ok := str.(*evalBytes); !ok { + str, err = evalToVarchar(str, call.collate, true) + if err != nil { + return nil, err + } + } + + col := str.(*evalBytes).col + fromStr, err = evalToVarchar(fromStr, col.Collation, true) + if err != nil { + return nil, err + } + + toStr, err = evalToVarchar(toStr, col.Collation, true) + if err != nil { + return nil, err + } + + strBytes := str.(*evalBytes).bytes + fromBytes := fromStr.(*evalBytes).bytes + toBytes := toStr.(*evalBytes).bytes + + out := replace(strBytes, fromBytes, toBytes) + return newEvalRaw(str.SQLType(), out, col), nil +} + +func (call *builtinReplace) compile(c *compiler) (ctype, error) { + str, err := call.Arguments[0].compile(c) + if err != nil { + return ctype{}, err + } + + fromStr, err := call.Arguments[1].compile(c) + if err != nil { + return ctype{}, err + } + + toStr, err := call.Arguments[2].compile(c) + if err != nil { + return ctype{}, err + } + + skip := c.compileNullCheck3(str, fromStr, toStr) + if !str.isTextual() { + c.asm.Convert_xce(3, sqltypes.VarChar, c.collation) + str.Col = collations.TypedCollation{ + Collation: c.collation, + Coercibility: collations.CoerceCoercible, + Repertoire: collations.RepertoireASCII, + } + } + + fromCharset := colldata.Lookup(fromStr.Col.Collation).Charset() + toCharset := colldata.Lookup(toStr.Col.Collation).Charset() + strCharset := colldata.Lookup(str.Col.Collation).Charset() + if !fromStr.isTextual() || (fromCharset != strCharset && !strCharset.IsSuperset(fromCharset)) { + c.asm.Convert_xce(2, sqltypes.VarChar, str.Col.Collation) + fromStr.Col = collations.TypedCollation{ + Collation: str.Col.Collation, + Coercibility: collations.CoerceCoercible, + Repertoire: collations.RepertoireASCII, + } + } + + if !toStr.isTextual() || (toCharset != strCharset && !strCharset.IsSuperset(toCharset)) { + c.asm.Convert_xce(1, sqltypes.VarChar, str.Col.Collation) + toStr.Col = collations.TypedCollation{ + Collation: str.Col.Collation, + Coercibility: collations.CoerceCoercible, + Repertoire: collations.RepertoireASCII, + } + } + + c.asm.Replace() + c.asm.jumpDestination(skip) + return ctype{Type: sqltypes.VarChar, Col: str.Col, Flag: flagNullable}, nil +} + +func replace(str, from, to []byte) []byte { + if len(from) == 0 { + return str + } + n := bytes.Count(str, from) + if n == 0 { + return str + } + + out := make([]byte, len(str)+n*(len(to)-len(from))) + end := 0 + start := 0 + for i := 0; i < n; i++ { + pos := start + bytes.Index(str[start:], from) + end += copy(out[end:], str[start:pos]) + end += copy(out[end:], to) + start = pos + len(from) + } + end += copy(out[end:], str[start:]) + return out[0:end] +} diff --git a/go/vt/vtgate/evalengine/testcases/cases.go b/go/vt/vtgate/evalengine/testcases/cases.go index c53faa7f217..b55f6c2c18d 100644 --- a/go/vt/vtgate/evalengine/testcases/cases.go +++ b/go/vt/vtgate/evalengine/testcases/cases.go @@ -83,6 +83,7 @@ var Cases = []TestCase{ {Run: FnTrim}, {Run: FnSubstr}, {Run: FnLocate}, + {Run: FnReplace}, {Run: FnConcat}, {Run: FnConcatWs}, {Run: FnChar}, @@ -1577,6 +1578,33 @@ func FnLocate(yield Query) { } } +func FnReplace(yield Query) { + cases := []string{ + `REPLACE('www.mysql.com', 'w', 'Ww')`, + // MySQL doesn't do collation matching for replace, only + // byte equivalence, but make sure to check. + `REPLACE('straße', 'ss', 'b')`, + `REPLACE('straße', 'ß', 'b')`, + // From / to strings are converted into the collation of + // the input string. + `REPLACE('fooÿbar', _latin1 0xFF, _latin1 0xFE)`, + // First occurence is replaced + `replace('fff', 'ff', 'gg')`, + } + + for _, q := range cases { + yield(q, nil) + } + + for _, substr := range inputStrings { + for _, str := range inputStrings { + for _, i := range inputStrings { + yield(fmt.Sprintf("REPLACE(%s, %s, %s)", substr, str, i), nil) + } + } + } +} + func FnConcat(yield Query) { for _, str := range inputStrings { yield(fmt.Sprintf("CONCAT(%s)", str), nil) diff --git a/go/vt/vtgate/evalengine/translate_builtin.go b/go/vt/vtgate/evalengine/translate_builtin.go index 71eff66bc2b..cabe406bfb6 100644 --- a/go/vt/vtgate/evalengine/translate_builtin.go +++ b/go/vt/vtgate/evalengine/translate_builtin.go @@ -627,6 +627,11 @@ func (ast *astCompiler) translateFuncExpr(fn *sqlparser.FuncExpr) (IR, error) { } call = CallExpr{Arguments: []IR{call.Arguments[1], call.Arguments[0]}, Method: method} return &builtinLocate{CallExpr: call, collate: ast.cfg.Collation}, nil + case "replace": + if len(args) != 3 { + return nil, argError(method) + } + return &builtinReplace{CallExpr: call, collate: ast.cfg.Collation}, nil default: return nil, translateExprNotSupported(fn) } From c4afae2950d57d5ddd5e31281ab7c69167d701c6 Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Mon, 19 Feb 2024 15:18:45 +0100 Subject: [PATCH 32/79] vtexplain: Ensure memory topo is set up for throttler (#15279) Signed-off-by: Dirkjan Bussink --- go/cmd/vtexplain/cli/vtexplain.go | 5 +- go/vt/srvtopo/watch.go | 11 ++-- go/vt/srvtopo/watch_srvkeyspace.go | 2 +- go/vt/vtadmin/api.go | 4 +- go/vt/vtexplain/vtexplain.go | 7 ++- go/vt/vtexplain/vtexplain_test.go | 19 +++--- go/vt/vtexplain/vtexplain_vtgate.go | 60 +++++++++++++------ go/vt/vtexplain/vtexplain_vttablet.go | 6 +- go/vt/vtexplain/vtexplain_vttablet_test.go | 18 ++++-- .../tabletserver/throttle/throttler.go | 4 +- 10 files changed, 92 insertions(+), 44 deletions(-) diff --git a/go/cmd/vtexplain/cli/vtexplain.go b/go/cmd/vtexplain/cli/vtexplain.go index aee920f6486..5c15112917e 100644 --- a/go/cmd/vtexplain/cli/vtexplain.go +++ b/go/cmd/vtexplain/cli/vtexplain.go @@ -24,6 +24,7 @@ import ( "vitess.io/vitess/go/acl" "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/servenv" + "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/vt/vtexplain" "vitess.io/vitess/go/vt/vtgate/planbuilder/plancontext" @@ -182,7 +183,9 @@ func parseAndRun() error { if err != nil { return err } - vte, err := vtexplain.Init(context.Background(), env, vschema, schema, ksShardMap, opts) + ctx := context.Background() + ts := memorytopo.NewServer(ctx, vtexplain.Cell) + vte, err := vtexplain.Init(ctx, env, ts, vschema, schema, ksShardMap, opts) if err != nil { return err } diff --git a/go/vt/srvtopo/watch.go b/go/vt/srvtopo/watch.go index 36d8fd428bd..4a0ccda2d59 100644 --- a/go/vt/srvtopo/watch.go +++ b/go/vt/srvtopo/watch.go @@ -23,6 +23,7 @@ import ( "time" "vitess.io/vitess/go/stats" + "vitess.io/vitess/go/timer" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/topo" ) @@ -204,8 +205,11 @@ func (entry *watchEntry) onErrorLocked(ctx context.Context, err error, init bool entry.value = nil } } else { - entry.lastError = fmt.Errorf("ResilientWatch stream failed for %v: %w", entry.key, err) - log.Errorf("%v", entry.lastError) + if !topo.IsErrType(err, topo.Interrupted) { + // No need to log if we're explicitly interrupted. + entry.lastError = fmt.Errorf("ResilientWatch stream failed for %v: %w", entry.key, err) + log.Errorf("%v", entry.lastError) + } // Even though we didn't get a new value, update the lastValueTime // here since the watch was successfully running before and we want @@ -224,8 +228,7 @@ func (entry *watchEntry) onErrorLocked(ctx context.Context, err error, init bool if len(entry.listeners) > 0 && !topo.IsErrType(err, topo.Interrupted) { go func() { - time.Sleep(entry.rw.cacheRefreshInterval) - + _ = timer.SleepContext(ctx, entry.rw.cacheRefreshInterval) entry.mutex.Lock() entry.ensureWatchingLocked(ctx) entry.mutex.Unlock() diff --git a/go/vt/srvtopo/watch_srvkeyspace.go b/go/vt/srvtopo/watch_srvkeyspace.go index cefe95c6951..ac2d8c0bac1 100644 --- a/go/vt/srvtopo/watch_srvkeyspace.go +++ b/go/vt/srvtopo/watch_srvkeyspace.go @@ -40,7 +40,7 @@ func (k *srvKeyspaceKey) String() string { func NewSrvKeyspaceWatcher(ctx context.Context, topoServer *topo.Server, counts *stats.CountersWithSingleLabel, cacheRefresh, cacheTTL time.Duration) *SrvKeyspaceWatcher { watch := func(entry *watchEntry) { key := entry.key.(*srvKeyspaceKey) - requestCtx, requestCancel := context.WithCancel(context.Background()) + requestCtx, requestCancel := context.WithCancel(ctx) defer requestCancel() current, changes, err := topoServer.WatchSrvKeyspace(requestCtx, key.cell, key.keyspace) diff --git a/go/vt/vtadmin/api.go b/go/vt/vtadmin/api.go index b462d1dcbb3..dce4ff041c9 100644 --- a/go/vt/vtadmin/api.go +++ b/go/vt/vtadmin/api.go @@ -39,6 +39,7 @@ import ( "vitess.io/vitess/go/vt/concurrency" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/topo" + "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/vtadmin/cluster" "vitess.io/vitess/go/vt/vtadmin/cluster/dynamic" @@ -2382,7 +2383,8 @@ func (api *API) VTExplain(ctx context.Context, req *vtadminpb.VTExplainRequest) return nil, er.Error() } - vte, err := vtexplain.Init(ctx, api.env, srvVSchema, schema, shardMap, &vtexplain.Options{ReplicationMode: "ROW"}) + ts := memorytopo.NewServer(ctx, vtexplain.Cell) + vte, err := vtexplain.Init(ctx, api.env, ts, srvVSchema, schema, shardMap, &vtexplain.Options{ReplicationMode: "ROW"}) if err != nil { return nil, fmt.Errorf("error initilaizing vtexplain: %w", err) } diff --git a/go/vt/vtexplain/vtexplain.go b/go/vt/vtexplain/vtexplain.go index 55a0e52b005..e16dea89d2b 100644 --- a/go/vt/vtexplain/vtexplain.go +++ b/go/vt/vtexplain/vtexplain.go @@ -28,6 +28,7 @@ import ( "github.com/spf13/pflag" + "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/vt/discovery" @@ -53,7 +54,7 @@ func init() { } const ( - vtexplainCell = "explainCell" + Cell = "explainCell" // ModeMulti is the default mode with autocommit implemented at vtgate ModeMulti = "multi" @@ -183,7 +184,7 @@ type TabletActions struct { } // Init sets up the fake execution environment -func Init(ctx context.Context, env *vtenv.Environment, vSchemaStr, sqlSchema, ksShardMapStr string, opts *Options) (*VTExplain, error) { +func Init(ctx context.Context, env *vtenv.Environment, ts *topo.Server, vSchemaStr, sqlSchema, ksShardMapStr string, opts *Options) (*VTExplain, error) { // Verify options if opts.ReplicationMode != "ROW" && opts.ReplicationMode != "STATEMENT" { return nil, fmt.Errorf("invalid replication mode \"%s\"", opts.ReplicationMode) @@ -206,7 +207,7 @@ func Init(ctx context.Context, env *vtenv.Environment, vSchemaStr, sqlSchema, ks env: env, } vte.setGlobalTabletEnv(tabletEnv) - err = vte.initVtgateExecutor(ctx, vSchemaStr, ksShardMapStr, opts) + err = vte.initVtgateExecutor(ctx, ts, vSchemaStr, ksShardMapStr, opts) if err != nil { return nil, fmt.Errorf("initVtgateExecutor: %v", err.Error()) } diff --git a/go/vt/vtexplain/vtexplain_test.go b/go/vt/vtexplain/vtexplain_test.go index 1c60ea5c34a..e7a6f4bdfc8 100644 --- a/go/vt/vtexplain/vtexplain_test.go +++ b/go/vt/vtexplain/vtexplain_test.go @@ -28,6 +28,7 @@ import ( "github.com/google/go-cmp/cmp" "github.com/stretchr/testify/require" + "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/test/utils" @@ -51,7 +52,7 @@ type testopts struct { shardmap map[string]map[string]*topo.ShardInfo } -func initTest(ctx context.Context, mode string, opts *Options, topts *testopts, t *testing.T) *VTExplain { +func initTest(ctx context.Context, ts *topo.Server, mode string, opts *Options, topts *testopts, t *testing.T) *VTExplain { schema, err := os.ReadFile("testdata/test-schema.sql") require.NoError(t, err) @@ -67,7 +68,7 @@ func initTest(ctx context.Context, mode string, opts *Options, topts *testopts, } opts.ExecutionMode = mode - vte, err := Init(ctx, vtenv.NewTestEnv(), string(vSchema), string(schema), shardmap, opts) + vte, err := Init(ctx, vtenv.NewTestEnv(), ts, string(vSchema), string(schema), shardmap, opts) require.NoError(t, err, "vtexplain Init error\n%s", string(schema)) return vte } @@ -90,7 +91,8 @@ func runTestCase(testcase, mode string, opts *Options, topts *testopts, t *testi t.Run(testcase, func(t *testing.T) { ctx := utils.LeakCheckContext(t) - vte := initTest(ctx, mode, opts, topts, t) + ts := memorytopo.NewServer(ctx, Cell) + vte := initTest(ctx, ts, mode, opts, topts, t) defer vte.Stop() sqlFile := fmt.Sprintf("testdata/%s-queries.sql", testcase) @@ -156,8 +158,8 @@ func TestExplain(t *testing.T) { func TestErrors(t *testing.T) { ctx := utils.LeakCheckContext(t) - - vte := initTest(ctx, ModeMulti, defaultTestOpts(), &testopts{}, t) + ts := memorytopo.NewServer(ctx, Cell) + vte := initTest(ctx, ts, ModeMulti, defaultTestOpts(), &testopts{}, t) defer vte.Stop() tests := []struct { @@ -196,8 +198,8 @@ func TestErrors(t *testing.T) { func TestJSONOutput(t *testing.T) { ctx := utils.LeakCheckContext(t) - - vte := initTest(ctx, ModeMulti, defaultTestOpts(), &testopts{}, t) + ts := memorytopo.NewServer(ctx, Cell) + vte := initTest(ctx, ts, ModeMulti, defaultTestOpts(), &testopts{}, t) defer vte.Stop() sql := "select 1 from user where id = 1" explains, err := vte.Run(sql) @@ -346,7 +348,8 @@ func TestInit(t *testing.T) { } }` schema := "create table table_missing_primary_vindex (id int primary key)" - _, err := Init(ctx, vtenv.NewTestEnv(), vschema, schema, "", defaultTestOpts()) + ts := memorytopo.NewServer(ctx, Cell) + _, err := Init(ctx, vtenv.NewTestEnv(), ts, vschema, schema, "", defaultTestOpts()) require.Error(t, err) require.Contains(t, err.Error(), "missing primary col vindex") } diff --git a/go/vt/vtexplain/vtexplain_vtgate.go b/go/vt/vtexplain/vtexplain_vtgate.go index f24725fcd7b..a5d9677f02a 100644 --- a/go/vt/vtexplain/vtexplain_vtgate.go +++ b/go/vt/vtexplain/vtexplain_vtgate.go @@ -22,26 +22,23 @@ package vtexplain import ( "context" "fmt" + "path" "sort" "strings" "vitess.io/vitess/go/cache/theine" - "vitess.io/vitess/go/vt/vtgate/logstats" - "vitess.io/vitess/go/vt/vtgate/vindexes" - - "vitess.io/vitess/go/vt/topo" - "vitess.io/vitess/go/vt/topo/memorytopo" - - "vitess.io/vitess/go/vt/vterrors" - "vitess.io/vitess/go/json2" "vitess.io/vitess/go/streamlog" "vitess.io/vitess/go/vt/discovery" "vitess.io/vitess/go/vt/key" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/srvtopo" + "vitess.io/vitess/go/vt/topo" + "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vtgate" "vitess.io/vitess/go/vt/vtgate/engine" + "vitess.io/vitess/go/vt/vtgate/logstats" + "vitess.io/vitess/go/vt/vtgate/vindexes" "vitess.io/vitess/go/vt/vttablet/queryservice" querypb "vitess.io/vitess/go/vt/proto/query" @@ -50,14 +47,14 @@ import ( vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" ) -func (vte *VTExplain) initVtgateExecutor(ctx context.Context, vSchemaStr, ksShardMapStr string, opts *Options) error { +func (vte *VTExplain) initVtgateExecutor(ctx context.Context, ts *topo.Server, vSchemaStr, ksShardMapStr string, opts *Options) error { vte.explainTopo = &ExplainTopo{NumShards: opts.NumShards} - vte.explainTopo.TopoServer = memorytopo.NewServer(ctx, vtexplainCell) + vte.explainTopo.TopoServer = ts vte.healthCheck = discovery.NewFakeHealthCheck(nil) - resolver := vte.newFakeResolver(ctx, opts, vte.explainTopo, vtexplainCell) + resolver := vte.newFakeResolver(ctx, opts, vte.explainTopo, Cell) - err := vte.buildTopology(ctx, opts, vSchemaStr, ksShardMapStr, opts.NumShards) + err := vte.buildTopology(ctx, ts, opts, vSchemaStr, ksShardMapStr, opts.NumShards) if err != nil { return err } @@ -75,7 +72,7 @@ func (vte *VTExplain) initVtgateExecutor(ctx context.Context, vSchemaStr, ksShar var schemaTracker vtgate.SchemaInfo // no schema tracker for these tests queryLogBufferSize := 10 plans := theine.NewStore[vtgate.PlanCacheKey, *engine.Plan](4*1024*1024, false) - vte.vtgateExecutor = vtgate.NewExecutor(ctx, vte.env, vte.explainTopo, vtexplainCell, resolver, opts.Normalize, false, streamSize, plans, schemaTracker, false, opts.PlannerVersion, 0) + vte.vtgateExecutor = vtgate.NewExecutor(ctx, vte.env, vte.explainTopo, Cell, resolver, opts.Normalize, false, streamSize, plans, schemaTracker, false, opts.PlannerVersion, 0) vte.vtgateExecutor.SetQueryLogger(streamlog.New[*logstats.LogStats]("VTGate", queryLogBufferSize)) return nil @@ -95,7 +92,7 @@ func (vte *VTExplain) newFakeResolver(ctx context.Context, opts *Options, serv s return vtgate.NewResolver(srvResolver, serv, cell, sc) } -func (vte *VTExplain) buildTopology(ctx context.Context, opts *Options, vschemaStr string, ksShardMapStr string, numShardsPerKeyspace int) error { +func (vte *VTExplain) buildTopology(ctx context.Context, ts *topo.Server, opts *Options, vschemaStr string, ksShardMapStr string, numShardsPerKeyspace int) error { vte.explainTopo.Lock.Lock() defer vte.explainTopo.Lock.Unlock() @@ -120,6 +117,10 @@ func (vte *VTExplain) buildTopology(ctx context.Context, opts *Options, vschemaS return err } + conn, err := ts.ConnForCell(ctx, Cell) + if err != nil { + return err + } vte.explainTopo.TabletConns = make(map[string]*explainTablet) vte.explainTopo.KeyspaceShards = make(map[string]map[string]*topodatapb.ShardReference) for ks, vschema := range vte.explainTopo.Keyspaces { @@ -130,6 +131,32 @@ func (vte *VTExplain) buildTopology(ctx context.Context, opts *Options, vschemaS vte.explainTopo.KeyspaceShards[ks] = make(map[string]*topodatapb.ShardReference) + srvPath := path.Join(topo.KeyspacesPath, ks, topo.SrvKeyspaceFile) + srvKeyspace := &topodatapb.SrvKeyspace{ + Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{ + { + ServedType: topodatapb.TabletType_PRIMARY, + ShardReferences: shards, + }, + { + ServedType: topodatapb.TabletType_REPLICA, + ShardReferences: shards, + }, + { + ServedType: topodatapb.TabletType_RDONLY, + ShardReferences: shards, + }, + }, + } + data, err := srvKeyspace.MarshalVT() + if err != nil { + return err + } + _, err = conn.Update(ctx, srvPath, data, nil) + if err != nil { + return err + } + for _, shard := range shards { // If the topology is in the middle of a reshard, there can be two shards covering the same key range (e.g. // both source shard 80- and target shard 80-c0 cover the keyrange 80-c0). For the purposes of explain, we @@ -142,14 +169,13 @@ func (vte *VTExplain) buildTopology(ctx context.Context, opts *Options, vschemaS hostname := fmt.Sprintf("%s/%s", ks, shard.Name) log.Infof("registering test tablet %s for keyspace %s shard %s", hostname, ks, shard.Name) - tablet := vte.healthCheck.AddFakeTablet(vtexplainCell, hostname, 1, ks, shard.Name, topodatapb.TabletType_PRIMARY, true, 1, nil, func(t *topodatapb.Tablet) queryservice.QueryService { - return vte.newTablet(ctx, vte.env, opts, t) + tablet := vte.healthCheck.AddFakeTablet(Cell, hostname, 1, ks, shard.Name, topodatapb.TabletType_PRIMARY, true, 1, nil, func(t *topodatapb.Tablet) queryservice.QueryService { + return vte.newTablet(ctx, vte.env, opts, t, ts) }) vte.explainTopo.TabletConns[hostname] = tablet.(*explainTablet) vte.explainTopo.KeyspaceShards[ks][shard.Name] = shard } } - return err } diff --git a/go/vt/vtexplain/vtexplain_vttablet.go b/go/vt/vtexplain/vtexplain_vttablet.go index 9ac81000f3d..b573fe29774 100644 --- a/go/vt/vtexplain/vtexplain_vttablet.go +++ b/go/vt/vtexplain/vtexplain_vttablet.go @@ -24,6 +24,7 @@ import ( "sync" "vitess.io/vitess/go/vt/sidecardb" + "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/mysql" @@ -35,7 +36,6 @@ import ( "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/mysqlctl" "vitess.io/vitess/go/vt/sqlparser" - "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/vtgate/evalengine" @@ -105,7 +105,7 @@ type explainTablet struct { var _ queryservice.QueryService = (*explainTablet)(nil) -func (vte *VTExplain) newTablet(ctx context.Context, env *vtenv.Environment, opts *Options, t *topodatapb.Tablet) *explainTablet { +func (vte *VTExplain) newTablet(ctx context.Context, env *vtenv.Environment, opts *Options, t *topodatapb.Tablet, ts *topo.Server) *explainTablet { db := fakesqldb.New(nil) sidecardb.AddSchemaInitQueries(db, true, env.Parser()) @@ -120,7 +120,7 @@ func (vte *VTExplain) newTablet(ctx context.Context, env *vtenv.Environment, opt config.EnableTableGC = false // XXX much of this is cloned from the tabletserver tests - tsv := tabletserver.NewTabletServer(ctx, env, topoproto.TabletAliasString(t.Alias), config, memorytopo.NewServer(ctx, ""), t.Alias) + tsv := tabletserver.NewTabletServer(ctx, env, topoproto.TabletAliasString(t.Alias), config, ts, t.Alias) tablet := explainTablet{db: db, tsv: tsv, vte: vte, collationEnv: env.CollationEnv()} db.Handler = &tablet diff --git a/go/vt/vtexplain/vtexplain_vttablet_test.go b/go/vt/vtexplain/vtexplain_vttablet_test.go index fc3785a907a..a4350316d82 100644 --- a/go/vt/vtexplain/vtexplain_vttablet_test.go +++ b/go/vt/vtexplain/vtexplain_vttablet_test.go @@ -20,12 +20,14 @@ import ( "context" "encoding/json" "testing" + "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/vt/sqlparser" + "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/vt/vttablet/tabletserver/schema" @@ -73,7 +75,8 @@ create table t2 ( ctx, cancel := context.WithCancel(context.Background()) defer cancel() - vte, err := Init(ctx, vtenv.NewTestEnv(), testVSchema, testSchema, "", opts) + ts := memorytopo.NewServer(ctx, Cell) + vte, err := Init(ctx, vtenv.NewTestEnv(), ts, testVSchema, testSchema, "", opts) require.NoError(t, err) defer vte.Stop() @@ -132,17 +135,22 @@ create table test_partitioned ( ctx, cancel := context.WithCancel(context.Background()) defer cancel() - vte := initTest(ctx, ModeMulti, defaultTestOpts(), &testopts{}, t) + ts := memorytopo.NewServer(ctx, Cell) + vte := initTest(ctx, ts, ModeMulti, defaultTestOpts(), &testopts{}, t) defer vte.Stop() tabletEnv, _ := newTabletEnvironment(ddls, defaultTestOpts(), env.CollationEnv()) vte.setGlobalTabletEnv(tabletEnv) tablet := vte.newTablet(ctx, env, defaultTestOpts(), &topodatapb.Tablet{ - Keyspace: "test_keyspace", + Keyspace: "ks_sharded", Shard: "-80", - Alias: &topodatapb.TabletAlias{}, - }) + Alias: &topodatapb.TabletAlias{ + Cell: Cell, + }, + }, ts) + + time.Sleep(10 * time.Millisecond) se := tablet.tsv.SchemaEngine() tables := se.GetSchema() diff --git a/go/vt/vttablet/tabletserver/throttle/throttler.go b/go/vt/vttablet/tabletserver/throttle/throttler.go index b75898a3256..8f6db91936d 100644 --- a/go/vt/vttablet/tabletserver/throttle/throttler.go +++ b/go/vt/vttablet/tabletserver/throttle/throttler.go @@ -358,7 +358,9 @@ func (throttler *Throttler) normalizeThrottlerConfig(throttlerConfig *topodatapb func (throttler *Throttler) WatchSrvKeyspaceCallback(srvks *topodatapb.SrvKeyspace, err error) bool { if err != nil { - log.Errorf("WatchSrvKeyspaceCallback error: %v", err) + if !topo.IsErrType(err, topo.Interrupted) && !errors.Is(err, context.Canceled) { + log.Errorf("WatchSrvKeyspaceCallback error: %v", err) + } return false } throttlerConfig := throttler.normalizeThrottlerConfig(srvks.ThrottlerConfig) From 4ddb70512f13959e9f68c6f935e143a0f2d73026 Mon Sep 17 00:00:00 2001 From: Matt Layher Date: Mon, 19 Feb 2024 10:36:50 -0500 Subject: [PATCH 33/79] go/vt/wrangler: pass reparent options structs (#15251) Signed-off-by: Matt Layher --- go/vt/vtctl/reparent.go | 19 ++++++++++++++--- go/vt/wrangler/reparent.go | 21 ++++--------------- .../testlib/emergency_reparent_shard_test.go | 9 +++++++- 3 files changed, 28 insertions(+), 21 deletions(-) diff --git a/go/vt/vtctl/reparent.go b/go/vt/vtctl/reparent.go index cd6cfe3fb6d..4498228d9c7 100644 --- a/go/vt/vtctl/reparent.go +++ b/go/vt/vtctl/reparent.go @@ -25,6 +25,7 @@ import ( "vitess.io/vitess/go/vt/mysqlctl" "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/topo/topoproto" + "vitess.io/vitess/go/vt/vtctl/reparentutil" "vitess.io/vitess/go/vt/wrangler" topodatapb "vitess.io/vitess/go/vt/proto/topodata" @@ -150,7 +151,13 @@ func commandPlannedReparentShard(ctx context.Context, wr *wrangler.Wrangler, sub return err } } - return wr.PlannedReparentShard(ctx, keyspace, shard, newPrimaryAlias, avoidTabletAlias, *waitReplicasTimeout, *tolerableReplicationLag) + + return wr.PlannedReparentShard(ctx, keyspace, shard, reparentutil.PlannedReparentOptions{ + NewPrimaryAlias: newPrimaryAlias, + AvoidPrimaryAlias: avoidTabletAlias, + WaitReplicasTimeout: *waitReplicasTimeout, + TolerableReplLag: *tolerableReplicationLag, + }) } func commandEmergencyReparentShard(ctx context.Context, wr *wrangler.Wrangler, subFlags *pflag.FlagSet, args []string) error { @@ -190,8 +197,14 @@ func commandEmergencyReparentShard(ctx context.Context, wr *wrangler.Wrangler, s return err } } - unreachableReplicas := topoproto.ParseTabletSet(*ignoreReplicasList) - return wr.EmergencyReparentShard(ctx, keyspace, shard, tabletAlias, *waitReplicasTimeout, unreachableReplicas, *preventCrossCellPromotion, *waitForAllTablets) + + return wr.EmergencyReparentShard(ctx, keyspace, shard, reparentutil.EmergencyReparentOptions{ + NewPrimaryAlias: tabletAlias, + WaitAllTablets: *waitForAllTablets, + WaitReplicasTimeout: *waitReplicasTimeout, + IgnoreReplicas: topoproto.ParseTabletSet(*ignoreReplicasList), + PreventCrossCellPromotion: *preventCrossCellPromotion, + }) } func commandTabletExternallyReparented(ctx context.Context, wr *wrangler.Wrangler, subFlags *pflag.FlagSet, args []string) error { diff --git a/go/vt/wrangler/reparent.go b/go/vt/wrangler/reparent.go index 98c5821f7c3..1a3a45cf99b 100644 --- a/go/vt/wrangler/reparent.go +++ b/go/vt/wrangler/reparent.go @@ -26,7 +26,6 @@ import ( "time" "vitess.io/vitess/go/event" - "vitess.io/vitess/go/sets" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/topotools/events" @@ -79,19 +78,13 @@ func (wr *Wrangler) InitShardPrimary(ctx context.Context, keyspace, shard string func (wr *Wrangler) PlannedReparentShard( ctx context.Context, keyspace, shard string, - primaryElectTabletAlias, avoidTabletAlias *topodatapb.TabletAlias, - waitReplicasTimeout, tolerableReplicationLag time.Duration, + opts reparentutil.PlannedReparentOptions, ) (err error) { _, err = reparentutil.NewPlannedReparenter(wr.ts, wr.tmc, wr.logger).ReparentShard( ctx, keyspace, shard, - reparentutil.PlannedReparentOptions{ - AvoidPrimaryAlias: avoidTabletAlias, - NewPrimaryAlias: primaryElectTabletAlias, - WaitReplicasTimeout: waitReplicasTimeout, - TolerableReplLag: tolerableReplicationLag, - }, + opts, ) return err @@ -99,18 +92,12 @@ func (wr *Wrangler) PlannedReparentShard( // EmergencyReparentShard will make the provided tablet the primary for // the shard, when the old primary is completely unreachable. -func (wr *Wrangler) EmergencyReparentShard(ctx context.Context, keyspace, shard string, primaryElectTabletAlias *topodatapb.TabletAlias, waitReplicasTimeout time.Duration, ignoredTablets sets.Set[string], preventCrossCellPromotion bool, waitForAllTablets bool) (err error) { +func (wr *Wrangler) EmergencyReparentShard(ctx context.Context, keyspace, shard string, opts reparentutil.EmergencyReparentOptions) (err error) { _, err = reparentutil.NewEmergencyReparenter(wr.ts, wr.tmc, wr.logger).ReparentShard( ctx, keyspace, shard, - reparentutil.EmergencyReparentOptions{ - NewPrimaryAlias: primaryElectTabletAlias, - WaitReplicasTimeout: waitReplicasTimeout, - IgnoreReplicas: ignoredTablets, - PreventCrossCellPromotion: preventCrossCellPromotion, - WaitAllTablets: waitForAllTablets, - }, + opts, ) return err diff --git a/go/vt/wrangler/testlib/emergency_reparent_shard_test.go b/go/vt/wrangler/testlib/emergency_reparent_shard_test.go index efdca1fc725..6cafe83b684 100644 --- a/go/vt/wrangler/testlib/emergency_reparent_shard_test.go +++ b/go/vt/wrangler/testlib/emergency_reparent_shard_test.go @@ -32,6 +32,7 @@ import ( "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/topo/topoproto" + "vitess.io/vitess/go/vt/vtctl/reparentutil" "vitess.io/vitess/go/vt/vtctl/reparentutil/reparenttestutil" "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/vt/vttablet/tmclient" @@ -279,7 +280,13 @@ func TestEmergencyReparentShardPrimaryElectNotBest(t *testing.T) { defer moreAdvancedReplica.StopActionLoop(t) // run EmergencyReparentShard - err := wr.EmergencyReparentShard(ctx, newPrimary.Tablet.Keyspace, newPrimary.Tablet.Shard, newPrimary.Tablet.Alias, 10*time.Second, sets.New[string](), false, false) + err := wr.EmergencyReparentShard(ctx, newPrimary.Tablet.Keyspace, newPrimary.Tablet.Shard, reparentutil.EmergencyReparentOptions{ + NewPrimaryAlias: newPrimary.Tablet.Alias, + WaitAllTablets: false, + WaitReplicasTimeout: 10 * time.Second, + IgnoreReplicas: sets.New[string](), + PreventCrossCellPromotion: false, + }) cancel() assert.NoError(t, err) From af3809949587dd4c03673880ec46365339dfd522 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Mon, 19 Feb 2024 14:25:32 -0500 Subject: [PATCH 34/79] VReplication: Add throttler stats (#15221) Signed-off-by: Matt Lord --- .../endtoend/vreplication/fk_config_test.go | 4 +- go/test/endtoend/vreplication/fk_test.go | 8 ++-- .../vreplication/vreplication_test.go | 38 +++++++++++++++---- go/vt/binlog/binlogplayer/binlog_player.go | 6 ++- go/vt/vtgate/sandbox_test.go | 5 ++- .../tabletmanager/vreplication/stats.go | 27 ++++++++++++- .../tabletmanager/vreplication/stats_test.go | 13 ++++++- .../tabletmanager/vreplication/vreplicator.go | 13 ++++++- .../vstreamer/helper_event_test.go | 2 +- .../tabletserver/vstreamer/vstreamer_test.go | 12 ++++++ 10 files changed, 108 insertions(+), 20 deletions(-) diff --git a/go/test/endtoend/vreplication/fk_config_test.go b/go/test/endtoend/vreplication/fk_config_test.go index 97d868cb371..822d44105b4 100644 --- a/go/test/endtoend/vreplication/fk_config_test.go +++ b/go/test/endtoend/vreplication/fk_config_test.go @@ -67,7 +67,7 @@ insert into t2 values(1, 1, 't21'), (2, 1, 't22'), (3, 2, 't23'); } ] }, - "t1": { + "t1": { "column_vindexes": [ { "column": "id", @@ -75,7 +75,7 @@ insert into t2 values(1, 1, 't21'), (2, 1, 't22'), (3, 2, 't23'); } ] }, - "t2": { + "t2": { "column_vindexes": [ { "column": "t1id", diff --git a/go/test/endtoend/vreplication/fk_test.go b/go/test/endtoend/vreplication/fk_test.go index 5d6cbb7b94c..e6133e9e0ff 100644 --- a/go/test/endtoend/vreplication/fk_test.go +++ b/go/test/endtoend/vreplication/fk_test.go @@ -283,10 +283,10 @@ func (ls *fkLoadSimulator) exec(query string) *sqltypes.Result { // constraints, where the parent table is lexicographically sorted before the child table and // thus may be dropped first, can be successfully cancelled. func testFKCancel(t *testing.T, vc *VitessCluster) { - var targetKeyspace = "fktarget" - var sourceKeyspace = "fksource" - var workflowName = "wf2" - var ksWorkflow = fmt.Sprintf("%s.%s", targetKeyspace, workflowName) + targetKeyspace := "fktarget" + sourceKeyspace := "fksource" + workflowName := "wf2" + ksWorkflow := fmt.Sprintf("%s.%s", targetKeyspace, workflowName) mt := newMoveTables(vc, &moveTablesWorkflow{ workflowInfo: &workflowInfo{ vc: vc, diff --git a/go/test/endtoend/vreplication/vreplication_test.go b/go/test/endtoend/vreplication/vreplication_test.go index 4e50ea12af3..c28118a97cc 100644 --- a/go/test/endtoend/vreplication/vreplication_test.go +++ b/go/test/endtoend/vreplication/vreplication_test.go @@ -22,6 +22,7 @@ import ( "io" "net/http" "runtime" + "strconv" "strings" "sync" "testing" @@ -1155,7 +1156,7 @@ func materialize(t *testing.T, spec string, useVtctldClient bool) { func materializeProduct(t *testing.T, useVtctldClient bool) { t.Run("materializeProduct", func(t *testing.T) { - // materializing from "product" keyspace to "customer" keyspace + // Materializing from "product" keyspace to "customer" keyspace. workflow := "cproduct" keyspace := "customer" defaultCell := vc.Cells[vc.CellNames[0]] @@ -1169,7 +1170,7 @@ func materializeProduct(t *testing.T, useVtctldClient bool) { productTablets := vc.getVttabletsInKeyspace(t, defaultCell, "product", "primary") t.Run("throttle-app-product", func(t *testing.T) { - // Now, throttle the streamer on source tablets, insert some rows + // Now, throttle the source side component (vstreamer), and insert some rows. for _, tab := range productTablets { body, err := throttleApp(tab, sourceThrottlerAppName) assert.NoError(t, err) @@ -1180,19 +1181,33 @@ func materializeProduct(t *testing.T, useVtctldClient bool) { waitForTabletThrottlingStatus(t, tab, targetThrottlerAppName, throttlerStatusNotThrottled) } insertMoreProductsForSourceThrottler(t) - // To be fair to the test, we give the target time to apply the new changes. We expect it to NOT get them in the first place, - // we expect the additional rows to **not appear** in the materialized view + // To be fair to the test, we give the target time to apply the new changes. We + // expect it to NOT get them in the first place, we expect the additional rows + // to **not appear** in the materialized view. for _, tab := range customerTablets { waitForRowCountInTablet(t, tab, keyspace, workflow, 5) + // Confirm that we updated the stats on the target tablets as expected. + jsVal, err := getDebugVar(t, tab.Port, []string{"VReplicationThrottledCounts"}) + require.NoError(t, err) + require.NotEqual(t, "{}", jsVal) + // The JSON value looks like this: {"cproduct.4.tablet.vstreamer": 2} + vstreamerThrottledCount := gjson.Get(jsVal, fmt.Sprintf(`%s\.*\.tablet\.vstreamer`, workflow)).Int() + require.Greater(t, vstreamerThrottledCount, int64(0)) + // We only need to do this stat check once. + val, err := getDebugVar(t, tab.Port, []string{"VReplicationThrottledCountTotal"}) + require.NoError(t, err) + throttledCount, err := strconv.ParseInt(val, 10, 64) + require.NoError(t, err) + require.GreaterOrEqual(t, throttledCount, vstreamerThrottledCount) } }) t.Run("unthrottle-app-product", func(t *testing.T) { - // unthrottle on source tablets, and expect the rows to show up + // Unthrottle the vstreamer component, and expect the rows to show up. for _, tab := range productTablets { body, err := unthrottleApp(tab, sourceThrottlerAppName) assert.NoError(t, err) assert.Contains(t, body, sourceThrottlerAppName) - // give time for unthrottling to take effect and for target to fetch data + // Give time for unthrottling to take effect and for targets to fetch data. waitForTabletThrottlingStatus(t, tab, sourceThrottlerAppName, throttlerStatusNotThrottled) } for _, tab := range customerTablets { @@ -1201,8 +1216,8 @@ func materializeProduct(t *testing.T, useVtctldClient bool) { }) t.Run("throttle-app-customer", func(t *testing.T) { - // Now, throttle vreplication (vcopier/vapplier) on target tablets, and - // insert some more rows. + // Now, throttle vreplication on the target side (vplayer), and insert some + // more rows. for _, tab := range customerTablets { body, err := throttleApp(tab, targetThrottlerAppName) assert.NoError(t, err) @@ -1217,6 +1232,13 @@ func materializeProduct(t *testing.T, useVtctldClient bool) { // rows to **not appear** in the materialized view. for _, tab := range customerTablets { waitForRowCountInTablet(t, tab, keyspace, workflow, 8) + // Confirm that we updated the stats on the target tablets as expected. + jsVal, err := getDebugVar(t, tab.Port, []string{"VReplicationThrottledCounts"}) + require.NoError(t, err) + require.NotEqual(t, "{}", jsVal) + // The JSON value now looks like this: {"cproduct.4.tablet.vstreamer": 2, "cproduct.4.tablet.vplayer": 4} + vplayerThrottledCount := gjson.Get(jsVal, fmt.Sprintf(`%s\.*\.tablet\.vplayer`, workflow)).Int() + require.Greater(t, vplayerThrottledCount, int64(0)) } }) t.Run("unthrottle-app-customer", func(t *testing.T) { diff --git a/go/vt/binlog/binlogplayer/binlog_player.go b/go/vt/binlog/binlogplayer/binlog_player.go index 88c4093f451..6bdc2d70d2d 100644 --- a/go/vt/binlog/binlogplayer/binlog_player.go +++ b/go/vt/binlog/binlogplayer/binlog_player.go @@ -105,6 +105,8 @@ type Stats struct { PartialQueryCount *stats.CountersWithMultiLabels PartialQueryCacheSize *stats.CountersWithMultiLabels + + ThrottledCounts *stats.CountersWithMultiLabels // By throttler and component } // RecordHeartbeat updates the time the last heartbeat from vstreamer was seen @@ -174,6 +176,7 @@ func NewStats() *Stats { bps.TableCopyTimings = stats.NewTimings("", "", "Table") bps.PartialQueryCacheSize = stats.NewCountersWithMultiLabels("", "", []string{"type"}) bps.PartialQueryCount = stats.NewCountersWithMultiLabels("", "", []string{"type"}) + bps.ThrottledCounts = stats.NewCountersWithMultiLabels("", "", []string{"throttler", "component"}) return bps } @@ -369,13 +372,14 @@ func (blp *BinlogPlayer) applyEvents(ctx context.Context) error { if backoff == throttler.NotThrottled { break } + blp.blplStats.ThrottledCounts.Add([]string{"trx", "binlogplayer"}, 1) // We don't bother checking for context cancellation here because the // sleep will block only up to 1 second. (Usually, backoff is 1s / rate // e.g. a rate of 1000 TPS results into a backoff of 1 ms.) time.Sleep(backoff) } - // get the response + // Get the response. response, err := stream.Recv() // Check context before checking error, because canceled // contexts could be wrapped as regular errors. diff --git a/go/vt/vtgate/sandbox_test.go b/go/vt/vtgate/sandbox_test.go index 3ceee09d5f7..27be6442cfe 100644 --- a/go/vt/vtgate/sandbox_test.go +++ b/go/vt/vtgate/sandbox_test.go @@ -281,7 +281,10 @@ func (sct *sandboxTopo) WatchSrvVSchema(ctx context.Context, cell string, callba } sct.topoServer.UpdateSrvVSchema(ctx, cell, srvVSchema) - current, updateChan, _ := sct.topoServer.WatchSrvVSchema(ctx, cell) + current, updateChan, err := sct.topoServer.WatchSrvVSchema(ctx, cell) + if err != nil { + panic(fmt.Sprintf("sandboxTopo WatchSrvVSchema returned an error: %v", err)) + } if !callback(current.Value, nil) { panic("sandboxTopo callback returned false") } diff --git a/go/vt/vttablet/tabletmanager/vreplication/stats.go b/go/vt/vttablet/tabletmanager/vreplication/stats.go index 892247efee0..5b5b6ede24c 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/stats.go +++ b/go/vt/vttablet/tabletmanager/vreplication/stats.go @@ -59,10 +59,12 @@ type vrStats struct { mu sync.Mutex isOpen bool controllers map[int32]*controller + + ThrottledCount *stats.Counter } func (st *vrStats) register() { - + st.ThrottledCount = stats.NewCounter("", "") stats.NewGaugeFunc("VReplicationStreamCount", "Number of vreplication streams", st.numControllers) stats.NewGaugeFunc("VReplicationLagSecondsMax", "Max vreplication seconds behind primary", st.maxReplicationLagSeconds) stats.NewStringMapFuncWithMultiLabels( @@ -502,6 +504,29 @@ func (st *vrStats) register() { return result }) + stats.NewCounterFunc( + "VReplicationThrottledCountTotal", + "The total number of times that vreplication has been throttled", + func() int64 { + st.mu.Lock() + defer st.mu.Unlock() + return st.ThrottledCount.Get() + }) + stats.NewCountersFuncWithMultiLabels( + "VReplicationThrottledCounts", + "The number of times vreplication was throttled by workflow, id, throttler (trx or tablet), and the sub-component that was throttled", + []string{"workflow", "id", "throttler", "component"}, + func() map[string]int64 { + st.mu.Lock() + defer st.mu.Unlock() + result := make(map[string]int64) + for _, ct := range st.controllers { + for key, val := range ct.blpStats.ThrottledCounts.Counts() { + result[fmt.Sprintf("%s.%d.%s", ct.workflow, ct.id, key)] = val + } + } + return result + }) } func (st *vrStats) numControllers() int64 { diff --git a/go/vt/vttablet/tabletmanager/vreplication/stats_test.go b/go/vt/vttablet/tabletmanager/vreplication/stats_test.go index 79149d34d6d..d94802adb7b 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/stats_test.go +++ b/go/vt/vttablet/tabletmanager/vreplication/stats_test.go @@ -26,6 +26,7 @@ import ( "github.com/stretchr/testify/require" "vitess.io/vitess/go/mysql/replication" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/binlog/binlogplayer" "vitess.io/vitess/go/vt/proto/binlogdata" @@ -132,7 +133,9 @@ func TestStatusHtml(t *testing.T) { func TestVReplicationStats(t *testing.T) { blpStats := binlogplayer.NewStats() defer blpStats.Stop() - testStats := &vrStats{} + testStats := &vrStats{ + ThrottledCount: stats.NewCounter("", ""), + } testStats.isOpen = true testStats.controllers = map[int32]*controller{ 1: { @@ -184,6 +187,14 @@ func TestVReplicationStats(t *testing.T) { require.Equal(t, int64(100), testStats.status().Controllers[0].CopyLoopCount) require.Equal(t, int64(200), testStats.status().Controllers[0].CopyRowCount) + testStats.ThrottledCount.Add(99) + require.Equal(t, int64(99), testStats.ThrottledCount.Get()) + + blpStats.ThrottledCounts.Add([]string{"tablet", "vcopier"}, 10) + blpStats.ThrottledCounts.Add([]string{"tablet", "vplayer"}, 80) + require.Equal(t, int64(10), testStats.controllers[1].blpStats.ThrottledCounts.Counts()["tablet.vcopier"]) + require.Equal(t, int64(80), testStats.controllers[1].blpStats.ThrottledCounts.Counts()["tablet.vplayer"]) + var tm int64 = 1234567890 blpStats.RecordHeartbeat(tm) require.Equal(t, tm, blpStats.Heartbeat()) diff --git a/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go b/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go index 67f4815b2a1..daa642c53af 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go @@ -580,10 +580,21 @@ func (vr *vreplicator) throttlerAppName() string { return throttlerapp.Concatenate(names...) } +// updateTimeThrottled updates the time_throttled field in the _vt.vreplication record +// with a rate limit so that it's only saved in the database at most once per +// throttleUpdatesRateLimiter.tickerTime. +// It also increments the throttled count in the stats to keep track of how many +// times a VReplication workflow, and the specific sub-component, is throttled by the +// tablet throttler over time. It also increments the global throttled count to keep +// track of how many times in total vreplication has been throttled across all workflows +// (both ones that currently exist and ones that no longer do). func (vr *vreplicator) updateTimeThrottled(appThrottled throttlerapp.Name) error { + appName := appThrottled.String() + vr.stats.ThrottledCounts.Add([]string{"tablet", appName}, 1) + globalStats.ThrottledCount.Add(1) err := vr.throttleUpdatesRateLimiter.Do(func() error { tm := time.Now().Unix() - update, err := binlogplayer.GenerateUpdateTimeThrottled(vr.id, tm, appThrottled.String()) + update, err := binlogplayer.GenerateUpdateTimeThrottled(vr.id, tm, appName) if err != nil { return err } diff --git a/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go b/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go index cc586756fe8..0b479bd588c 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go @@ -61,7 +61,7 @@ const ( ) func getDefaultCollationID() int64 { - return 45 + return 45 // utf8mb4_general_ci } var ( diff --git a/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go b/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go index 5a1a786513f..4d1983cd4d3 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go @@ -89,6 +89,12 @@ func TestNoBlob(t *testing.T) { env = nil newEngine(t, ctx, "noblob") defer func() { + if engine != nil { + engine.Close() + } + if env != nil { + env.Close() + } engine = oldEngine env = oldEnv }() @@ -1854,6 +1860,12 @@ func TestMinimalMode(t *testing.T) { env = nil newEngine(t, ctx, "minimal") defer func() { + if engine != nil { + engine.Close() + } + if env != nil { + env.Close() + } engine = oldEngine env = oldEnv }() From 241fb442059666a65dff14fa53674eefbc1632f7 Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Tue, 20 Feb 2024 00:14:09 -0500 Subject: [PATCH 35/79] Rewrite _many_ tests to use vtctldclient invocations, mostly non-output related stuff (#15270) Signed-off-by: Andrew Mason --- .../backup/vtbackup/backup_only_test.go | 10 +- .../backup/vtctlbackup/backup_utils.go | 103 +++++++++--------- go/test/endtoend/cellalias/cell_alias_test.go | 24 ++-- go/test/endtoend/cluster/cluster_process.go | 12 +- go/test/endtoend/cluster/cluster_util.go | 4 +- .../endtoend/cluster/vtctldclient_process.go | 92 ++++++++++++++++ go/test/endtoend/clustertest/vttablet_test.go | 2 +- .../encrypted_replication_test.go | 2 +- go/test/endtoend/keyspace/keyspace_test.go | 38 ++++--- go/test/endtoend/messaging/message_test.go | 20 ++-- go/test/endtoend/migration/migration_test.go | 4 +- go/test/endtoend/mysqlctl/mysqlctl_test.go | 2 +- go/test/endtoend/mysqlctld/mysqlctld_test.go | 2 +- .../onlineddl/ghost/onlineddl_ghost_test.go | 4 +- .../onlineddl/revert/onlineddl_revert_test.go | 2 +- .../scheduler/onlineddl_scheduler_test.go | 14 +-- .../onlineddl/vrepl/onlineddl_vrepl_test.go | 14 +-- .../onlineddl_vrepl_mini_stress_test.go | 6 +- .../onlineddl_vrepl_stress_suite_test.go | 6 +- go/test/endtoend/onlineddl/vtctlutil.go | 4 +- .../recovery/pitr/shardedpitr_test.go | 36 +++--- .../recovery/unshardedrecovery/recovery.go | 16 +-- .../reparent/emergencyreparent/ers_test.go | 32 +++--- 23 files changed, 269 insertions(+), 180 deletions(-) diff --git a/go/test/endtoend/backup/vtbackup/backup_only_test.go b/go/test/endtoend/backup/vtbackup/backup_only_test.go index 69c12d4376c..3f5389d2726 100644 --- a/go/test/endtoend/backup/vtbackup/backup_only_test.go +++ b/go/test/endtoend/backup/vtbackup/backup_only_test.go @@ -83,10 +83,10 @@ func TestTabletInitialBackup(t *testing.T) { restore(t, primary, "replica", "NOT_SERVING") // Vitess expects that the user has set the database into ReadWrite mode before calling // TabletExternallyReparented - err = localCluster.VtctlclientProcess.ExecuteCommand( - "SetReadWrite", primary.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand( + "SetWritable", primary.Alias, "true") require.Nil(t, err) - err = localCluster.VtctlclientProcess.ExecuteCommand( + err = localCluster.VtctldClientProcess.ExecuteCommand( "TabletExternallyReparented", primary.Alias) require.Nil(t, err) restore(t, replica1, "replica", "SERVING") @@ -277,7 +277,7 @@ func initTablets(t *testing.T, startTablet bool, initShardPrimary bool) { if initShardPrimary { // choose primary and start replication - err := localCluster.VtctlclientProcess.InitShardPrimary(keyspaceName, shardName, cell, primary.TabletUID) + err := localCluster.VtctldClientProcess.InitShardPrimary(keyspaceName, shardName, cell, primary.TabletUID) require.Nil(t, err) } } @@ -339,7 +339,7 @@ func tearDown(t *testing.T, initMysql bool) { for _, tablet := range []cluster.Vttablet{*primary, *replica1, *replica2} { resetTabletDirectory(t, tablet, initMysql) // DeleteTablet on a primary will cause tablet to shutdown, so should only call it after tablet is already shut down - err := localCluster.VtctlclientProcess.ExecuteCommand("DeleteTablet", "--", "--allow_primary", tablet.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("DeleteTablets", "--allow-primary", tablet.Alias) require.Nil(t, err) } } diff --git a/go/test/endtoend/backup/vtctlbackup/backup_utils.go b/go/test/endtoend/backup/vtctlbackup/backup_utils.go index a70d1804028..c20ab70e652 100644 --- a/go/test/endtoend/backup/vtctlbackup/backup_utils.go +++ b/go/test/endtoend/backup/vtctlbackup/backup_utils.go @@ -257,7 +257,7 @@ func LaunchCluster(setupType int, streamMode string, stripes int, cDetails *Comp return replica3, nil } - if err := localCluster.VtctlclientProcess.InitShardPrimary(keyspaceName, shard.Name, cell, primary.TabletUID); err != nil { + if err := localCluster.VtctldClientProcess.InitShardPrimary(keyspaceName, shard.Name, cell, primary.TabletUID); err != nil { return 1, err } @@ -455,7 +455,7 @@ func primaryBackup(t *testing.T) { localCluster.VerifyBackupCount(t, shardKsName, 0) - err = localCluster.VtctlclientProcess.ExecuteCommand("Backup", "--", "--allow_primary=true", primary.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", "--allow-primary", primary.Alias) require.Nil(t, err) // We'll restore this on the primary later to test restores using a backup timestamp @@ -475,7 +475,7 @@ func primaryBackup(t *testing.T) { // And only 1 record after we restore using the first backup timestamp cluster.VerifyRowsInTablet(t, replica2, keyspaceName, 2) - err = localCluster.VtctlclientProcess.ExecuteCommand("Backup", "--", "--allow_primary=true", primary.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", "--allow-primary", primary.Alias) require.Nil(t, err) backups = localCluster.VerifyBackupCount(t, shardKsName, 2) @@ -485,26 +485,25 @@ func primaryBackup(t *testing.T) { // Perform PRS to demote the primary tablet (primary) so that we can do a restore there and verify we don't have the // data from after the older/first backup - err = localCluster.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", - "--keyspace_shard", shardKsName, - "--new_primary", replica2.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", + "--new-primary", replica2.Alias, shardKsName) require.Nil(t, err) // Delete the current primary tablet (replica2) so that the original primary tablet (primary) can be restored from the // older/first backup w/o it replicating the subsequent insert done after the first backup was taken - err = localCluster.VtctlclientProcess.ExecuteCommand("DeleteTablet", "--", "--allow_primary=true", replica2.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("DeleteTablets", "--allow-primary", replica2.Alias) require.Nil(t, err) err = replica2.VttabletProcess.TearDown() require.Nil(t, err) // Restore the older/first backup -- using the timestamp we saved -- on the original primary tablet (primary) - err = localCluster.VtctlclientProcess.ExecuteCommand("RestoreFromBackup", "--", "--backup_timestamp", firstBackupTimestamp, primary.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("RestoreFromBackup", "--backup-timestamp", firstBackupTimestamp, primary.Alias) require.Nil(t, err) verifyTabletRestoreStats(t, primary.VttabletProcess.GetVars()) // Re-init the shard -- making the original primary tablet (primary) primary again -- for subsequent tests - err = localCluster.VtctlclientProcess.InitShardPrimary(keyspaceName, shardName, cell, primary.TabletUID) + err = localCluster.VtctldClientProcess.InitShardPrimary(keyspaceName, shardName, cell, primary.TabletUID) require.Nil(t, err) // Verify that we don't have the record created after the older/first backup @@ -526,7 +525,7 @@ func primaryReplicaSameBackup(t *testing.T) { verifyInitialReplication(t) // backup the replica - err := localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.Nil(t, err) verifyTabletBackupStats(t, replica1.VttabletProcess.GetVars()) @@ -544,9 +543,8 @@ func primaryReplicaSameBackup(t *testing.T) { cluster.VerifyRowsInTablet(t, replica2, keyspaceName, 2) // Promote replica2 to primary - err = localCluster.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", - "--keyspace_shard", shardKsName, - "--new_primary", replica2.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", + "--new-primary", replica2.Alias, shardKsName) require.Nil(t, err) // insert more data on replica2 (current primary) @@ -564,7 +562,7 @@ func primaryReplicaSameBackup(t *testing.T) { // It is written into the MANIFEST and read back from the MANIFEST. // // Take another backup on the replica. - err = localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.Nil(t, err) // Insert more data on replica2 (current primary). @@ -594,7 +592,7 @@ func primaryReplicaSameBackupModifiedCompressionEngine(t *testing.T) { time.Sleep(5 * time.Second) // backup the replica - err := localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.Nil(t, err) verifyTabletBackupStats(t, replica1.VttabletProcess.GetVars()) @@ -619,9 +617,8 @@ func primaryReplicaSameBackupModifiedCompressionEngine(t *testing.T) { cluster.VerifyRowsInTablet(t, replica2, keyspaceName, 2) // Promote replica2 to primary - err = localCluster.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", - "--keyspace_shard", shardKsName, - "--new_primary", replica2.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", + "--new-primary", replica2.Alias, shardKsName) require.Nil(t, err) // insert more data on replica2 (current primary) @@ -635,9 +632,8 @@ func primaryReplicaSameBackupModifiedCompressionEngine(t *testing.T) { cluster.VerifyRowsInTablet(t, replica1, keyspaceName, 3) // Promote replica1 to primary - err = localCluster.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", - "--keyspace_shard", shardKsName, - "--new_primary", replica1.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", + "--new-primary", replica1.Alias, shardKsName) require.Nil(t, err) // Insert more data on replica1 (current primary). @@ -648,7 +644,7 @@ func primaryReplicaSameBackupModifiedCompressionEngine(t *testing.T) { cluster.VerifyRowsInTablet(t, replica2, keyspaceName, 4) // Now take replica2 backup with gzip (new compressor) - err = localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica2.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica2.Alias) require.Nil(t, err) verifyTabletBackupStats(t, replica2.VttabletProcess.GetVars()) @@ -688,7 +684,7 @@ func testRestoreOldPrimary(t *testing.T, method restoreMethod) { time.Sleep(5 * time.Second) // backup the replica - err := localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.Nil(t, err) verifyTabletBackupStats(t, replica1.VttabletProcess.GetVars()) @@ -698,9 +694,8 @@ func testRestoreOldPrimary(t *testing.T, method restoreMethod) { require.Nil(t, err) // reparent to replica1 - err = localCluster.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", - "--keyspace_shard", shardKsName, - "--new_primary", replica1.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", + "--new-primary", replica1.Alias, shardKsName) require.Nil(t, err) // insert more data to new primary @@ -726,7 +721,7 @@ func restoreUsingRestart(t *testing.T, tablet *cluster.Vttablet) { } func restoreInPlace(t *testing.T, tablet *cluster.Vttablet) { - err := localCluster.VtctlclientProcess.ExecuteCommand("RestoreFromBackup", tablet.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("RestoreFromBackup", tablet.Alias) require.Nil(t, err) } @@ -756,7 +751,7 @@ func restartPrimaryAndReplica(t *testing.T) { err = tablet.VttabletProcess.Setup() require.Nil(t, err) } - err := localCluster.VtctlclientProcess.InitShardPrimary(keyspaceName, shardName, cell, primary.TabletUID) + err := localCluster.VtctldClientProcess.InitShardPrimary(keyspaceName, shardName, cell, primary.TabletUID) require.Nil(t, err) } @@ -766,12 +761,12 @@ func stopAllTablets() { tablet.VttabletProcess.TearDown() if tablet.MysqlctldProcess.TabletUID > 0 { tablet.MysqlctldProcess.Stop() - localCluster.VtctlclientProcess.ExecuteCommand("DeleteTablet", "--", "--allow_primary", tablet.Alias) + localCluster.VtctldClientProcess.ExecuteCommand("DeleteTablets", "--allow-primary", tablet.Alias) continue } proc, _ := tablet.MysqlctlProcess.StopProcess() mysqlProcs = append(mysqlProcs, proc) - localCluster.VtctlclientProcess.ExecuteCommand("DeleteTablet", "--", "--allow_primary", tablet.Alias) + localCluster.VtctldClientProcess.ExecuteCommand("DeleteTablets", "--allow-primary", tablet.Alias) } for _, proc := range mysqlProcs { proc.Wait() @@ -796,7 +791,7 @@ func terminatedRestore(t *testing.T) { checkTabletType(t, replica1.Alias, topodata.TabletType_REPLICA) // backup the replica - err := localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.Nil(t, err) checkTabletType(t, replica1.Alias, topodata.TabletType_REPLICA) @@ -807,9 +802,8 @@ func terminatedRestore(t *testing.T) { require.Nil(t, err) // reparent to replica1 - err = localCluster.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", - "--keyspace_shard", shardKsName, - "--new_primary", replica1.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", + "--new-primary", replica1.Alias, shardKsName) require.Nil(t, err) // insert more data to new primary @@ -821,7 +815,7 @@ func terminatedRestore(t *testing.T) { // If restore fails then the tablet type goes back to original type. checkTabletType(t, primary.Alias, topodata.TabletType_REPLICA) - err = localCluster.VtctlclientProcess.ExecuteCommand("RestoreFromBackup", primary.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("RestoreFromBackup", primary.Alias) require.Nil(t, err) checkTabletType(t, primary.Alias, topodata.TabletType_REPLICA) @@ -863,7 +857,7 @@ func doNotDemoteNewlyPromotedPrimaryIfReparentingDuringBackup(t *testing.T) { checkTabletType(t, primary.Alias, topodata.TabletType_PRIMARY) // now backup - err := localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.Nil(t, err) }() @@ -874,10 +868,11 @@ func doNotDemoteNewlyPromotedPrimaryIfReparentingDuringBackup(t *testing.T) { checkTabletType(t, primary.Alias, topodata.TabletType_PRIMARY) // now reparent - _, err := localCluster.VtctlclientProcess.ExecuteCommandWithOutput( - "PlannedReparentShard", "--", - "--keyspace_shard", fmt.Sprintf("%s/%s", keyspaceName, shardName), - "--new_primary", replica1.Alias) + _, err := localCluster.VtctldClientProcess.ExecuteCommandWithOutput( + "PlannedReparentShard", + "--new-primary", replica1.Alias, + fmt.Sprintf("%s/%s", keyspaceName, shardName), + ) require.Nil(t, err) // check that we reparented @@ -906,13 +901,13 @@ func doNotDemoteNewlyPromotedPrimaryIfReparentingDuringBackup(t *testing.T) { func vtctlBackup(t *testing.T, tabletType string) { // StopReplication on replica1. We verify that the replication works fine later in // verifyInitialReplication. So this will also check that VTOrc is running. - err := localCluster.VtctlclientProcess.ExecuteCommand("StopReplication", replica1.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("StopReplication", replica1.Alias) require.Nil(t, err) verifyInitialReplication(t) restoreWaitForBackup(t, tabletType, nil, true) - err = localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.Nil(t, err) backups := localCluster.VerifyBackupCount(t, shardKsName, 1) @@ -930,7 +925,7 @@ func vtctlBackup(t *testing.T, tabletType string) { err = replica2.VttabletProcess.TearDown() require.Nil(t, err) - err = localCluster.VtctlclientProcess.ExecuteCommand("DeleteTablet", replica2.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("DeleteTablets", replica2.Alias) require.Nil(t, err) _, err = primary.VttabletProcess.QueryTablet("DROP TABLE vt_insert_test", keyspaceName, true) require.Nil(t, err) @@ -976,7 +971,7 @@ func restoreWaitForBackup(t *testing.T, tabletType string, cDetails *Compression } func RemoveBackup(t *testing.T, backupName string) { - err := localCluster.VtctlclientProcess.ExecuteCommand("RemoveBackup", shardKsName, backupName) + err := localCluster.VtctldClientProcess.ExecuteCommand("RemoveBackup", shardKsName, backupName) require.Nil(t, err) } @@ -1002,9 +997,9 @@ func verifyRestoreTablet(t *testing.T, tablet *cluster.Vttablet, status string) // We restart replication here because semi-sync will not be set correctly on tablet startup since // we deprecated enable_semi_sync. StartReplication RPC fixes the semi-sync settings by consulting the // durability policies set. - err = localCluster.VtctlclientProcess.ExecuteCommand("StopReplication", tablet.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("StopReplication", tablet.Alias) require.NoError(t, err) - err = localCluster.VtctlclientProcess.ExecuteCommand("StartReplication", tablet.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("StartReplication", tablet.Alias) require.NoError(t, err) if tablet.Type == "replica" { @@ -1033,13 +1028,13 @@ func terminateBackup(t *testing.T, alias string) { }() } - args := append([]string{"--server", localCluster.VtctlclientProcess.Server, "--alsologtostderr"}, "Backup", "--", alias) + args := append([]string{"--server", localCluster.VtctldClientProcess.Server, "--alsologtostderr"}, "Backup", alias) tmpProcess := exec.Command( - "vtctlclient", + "vtctldclient", args..., ) - reader, _ := tmpProcess.StderrPipe() + reader, _ := tmpProcess.StdoutPipe() err := tmpProcess.Start() require.Nil(t, err) found := false @@ -1067,13 +1062,13 @@ func terminateRestore(t *testing.T) { }() } - args := append([]string{"--server", localCluster.VtctlclientProcess.Server, "--alsologtostderr"}, "RestoreFromBackup", "--", primary.Alias) + args := append([]string{"--server", localCluster.VtctldClientProcess.Server, "--alsologtostderr"}, "RestoreFromBackup", primary.Alias) tmpProcess := exec.Command( - "vtctlclient", + "vtctldclient", args..., ) - reader, _ := tmpProcess.StderrPipe() + reader, _ := tmpProcess.StdoutPipe() err := tmpProcess.Start() require.Nil(t, err) found := false @@ -1289,7 +1284,7 @@ func TestReplicaIncrementalBackup(t *testing.T, replicaIndex int, incrementalFro func TestReplicaFullRestore(t *testing.T, replicaIndex int, expectError string) { replica := getReplica(t, replicaIndex) - output, err := localCluster.VtctlclientProcess.ExecuteCommandWithOutput("RestoreFromBackup", replica.Alias) + output, err := localCluster.VtctldClientProcess.ExecuteCommandWithOutput("RestoreFromBackup", replica.Alias) if expectError != "" { require.Errorf(t, err, "expected: %v", expectError) require.Contains(t, output, expectError) @@ -1304,7 +1299,7 @@ func TestReplicaRestoreToPos(t *testing.T, replicaIndex int, restoreToPos replic require.False(t, restoreToPos.IsZero()) restoreToPosArg := replication.EncodePosition(restoreToPos) - output, err := localCluster.VtctlclientProcess.ExecuteCommandWithOutput("RestoreFromBackup", "--", "--restore_to_pos", restoreToPosArg, replica.Alias) + output, err := localCluster.VtctldClientProcess.ExecuteCommandWithOutput("RestoreFromBackup", "--restore-to-pos", restoreToPosArg, replica.Alias) if expectError != "" { require.Errorf(t, err, "expected: %v", expectError) require.Contains(t, output, expectError) diff --git a/go/test/endtoend/cellalias/cell_alias_test.go b/go/test/endtoend/cellalias/cell_alias_test.go index d357331d8cd..07e8d687f4e 100644 --- a/go/test/endtoend/cellalias/cell_alias_test.go +++ b/go/test/endtoend/cellalias/cell_alias_test.go @@ -186,14 +186,14 @@ func TestMain(m *testing.M) { return 1, err } } - if err := localCluster.VtctlclientProcess.InitializeShard(keyspaceName, shard1.Name, shard1Primary.Cell, shard1Primary.TabletUID); err != nil { + if err := localCluster.VtctldClientProcess.InitializeShard(keyspaceName, shard1.Name, shard1Primary.Cell, shard1Primary.TabletUID); err != nil { return 1, err } // run a health check on source replica so it responds to discovery // (for binlog players) and on the source rdonlys (for workers) for _, tablet := range []string{shard1Replica.Alias, shard1Rdonly.Alias} { - if err := localCluster.VtctlclientProcess.ExecuteCommand("RunHealthCheck", tablet); err != nil { + if err := localCluster.VtctldClientProcess.ExecuteCommand("RunHealthCheck", tablet); err != nil { return 1, err } } @@ -204,7 +204,7 @@ func TestMain(m *testing.M) { } } - if err := localCluster.VtctlclientProcess.InitializeShard(keyspaceName, shard2.Name, shard2Primary.Cell, shard2Primary.TabletUID); err != nil { + if err := localCluster.VtctldClientProcess.InitializeShard(keyspaceName, shard2.Name, shard2Primary.Cell, shard2Primary.TabletUID); err != nil { return 1, err } @@ -212,14 +212,14 @@ func TestMain(m *testing.M) { return 1, err } - if err := localCluster.VtctlclientProcess.ApplySchema(keyspaceName, fmt.Sprintf(sqlSchema, tableName)); err != nil { + if err := localCluster.VtctldClientProcess.ApplySchema(keyspaceName, fmt.Sprintf(sqlSchema, tableName)); err != nil { return 1, err } - if err := localCluster.VtctlclientProcess.ApplyVSchema(keyspaceName, fmt.Sprintf(vSchema, tableName)); err != nil { + if err := localCluster.VtctldClientProcess.ApplyVSchema(keyspaceName, fmt.Sprintf(vSchema, tableName)); err != nil { return 1, err } - _ = localCluster.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) + _ = localCluster.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) return m.Run(), nil }() @@ -237,7 +237,7 @@ func TestAlias(t *testing.T) { insertInitialValues(t) defer deleteInitialValues(t) - err := localCluster.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) + err := localCluster.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) require.NoError(t, err) shard1 := localCluster.Keyspaces[0].Shards[0] shard2 := localCluster.Keyspaces[0].Shards[1] @@ -251,11 +251,11 @@ func TestAlias(t *testing.T) { cluster.CheckSrvKeyspace(t, cell2, keyspaceName, expectedPartitions, *localCluster) // Adds alias so vtgate can route to replica/rdonly tablets that are not in the same cell, but same alias - err = localCluster.VtctlclientProcess.ExecuteCommand("AddCellsAlias", "--", + err = localCluster.VtctldClientProcess.ExecuteCommand("AddCellsAlias", "--cells", allCells, "region_east_coast") require.NoError(t, err) - err = localCluster.VtctlclientProcess.ExecuteCommand("UpdateCellsAlias", "--", + err = localCluster.VtctldClientProcess.ExecuteCommand("UpdateCellsAlias", "--cells", allCells, "region_east_coast") require.NoError(t, err) @@ -277,7 +277,7 @@ func TestAlias(t *testing.T) { testQueriesOnTabletType(t, "rdonly", vtgateInstance.GrpcPort, false) // now, delete the alias, so that if we run above assertions again, it will fail for replica,rdonly target type - err = localCluster.VtctlclientProcess.ExecuteCommand("DeleteCellsAlias", + err = localCluster.VtctldClientProcess.ExecuteCommand("DeleteCellsAlias", "region_east_coast") require.NoError(t, err) @@ -301,7 +301,7 @@ func TestAddAliasWhileVtgateUp(t *testing.T) { insertInitialValues(t) defer deleteInitialValues(t) - err := localCluster.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) + err := localCluster.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) require.NoError(t, err) shard1 := localCluster.Keyspaces[0].Shards[0] shard2 := localCluster.Keyspaces[0].Shards[1] @@ -328,7 +328,7 @@ func TestAddAliasWhileVtgateUp(t *testing.T) { testQueriesOnTabletType(t, "rdonly", vtgateInstance.GrpcPort, true) // Adds alias so vtgate can route to replica/rdonly tablets that are not in the same cell, but same alias - err = localCluster.VtctlclientProcess.ExecuteCommand("AddCellsAlias", "--", + err = localCluster.VtctldClientProcess.ExecuteCommand("AddCellsAlias", "--cells", allCells, "region_east_coast") require.NoError(t, err) diff --git a/go/test/endtoend/cluster/cluster_process.go b/go/test/endtoend/cluster/cluster_process.go index a9cc482b9e3..98218bcf3fb 100644 --- a/go/test/endtoend/cluster/cluster_process.go +++ b/go/test/endtoend/cluster/cluster_process.go @@ -421,7 +421,7 @@ func (cluster *LocalProcessCluster) startKeyspace(keyspace Keyspace, shardNames } // Make first tablet as primary - if err = cluster.VtctlclientProcess.InitializeShard(keyspace.Name, shardName, cluster.Cell, shard.Vttablets[0].TabletUID); err != nil { + if err = cluster.VtctldClientProcess.InitializeShard(keyspace.Name, shardName, cluster.Cell, shard.Vttablets[0].TabletUID); err != nil { log.Errorf("error running InitializeShard on keyspace %v, shard %v: %v", keyspace.Name, shardName, err) return } @@ -441,7 +441,7 @@ func (cluster *LocalProcessCluster) startKeyspace(keyspace Keyspace, shardNames // Apply Schema SQL if keyspace.SchemaSQL != "" { - if err = cluster.VtctlclientProcess.ApplySchema(keyspace.Name, keyspace.SchemaSQL); err != nil { + if err = cluster.VtctldClientProcess.ApplySchema(keyspace.Name, keyspace.SchemaSQL); err != nil { log.Errorf("error applying schema: %v, %v", keyspace.SchemaSQL, err) return } @@ -449,7 +449,7 @@ func (cluster *LocalProcessCluster) startKeyspace(keyspace Keyspace, shardNames // Apply VSchema if keyspace.VSchema != "" { - if err = cluster.VtctlclientProcess.ApplyVSchema(keyspace.Name, keyspace.VSchema); err != nil { + if err = cluster.VtctldClientProcess.ApplyVSchema(keyspace.Name, keyspace.VSchema); err != nil { log.Errorf("error applying vschema: %v, %v", keyspace.VSchema, err) return } @@ -581,7 +581,7 @@ func (cluster *LocalProcessCluster) StartKeyspaceLegacy(keyspace Keyspace, shard } // Make first tablet as primary - if err = cluster.VtctlclientProcess.InitShardPrimary(keyspace.Name, shardName, cluster.Cell, shard.Vttablets[0].TabletUID); err != nil { + if err = cluster.VtctldClientProcess.InitShardPrimary(keyspace.Name, shardName, cluster.Cell, shard.Vttablets[0].TabletUID); err != nil { log.Errorf("error running ISM on keyspace %v, shard %v: %v", keyspace.Name, shardName, err) return } @@ -601,7 +601,7 @@ func (cluster *LocalProcessCluster) StartKeyspaceLegacy(keyspace Keyspace, shard // Apply Schema SQL if keyspace.SchemaSQL != "" { - if err = cluster.VtctlclientProcess.ApplySchema(keyspace.Name, keyspace.SchemaSQL); err != nil { + if err = cluster.VtctldClientProcess.ApplySchema(keyspace.Name, keyspace.SchemaSQL); err != nil { log.Errorf("error applying schema: %v, %v", keyspace.SchemaSQL, err) return } @@ -609,7 +609,7 @@ func (cluster *LocalProcessCluster) StartKeyspaceLegacy(keyspace Keyspace, shard // Apply VSchema if keyspace.VSchema != "" { - if err = cluster.VtctlclientProcess.ApplyVSchema(keyspace.Name, keyspace.VSchema); err != nil { + if err = cluster.VtctldClientProcess.ApplyVSchema(keyspace.Name, keyspace.VSchema); err != nil { log.Errorf("error applying vschema: %v, %v", keyspace.VSchema, err) return } diff --git a/go/test/endtoend/cluster/cluster_util.go b/go/test/endtoend/cluster/cluster_util.go index a35c3bf3769..9fcefba3892 100644 --- a/go/test/endtoend/cluster/cluster_util.go +++ b/go/test/endtoend/cluster/cluster_util.go @@ -138,7 +138,7 @@ func PanicHandler(t testing.TB) { // ListBackups Lists back preset in shard func (cluster LocalProcessCluster) ListBackups(shardKsName string) ([]string, error) { - output, err := cluster.VtctlclientProcess.ExecuteCommandWithOutput("ListBackups", shardKsName) + output, err := cluster.VtctldClientProcess.ExecuteCommandWithOutput("GetBackups", shardKsName) if err != nil { return nil, err } @@ -165,7 +165,7 @@ func (cluster LocalProcessCluster) RemoveAllBackups(t *testing.T, shardKsName st backups, err := cluster.ListBackups(shardKsName) require.Nil(t, err) for _, backup := range backups { - cluster.VtctlclientProcess.ExecuteCommand("RemoveBackup", shardKsName, backup) + cluster.VtctldClientProcess.ExecuteCommand("RemoveBackup", shardKsName, backup) } } diff --git a/go/test/endtoend/cluster/vtctldclient_process.go b/go/test/endtoend/cluster/vtctldclient_process.go index 52e0f985680..959ab5a93b9 100644 --- a/go/test/endtoend/cluster/vtctldclient_process.go +++ b/go/test/endtoend/cluster/vtctldclient_process.go @@ -22,7 +22,11 @@ import ( "strings" "time" + "vitess.io/vitess/go/json2" "vitess.io/vitess/go/vt/log" + "vitess.io/vitess/go/vt/vterrors" + + topodatapb "vitess.io/vitess/go/vt/proto/topodata" ) // VtctldClientProcess is a generic handle for a running vtctldclient command . @@ -93,6 +97,68 @@ func VtctldClientProcessInstance(hostname string, grpcPort int, tmpDirectory str return vtctldclient } +type ApplySchemaParams struct { + DDLStrategy string + MigrationContext string + UUIDs string + CallerID string + BatchSize int +} + +// ApplySchemaWithOutput applies SQL schema to the keyspace +func (vtctldclient *VtctldClientProcess) ApplySchemaWithOutput(keyspace string, sql string, params ApplySchemaParams) (result string, err error) { + args := []string{ + "ApplySchema", + "--sql", sql, + } + if params.MigrationContext != "" { + args = append(args, "--migration-context", params.MigrationContext) + } + if params.DDLStrategy != "" { + args = append(args, "--ddl-strategy", params.DDLStrategy) + } + if params.UUIDs != "" { + args = append(args, "--uuid", params.UUIDs) + } + if params.BatchSize > 0 { + args = append(args, "--batch-size", fmt.Sprintf("%d", params.BatchSize)) + } + if params.CallerID != "" { + args = append(args, "--caller-id", params.CallerID) + } + args = append(args, keyspace) + return vtctldclient.ExecuteCommandWithOutput(args...) +} + +// ApplySchema applies SQL schema to the keyspace +func (vtctldclient *VtctldClientProcess) ApplySchema(keyspace string, sql string) error { + message, err := vtctldclient.ApplySchemaWithOutput(keyspace, sql, ApplySchemaParams{DDLStrategy: "direct -allow-zero-in-date"}) + + return vterrors.Wrap(err, message) +} + +// ApplyVSchema applies vitess schema (JSON format) to the keyspace +func (vtctldclient *VtctldClientProcess) ApplyVSchema(keyspace string, json string) (err error) { + return vtctldclient.ExecuteCommand( + "ApplyVSchema", + "--vschema", json, + keyspace, + ) +} + +// GetSrvKeyspaces returns a mapping of cell to srv keyspace for the given keyspace. +func (vtctldclient *VtctldClientProcess) GetSrvKeyspaces(keyspace string, cells ...string) (ksMap map[string]*topodatapb.SrvKeyspace, err error) { + args := append([]string{"GetSrvKeyspaces", keyspace}, cells...) + out, err := vtctldclient.ExecuteCommandWithOutput(args...) + if err != nil { + return nil, err + } + + ksMap = map[string]*topodatapb.SrvKeyspace{} + err = json2.Unmarshal([]byte(out), &ksMap) + return ksMap, err +} + // PlannedReparentShard executes vtctlclient command to make specified tablet the primary for the shard. func (vtctldclient *VtctldClientProcess) PlannedReparentShard(Keyspace string, Shard string, alias string) (err error) { output, err := vtctldclient.ExecuteCommandWithOutput( @@ -105,6 +171,32 @@ func (vtctldclient *VtctldClientProcess) PlannedReparentShard(Keyspace string, S return err } +// InitializeShard executes vtctldclient command to make specified tablet the primary for the shard. +func (vtctldclient *VtctldClientProcess) InitializeShard(keyspace string, shard string, cell string, uid int) error { + output, err := vtctldclient.ExecuteCommandWithOutput( + "PlannedReparentShard", + fmt.Sprintf("%s/%s", keyspace, shard), + "--wait-replicas-timeout", "31s", + "--new-primary", fmt.Sprintf("%s-%d", cell, uid)) + if err != nil { + log.Errorf("error in PlannedReparentShard output %s, err %s", output, err.Error()) + } + return err +} + +// InitShardPrimary executes vtctldclient command to make specified tablet the primary for the shard. +func (vtctldclient *VtctldClientProcess) InitShardPrimary(keyspace string, shard string, cell string, uid int) error { + output, err := vtctldclient.ExecuteCommandWithOutput( + "InitShardPrimary", + "--force", "--wait-replicas-timeout", "31s", + fmt.Sprintf("%s/%s", keyspace, shard), + fmt.Sprintf("%s-%d", cell, uid)) + if err != nil { + log.Errorf("error in InitShardPrimary output %s, err %s", output, err.Error()) + } + return err +} + // CreateKeyspace executes the vtctl command to create a keyspace func (vtctldclient *VtctldClientProcess) CreateKeyspace(keyspaceName string, sidecarDBName string) (err error) { var output string diff --git a/go/test/endtoend/clustertest/vttablet_test.go b/go/test/endtoend/clustertest/vttablet_test.go index 369deb18cfd..5e7d5e27182 100644 --- a/go/test/endtoend/clustertest/vttablet_test.go +++ b/go/test/endtoend/clustertest/vttablet_test.go @@ -51,6 +51,6 @@ func TestDeleteTablet(t *testing.T) { defer cluster.PanicHandler(t) primary := clusterInstance.Keyspaces[0].Shards[0].PrimaryTablet() require.NotNil(t, primary) - _, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("DeleteTablet", "--", "--allow_primary", primary.Alias) + _, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("DeleteTablets", "--allow-primary", primary.Alias) require.NoError(t, err) } diff --git a/go/test/endtoend/encryption/encryptedreplication/encrypted_replication_test.go b/go/test/endtoend/encryption/encryptedreplication/encrypted_replication_test.go index 725659a5ee1..4c759ff577a 100644 --- a/go/test/endtoend/encryption/encryptedreplication/encrypted_replication_test.go +++ b/go/test/endtoend/encryption/encryptedreplication/encrypted_replication_test.go @@ -74,7 +74,7 @@ func testReplicationBase(t *testing.T, isClientCertPassed bool) { } // Reparent using SSL (this will also check replication works) - err = clusterInstance.VtctlclientProcess.InitializeShard(keyspace, shardName, clusterInstance.Cell, primaryTablet.TabletUID) + err = clusterInstance.VtctldClientProcess.InitializeShard(keyspace, shardName, clusterInstance.Cell, primaryTablet.TabletUID) if isClientCertPassed { require.NoError(t, err) } else { diff --git a/go/test/endtoend/keyspace/keyspace_test.go b/go/test/endtoend/keyspace/keyspace_test.go index 338ad5c8cd2..142e4b4b442 100644 --- a/go/test/endtoend/keyspace/keyspace_test.go +++ b/go/test/endtoend/keyspace/keyspace_test.go @@ -24,6 +24,7 @@ import ( "strings" "testing" + "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/vt/key" "github.com/stretchr/testify/assert" @@ -109,7 +110,7 @@ func TestMain(m *testing.M) { if err := clusterForKSTest.StartKeyspace(*keyspaceSharded, []string{"-80", "80-"}, 1, false); err != nil { return 1 } - if err := clusterForKSTest.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceShardedName); err != nil { + if err := clusterForKSTest.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceShardedName); err != nil { return 1 } @@ -121,7 +122,7 @@ func TestMain(m *testing.M) { if err := clusterForKSTest.StartKeyspace(*keyspaceUnsharded, []string{keyspaceUnshardedName}, 1, false); err != nil { return 1 } - if err := clusterForKSTest.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceUnshardedName); err != nil { + if err := clusterForKSTest.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceUnshardedName); err != nil { return 1 } @@ -228,48 +229,49 @@ func TestGetKeyspace(t *testing.T) { func TestDeleteKeyspace(t *testing.T) { defer cluster.PanicHandler(t) - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("CreateKeyspace", "test_delete_keyspace") - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("CreateShard", "test_delete_keyspace/0") + _ = clusterForKSTest.VtctldClientProcess.CreateKeyspace("test_delete_keyspace", sidecar.DefaultName) + _ = clusterForKSTest.VtctldClientProcess.ExecuteCommand("CreateShard", "test_delete_keyspace/0") _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("InitTablet", "--", "--keyspace=test_delete_keyspace", "--shard=0", "zone1-0000000100", "primary") // Can't delete keyspace if there are shards present. - err := clusterForKSTest.VtctlclientProcess.ExecuteCommand("DeleteKeyspace", "test_delete_keyspace") + err := clusterForKSTest.VtctldClientProcess.ExecuteCommand("DeleteKeyspace", "test_delete_keyspace") require.Error(t, err) // Can't delete shard if there are tablets present. - err = clusterForKSTest.VtctlclientProcess.ExecuteCommand("DeleteShard", "--", "--even_if_serving", "test_delete_keyspace/0") + err = clusterForKSTest.VtctldClientProcess.ExecuteCommand("DeleteShards", "--even-if-serving", "test_delete_keyspace/0") require.Error(t, err) // Use recursive DeleteShard to remove tablets. - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("DeleteShard", "--", "--even_if_serving", "--recursive", "test_delete_keyspace/0") + _ = clusterForKSTest.VtctldClientProcess.ExecuteCommand("DeleteShards", "--even-if-serving", "--recursive", "test_delete_keyspace/0") // Now non-recursive DeleteKeyspace should work. - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("DeleteKeyspace", "test_delete_keyspace") + _ = clusterForKSTest.VtctldClientProcess.ExecuteCommand("DeleteKeyspace", "test_delete_keyspace") // Start over and this time use recursive DeleteKeyspace to do everything. - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("CreateKeyspace", "test_delete_keyspace") - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("CreateShard", "test_delete_keyspace/0") + _ = clusterForKSTest.VtctldClientProcess.CreateKeyspace("test_delete_keyspace", sidecar.DefaultName) + _ = clusterForKSTest.VtctldClientProcess.ExecuteCommand("CreateShard", "test_delete_keyspace/0") _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("InitTablet", "--", "--port=1234", "--bind-address=127.0.0.1", "--keyspace=test_delete_keyspace", "--shard=0", "zone1-0000000100", "primary") // Create the serving/replication entries and check that they exist, // so we can later check they're deleted. - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", "test_delete_keyspace") + _ = clusterForKSTest.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", "test_delete_keyspace") _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("GetShardReplication", cell, "test_delete_keyspace/0") - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("GetSrvKeyspace", cell, "test_delete_keyspace") + _ = clusterForKSTest.VtctldClientProcess.ExecuteCommand("GetSrvKeyspaces", "test_delete_keyspace", cell) // Recursive DeleteKeyspace - _ = clusterForKSTest.VtctlclientProcess.ExecuteCommand("DeleteKeyspace", "--", "--recursive", "test_delete_keyspace") + _ = clusterForKSTest.VtctldClientProcess.ExecuteCommand("DeleteKeyspace", "--recursive", "test_delete_keyspace") // Check that everything is gone. - err = clusterForKSTest.VtctlclientProcess.ExecuteCommand("GetKeyspace", "test_delete_keyspace") + err = clusterForKSTest.VtctldClientProcess.ExecuteCommand("GetKeyspace", "test_delete_keyspace") require.Error(t, err) - err = clusterForKSTest.VtctlclientProcess.ExecuteCommand("GetShard", "test_delete_keyspace/0") + err = clusterForKSTest.VtctldClientProcess.ExecuteCommand("GetShard", "test_delete_keyspace/0") require.Error(t, err) - err = clusterForKSTest.VtctlclientProcess.ExecuteCommand("GetTablet", "zone1-0000000100") + err = clusterForKSTest.VtctldClientProcess.ExecuteCommand("GetTablet", "zone1-0000000100") require.Error(t, err) err = clusterForKSTest.VtctlclientProcess.ExecuteCommand("GetShardReplication", cell, "test_delete_keyspace/0") require.Error(t, err) - err = clusterForKSTest.VtctlclientProcess.ExecuteCommand("GetSrvKeyspace", cell, "test_delete_keyspace") - require.Error(t, err) + ksMap, err := clusterForKSTest.VtctldClientProcess.GetSrvKeyspaces("test_delete_keyspace", cell) + require.NoError(t, err) + require.Empty(t, ksMap[cell]) } // TODO: Fix this test, not running in CI diff --git a/go/test/endtoend/messaging/message_test.go b/go/test/endtoend/messaging/message_test.go index 3082f295055..7e1190c16bb 100644 --- a/go/test/endtoend/messaging/message_test.go +++ b/go/test/endtoend/messaging/message_test.go @@ -393,12 +393,12 @@ func TestReparenting(t *testing.T) { // do planned reparenting, make one replica as primary // and validate client connection count in correspond tablets - clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput( - "PlannedReparentShard", "--", - "--keyspace_shard", userKeyspace+"/-80", - "--new_primary", shard0Replica.Alias) + clusterInstance.VtctldClientProcess.ExecuteCommand( + "PlannedReparentShard", + userKeyspace+"/-80", + "--new-primary", shard0Replica.Alias) // validate topology - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Validate") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Validate") require.Nil(t, err) // Verify connection has migrated. @@ -417,12 +417,12 @@ func TestReparenting(t *testing.T) { stream.Next() // make old primary again as new primary - clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput( - "PlannedReparentShard", "--", - "--keyspace_shard", userKeyspace+"/-80", - "--new_primary", shard0Primary.Alias) + clusterInstance.VtctldClientProcess.ExecuteCommand( + "PlannedReparentShard", + userKeyspace+"/-80", + "--new-primary", shard0Primary.Alias) // validate topology - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Validate") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Validate") require.Nil(t, err) time.Sleep(10 * time.Second) assertClientCount(t, 1, shard0Primary) diff --git a/go/test/endtoend/migration/migration_test.go b/go/test/endtoend/migration/migration_test.go index f0b91e2d6df..eca112e388d 100644 --- a/go/test/endtoend/migration/migration_test.go +++ b/go/test/endtoend/migration/migration_test.go @@ -145,7 +145,7 @@ func TestMigration(t *testing.T) { vt.ExtraArgs = append(vt.ExtraArgs, "--tablet_config", yamlFile) } createKeyspace(t, commerce, []string{"0"}, tabletConfig) - err := clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", "commerce") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", "commerce") require.NoError(t, err) err = clusterInstance.StartVtgate() @@ -221,7 +221,7 @@ func migrate(t *testing.T, fromdb, toks string, tables []string) { "('%s', '%s', %s, '', 9999, 9999, 'primary', 0, 0, 'Running')", tables[0], "vt_"+toks, sqlEscaped.String()) fmt.Printf("VReplicationExec: %s\n", query) vttablet := keyspaces[toks].Shards[0].Vttablets[0].VttabletProcess - err := clusterInstance.VtctlclientProcess.ExecuteCommand("VReplicationExec", vttablet.TabletPath, query) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("VReplicationExec", vttablet.TabletPath, query) require.NoError(t, err) } diff --git a/go/test/endtoend/mysqlctl/mysqlctl_test.go b/go/test/endtoend/mysqlctl/mysqlctl_test.go index 3b28c5bcf30..bdea4d3988c 100644 --- a/go/test/endtoend/mysqlctl/mysqlctl_test.go +++ b/go/test/endtoend/mysqlctl/mysqlctl_test.go @@ -156,6 +156,6 @@ func TestAutoDetect(t *testing.T) { require.Nil(t, err, "error should be nil") // Reparent tablets, which requires flavor detection - err = clusterInstance.VtctlclientProcess.InitializeShard(keyspaceName, shardName, cell, primaryTablet.TabletUID) + err = clusterInstance.VtctldClientProcess.InitializeShard(keyspaceName, shardName, cell, primaryTablet.TabletUID) require.Nil(t, err, "error should be nil") } diff --git a/go/test/endtoend/mysqlctld/mysqlctld_test.go b/go/test/endtoend/mysqlctld/mysqlctld_test.go index e1577acfc52..52be2fa4323 100644 --- a/go/test/endtoend/mysqlctld/mysqlctld_test.go +++ b/go/test/endtoend/mysqlctld/mysqlctld_test.go @@ -159,7 +159,7 @@ func TestAutoDetect(t *testing.T) { require.Nil(t, err, "error should be nil") // Reparent tablets, which requires flavor detection - err = clusterInstance.VtctlclientProcess.InitializeShard(keyspaceName, shardName, cell, primaryTablet.TabletUID) + err = clusterInstance.VtctldClientProcess.InitializeShard(keyspaceName, shardName, cell, primaryTablet.TabletUID) require.Nil(t, err, "error should be nil") } diff --git a/go/test/endtoend/onlineddl/ghost/onlineddl_ghost_test.go b/go/test/endtoend/onlineddl/ghost/onlineddl_ghost_test.go index 3dc635c8870..41a9a80086b 100644 --- a/go/test/endtoend/onlineddl/ghost/onlineddl_ghost_test.go +++ b/go/test/endtoend/onlineddl/ghost/onlineddl_ghost_test.go @@ -370,7 +370,7 @@ func testWithInitialSchema(t *testing.T) { for i := 0; i < totalTableCount; i++ { tableName := fmt.Sprintf("vt_onlineddl_test_%02d", i) sqlQuery = fmt.Sprintf(createTable, tableName) - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, sqlQuery) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, sqlQuery) require.Nil(t, err) for _, insert := range insertStatements { @@ -395,7 +395,7 @@ func testOnlineDDLStatement(t *testing.T, alterStatement string, ddlStrategy str } } else { var err error - uuid, err = clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, sqlQuery, cluster.VtctlClientParams{DDLStrategy: ddlStrategy, CallerID: callerID}) + uuid, err = clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, sqlQuery, cluster.ApplySchemaParams{DDLStrategy: ddlStrategy, CallerID: callerID}) assert.NoError(t, err) } uuid = strings.TrimSpace(uuid) diff --git a/go/test/endtoend/onlineddl/revert/onlineddl_revert_test.go b/go/test/endtoend/onlineddl/revert/onlineddl_revert_test.go index d4517e67aff..672e79c0985 100644 --- a/go/test/endtoend/onlineddl/revert/onlineddl_revert_test.go +++ b/go/test/endtoend/onlineddl/revert/onlineddl_revert_test.go @@ -1194,7 +1194,7 @@ func testOnlineDDLStatement(t *testing.T, alterStatement string, ddlStrategy str } } else { var err error - uuid, err = clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.VtctlClientParams{DDLStrategy: ddlStrategy}) + uuid, err = clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.ApplySchemaParams{DDLStrategy: ddlStrategy}) assert.NoError(t, err) } uuid = strings.TrimSpace(uuid) diff --git a/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go b/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go index 3c2c25ec8b5..01f7024f59c 100644 --- a/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go +++ b/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go @@ -82,7 +82,7 @@ var ( keyspaceName = "ks" cell = "zone1" schemaChangeDirectory = "" - overrideVtctlParams *cluster.VtctlClientParams + overrideVtctlParams *cluster.ApplySchemaParams ) type WriteMetrics struct { @@ -949,7 +949,7 @@ func testScheduler(t *testing.T) { t.Run("Idempotent submission, retry failed migration", func(t *testing.T) { uuid := "00000000_1111_2222_3333_444444444444" - overrideVtctlParams = &cluster.VtctlClientParams{DDLStrategy: ddlStrategy, UUIDList: uuid, MigrationContext: "idempotent:1111-2222-3333"} + overrideVtctlParams = &cluster.ApplySchemaParams{DDLStrategy: ddlStrategy, UUIDs: uuid, MigrationContext: "idempotent:1111-2222-3333"} defer func() { overrideVtctlParams = nil }() // create a migration and cancel it. We don't let it complete. We want it in "failed" state t.Run("start and fail migration", func(t *testing.T) { @@ -985,7 +985,7 @@ func testScheduler(t *testing.T) { t.Run("Idempotent submission, retry failed migration in singleton context", func(t *testing.T) { uuid := "00000000_1111_3333_3333_444444444444" ddlStrategy := ddlStrategy + " --singleton-context" - overrideVtctlParams = &cluster.VtctlClientParams{DDLStrategy: ddlStrategy, UUIDList: uuid, MigrationContext: "idempotent:1111-3333-3333"} + overrideVtctlParams = &cluster.ApplySchemaParams{DDLStrategy: ddlStrategy, UUIDs: uuid, MigrationContext: "idempotent:1111-3333-3333"} defer func() { overrideVtctlParams = nil }() // create a migration and cancel it. We don't let it complete. We want it in "failed" state t.Run("start and fail migration", func(t *testing.T) { @@ -2391,7 +2391,7 @@ func testForeignKeys(t *testing.T) { continue } statement := fmt.Sprintf("DROP TABLE IF EXISTS %s", artifact) - _, err := clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, statement, cluster.VtctlClientParams{DDLStrategy: "direct"}) + _, err := clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, statement, cluster.ApplySchemaParams{DDLStrategy: "direct"}) if err == nil { droppedTables[artifact] = true } @@ -2423,11 +2423,11 @@ func testOnlineDDLStatement(t *testing.T, params *testOnlineDDLStatementParams) } } } else { - vtctlParams := &cluster.VtctlClientParams{DDLStrategy: params.ddlStrategy, MigrationContext: params.migrationContext} + vtctlParams := &cluster.ApplySchemaParams{DDLStrategy: params.ddlStrategy, MigrationContext: params.migrationContext} if overrideVtctlParams != nil { vtctlParams = overrideVtctlParams } - output, err := clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, params.ddlStatement, *vtctlParams) + output, err := clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, params.ddlStatement, *vtctlParams) switch params.expectError { case anyErrorIndicator: if err != nil { @@ -2472,7 +2472,7 @@ func testRevertMigration(t *testing.T, params *testRevertMigrationParams) (uuid } } } else { - output, err := clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, revertQuery, cluster.VtctlClientParams{DDLStrategy: params.ddlStrategy, MigrationContext: params.migrationContext}) + output, err := clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, revertQuery, cluster.ApplySchemaParams{DDLStrategy: params.ddlStrategy, MigrationContext: params.migrationContext}) if params.expectError == "" { assert.NoError(t, err) uuid = output diff --git a/go/test/endtoend/onlineddl/vrepl/onlineddl_vrepl_test.go b/go/test/endtoend/onlineddl/vrepl/onlineddl_vrepl_test.go index 49e72eda290..e5df3051612 100644 --- a/go/test/endtoend/onlineddl/vrepl/onlineddl_vrepl_test.go +++ b/go/test/endtoend/onlineddl/vrepl/onlineddl_vrepl_test.go @@ -458,7 +458,7 @@ func TestSchemaChange(t *testing.T) { time.Sleep(10 * time.Second) onlineddl.CheckCancelAllMigrations(t, &vtParams, 0) // Validate that invoking CANCEL ALL via vtctl works - onlineddl.CheckCancelAllMigrationsViaVtctl(t, &clusterInstance.VtctlclientProcess, keyspaceName) + onlineddl.CheckCancelAllMigrationsViaVtctld(t, &clusterInstance.VtctldClientProcess, keyspaceName) }) t.Run("cancel all migrations: some migrations to cancel", func(t *testing.T) { // Use VTGate for throttling, issue a `ALTER VITESS_MIGRATION THROTTLE ALL ...` @@ -497,7 +497,7 @@ func TestSchemaChange(t *testing.T) { } wg.Wait() // cancelling via vtctl does not return values. We CANCEL ALL via vtctl, then validate via VTGate that nothing remains to be cancelled. - onlineddl.CheckCancelAllMigrationsViaVtctl(t, &clusterInstance.VtctlclientProcess, keyspaceName) + onlineddl.CheckCancelAllMigrationsViaVtctld(t, &clusterInstance.VtctldClientProcess, keyspaceName) onlineddl.CheckCancelAllMigrations(t, &vtParams, 0) }) @@ -555,7 +555,7 @@ func TestSchemaChange(t *testing.T) { }) t.Run("PRS shard -80", func(t *testing.T) { // migration has started and is throttled. We now run PRS - err := clusterInstance.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", "--keyspace_shard", keyspaceName+"/-80", "--new_primary", reparentTablet.Alias) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", keyspaceName+"/-80", "--new-primary", reparentTablet.Alias) require.NoError(t, err, "failed PRS: %v", err) rs := onlineddl.VtgateExecQuery(t, &vtParams, "show vitess_tablets", "") onlineddl.PrintQueryResult(os.Stdout, rs) @@ -650,7 +650,7 @@ func TestSchemaChange(t *testing.T) { }) t.Run("PRS shard -80", func(t *testing.T) { // migration has started and completion is postponed. We now PRS - err := clusterInstance.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", "--keyspace_shard", keyspaceName+"/-80", "--new_primary", reparentTablet.Alias) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", keyspaceName+"/-80", "--new-primary", reparentTablet.Alias) require.NoError(t, err, "failed PRS: %v", err) rs := onlineddl.VtgateExecQuery(t, &vtParams, "show vitess_tablets", "") onlineddl.PrintQueryResult(os.Stdout, rs) @@ -905,7 +905,7 @@ func testWithInitialSchema(t *testing.T) { var sqlQuery = "" //nolint for i := 0; i < totalTableCount; i++ { sqlQuery = fmt.Sprintf(createTable, fmt.Sprintf("vt_onlineddl_test_%02d", i)) - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, sqlQuery) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, sqlQuery) require.Nil(t, err) } @@ -923,8 +923,8 @@ func testOnlineDDLStatement(t *testing.T, alterStatement string, ddlStrategy str uuid = row.AsString("uuid", "") } } else { - params := cluster.VtctlClientParams{DDLStrategy: ddlStrategy, UUIDList: providedUUIDList, MigrationContext: providedMigrationContext} - output, err := clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, sqlQuery, params) + params := cluster.ApplySchemaParams{DDLStrategy: ddlStrategy, UUIDs: providedUUIDList, MigrationContext: providedMigrationContext} + output, err := clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, sqlQuery, params) if expectError == "" { assert.NoError(t, err) uuid = output diff --git a/go/test/endtoend/onlineddl/vrepl_stress/onlineddl_vrepl_mini_stress_test.go b/go/test/endtoend/onlineddl/vrepl_stress/onlineddl_vrepl_mini_stress_test.go index 9f442a39c76..84c1ea7165c 100644 --- a/go/test/endtoend/onlineddl/vrepl_stress/onlineddl_vrepl_mini_stress_test.go +++ b/go/test/endtoend/onlineddl/vrepl_stress/onlineddl_vrepl_mini_stress_test.go @@ -329,11 +329,11 @@ func TestSchemaChange(t *testing.T) { func testWithInitialSchema(t *testing.T) { for _, statement := range cleanupStatements { - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, statement) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, statement) require.Nil(t, err) } // Create the stress table - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, createStatement) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, createStatement) require.Nil(t, err) // Check if table is created @@ -349,7 +349,7 @@ func testOnlineDDLStatement(t *testing.T, alterStatement string, ddlStrategy str } } else { var err error - uuid, err = clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.VtctlClientParams{DDLStrategy: ddlStrategy}) + uuid, err = clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.ApplySchemaParams{DDLStrategy: ddlStrategy}) assert.NoError(t, err) } uuid = strings.TrimSpace(uuid) diff --git a/go/test/endtoend/onlineddl/vrepl_stress_suite/onlineddl_vrepl_stress_suite_test.go b/go/test/endtoend/onlineddl/vrepl_stress_suite/onlineddl_vrepl_stress_suite_test.go index 2d9caaa6703..0db25088bd0 100644 --- a/go/test/endtoend/onlineddl/vrepl_stress_suite/onlineddl_vrepl_stress_suite_test.go +++ b/go/test/endtoend/onlineddl/vrepl_stress_suite/onlineddl_vrepl_stress_suite_test.go @@ -553,10 +553,10 @@ func TestSchemaChange(t *testing.T) { func testWithInitialSchema(t *testing.T) { // Create the stress table for _, statement := range cleanupStatements { - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, statement) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, statement) require.Nil(t, err) } - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, createStatement) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, createStatement) require.Nil(t, err) // Check if table is created @@ -572,7 +572,7 @@ func testOnlineDDLStatement(t *testing.T, alterStatement string, ddlStrategy str } } else { var err error - uuid, err = clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.VtctlClientParams{DDLStrategy: ddlStrategy}) + uuid, err = clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.ApplySchemaParams{DDLStrategy: ddlStrategy}) assert.NoError(t, err) } uuid = strings.TrimSpace(uuid) diff --git a/go/test/endtoend/onlineddl/vtctlutil.go b/go/test/endtoend/onlineddl/vtctlutil.go index 19a6ff79604..52a832f0e1f 100644 --- a/go/test/endtoend/onlineddl/vtctlutil.go +++ b/go/test/endtoend/onlineddl/vtctlutil.go @@ -25,9 +25,9 @@ import ( ) // CheckCancelAllMigrations cancels all pending migrations. There is no validation for affected migrations. -func CheckCancelAllMigrationsViaVtctl(t *testing.T, vtctlclient *cluster.VtctlClientProcess, keyspace string) { +func CheckCancelAllMigrationsViaVtctld(t *testing.T, vtctldclient *cluster.VtctldClientProcess, keyspace string) { cancelQuery := "alter vitess_migration cancel all" - _, err := vtctlclient.ApplySchemaWithOutput(keyspace, cancelQuery, cluster.VtctlClientParams{}) + _, err := vtctldclient.ApplySchemaWithOutput(keyspace, cancelQuery, cluster.ApplySchemaParams{}) assert.NoError(t, err) } diff --git a/go/test/endtoend/recovery/pitr/shardedpitr_test.go b/go/test/endtoend/recovery/pitr/shardedpitr_test.go index 7f70a926be3..0aed6573337 100644 --- a/go/test/endtoend/recovery/pitr/shardedpitr_test.go +++ b/go/test/endtoend/recovery/pitr/shardedpitr_test.go @@ -141,7 +141,7 @@ func TestPITRRecovery(t *testing.T) { cluster.VerifyRowsInTabletForTable(t, replica1, keyspaceName, 2, "product") // backup the replica - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) require.NoError(t, err) // check that the backup shows up in the listing @@ -181,10 +181,10 @@ func TestPITRRecovery(t *testing.T) { cluster.VerifyRowsInTabletForTable(t, shard1Replica1, keyspaceName, 4, "product") // take the backup (to simulate the regular backup) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Backup", shard0Replica1.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Backup", shard0Replica1.Alias) require.NoError(t, err) // take the backup (to simulate the regular backup) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Backup", shard1Replica1.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Backup", shard1Replica1.Alias) require.NoError(t, err) backups, err := clusterInstance.ListBackups(keyspaceName + "/-80") @@ -295,10 +295,10 @@ func TestPITRRecovery(t *testing.T) { } func performResharding(t *testing.T) { - err := clusterInstance.VtctlclientProcess.ApplyVSchema(keyspaceName, vSchema) + err := clusterInstance.VtctldClientProcess.ApplyVSchema(keyspaceName, vSchema) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "--", "--source_shards=0", "--target_shards=-80,80-", "Create", "ks.reshardWorkflow") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "create", "--source-shards=0", "--target-shards=-80,80-", "--target-keyspace", "ks", "--workflow", "reshardWorkflow") require.NoError(t, err) waitTimeout := 30 * time.Second @@ -307,32 +307,32 @@ func performResharding(t *testing.T) { waitForNoWorkflowLag(t, clusterInstance, "ks.reshardWorkflow") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "--", "--tablet_types=rdonly", "SwitchTraffic", "ks.reshardWorkflow") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "SwitchTraffic", "--tablet-types=rdonly", "--target-keyspace", "ks", "--workflow", "reshardWorkflow") require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "--", "--tablet_types=replica", "SwitchTraffic", "ks.reshardWorkflow") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "SwitchTraffic", "--tablet-types=replica", "--target-keyspace", "ks", "--workflow", "reshardWorkflow") require.NoError(t, err) // then serve primary from the split shards - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "--", "--tablet_types=primary", "SwitchTraffic", "ks.reshardWorkflow") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "SwitchTraffic", "--tablet-types=primary", "--target-keyspace", "ks", "--workflow", "reshardWorkflow") require.NoError(t, err) // remove the original tablets in the original shard removeTablets(t, []*cluster.Vttablet{primary, replica1, replica2}) for _, tablet := range []*cluster.Vttablet{replica1, replica2} { - err = clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", tablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", tablet.Alias) require.NoError(t, err) } - err = clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", "--", "--allow_primary", primary.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", "--allow-primary", primary.Alias) require.NoError(t, err) // rebuild the serving graph, all mentions of the old shards should be gone - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", "ks") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", "ks") require.NoError(t, err) // delete the original shard - err = clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteShard", "ks/0") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteShards", "ks/0") require.NoError(t, err) // Restart vtgate process @@ -460,13 +460,13 @@ func initializeCluster(t *testing.T) { } } - err = clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shard.Name, cell, primary.TabletUID) + err = clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shard.Name, cell, primary.TabletUID) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shard0.Name, cell, shard0Primary.TabletUID) + err = clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shard0.Name, cell, shard0Primary.TabletUID) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shard1.Name, cell, shard1Primary.TabletUID) + err = clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shard1.Name, cell, shard1Primary.TabletUID) require.NoError(t, err) err = clusterInstance.StartVTOrc(keyspaceName) @@ -497,9 +497,9 @@ func insertRow(t *testing.T, id int, productName string, isSlow bool) { } func createRestoreKeyspace(t *testing.T, timeToRecover, restoreKeyspaceName string) { - output, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("CreateKeyspace", "--", - "--keyspace_type=SNAPSHOT", "--base_keyspace="+keyspaceName, - "--snapshot_time", timeToRecover, restoreKeyspaceName) + output, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("CreateKeyspace", + "--type=SNAPSHOT", "--base-keyspace="+keyspaceName, + "--snapshot-timestamp", timeToRecover, restoreKeyspaceName) log.Info(output) require.NoError(t, err) } diff --git a/go/test/endtoend/recovery/unshardedrecovery/recovery.go b/go/test/endtoend/recovery/unshardedrecovery/recovery.go index 8966e66ed47..1ebb7c2647f 100644 --- a/go/test/endtoend/recovery/unshardedrecovery/recovery.go +++ b/go/test/endtoend/recovery/unshardedrecovery/recovery.go @@ -164,7 +164,7 @@ func TestMainImpl(m *testing.M) { if err != nil { return 1, err } - if err := localCluster.VtctlclientProcess.InitializeShard(keyspaceName, shard.Name, cell, primary.TabletUID); err != nil { + if err := localCluster.VtctldClientProcess.InitializeShard(keyspaceName, shard.Name, cell, primary.TabletUID); err != nil { return 1, err } if err := localCluster.StartVTOrc(keyspaceName); err != nil { @@ -206,17 +206,17 @@ func TestRecoveryImpl(t *testing.T) { verifyInitialReplication(t) // take first backup of value = test1 - err := localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err := localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) assert.NoError(t, err) backups := listBackups(t) require.Equal(t, len(backups), 1) assert.Contains(t, backups[0], replica1.Alias) - err = localCluster.VtctlclientProcess.ApplyVSchema(keyspaceName, vSchema) + err = localCluster.VtctldClientProcess.ApplyVSchema(keyspaceName, vSchema) assert.NoError(t, err) - output, err := localCluster.VtctlclientProcess.ExecuteCommandWithOutput("GetVSchema", keyspaceName) + output, err := localCluster.VtctldClientProcess.ExecuteCommandWithOutput("GetVSchema", keyspaceName) assert.NoError(t, err) assert.Contains(t, output, "vt_insert_test") @@ -224,12 +224,12 @@ func TestRecoveryImpl(t *testing.T) { restoreTime := time.Now().UTC() recovery.RestoreTablet(t, localCluster, replica2, recoveryKS1, "0", keyspaceName, commonTabletArg, restoreTime) - output, err = localCluster.VtctlclientProcess.ExecuteCommandWithOutput("GetSrvVSchema", cell) + output, err = localCluster.VtctldClientProcess.ExecuteCommandWithOutput("GetSrvVSchema", cell) assert.NoError(t, err) assert.Contains(t, output, keyspaceName) assert.Contains(t, output, recoveryKS1) - output, err = localCluster.VtctlclientProcess.ExecuteCommandWithOutput("GetVSchema", recoveryKS1) + output, err = localCluster.VtctldClientProcess.ExecuteCommandWithOutput("GetVSchema", recoveryKS1) assert.NoError(t, err) assert.Contains(t, output, "vt_insert_test") @@ -277,13 +277,13 @@ func TestRecoveryImpl(t *testing.T) { } // take second backup of value = msgx1 - err = localCluster.VtctlclientProcess.ExecuteCommand("Backup", replica1.Alias) + err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", replica1.Alias) assert.NoError(t, err) // restore to first backup recovery.RestoreTablet(t, localCluster, replica3, recoveryKS2, "0", keyspaceName, commonTabletArg, restoreTime) - output, err = localCluster.VtctlclientProcess.ExecuteCommandWithOutput("GetVSchema", recoveryKS2) + output, err = localCluster.VtctldClientProcess.ExecuteCommandWithOutput("GetVSchema", recoveryKS2) assert.NoError(t, err) assert.Contains(t, output, "vt_insert_test") diff --git a/go/test/endtoend/reparent/emergencyreparent/ers_test.go b/go/test/endtoend/reparent/emergencyreparent/ers_test.go index fbd4770e15e..f0cf4f2cd6a 100644 --- a/go/test/endtoend/reparent/emergencyreparent/ers_test.go +++ b/go/test/endtoend/reparent/emergencyreparent/ers_test.go @@ -233,10 +233,10 @@ func TestERSPromoteRdonly(t *testing.T) { tablets := clusterInstance.Keyspaces[0].Shards[0].Vttablets var err error - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", tablets[2].Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", tablets[2].Alias, "rdonly") require.NoError(t, err) utils.ConfirmReplication(t, tablets[0], tablets[1:]) @@ -248,7 +248,7 @@ func TestERSPromoteRdonly(t *testing.T) { out, err := utils.ErsIgnoreTablet(clusterInstance, nil, "30s", "30s", []*cluster.Vttablet{tablets[3]}, false) require.NotNil(t, err, out) - out, err = clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetShard", utils.KeyspaceShard) + out, err = clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("GetShard", utils.KeyspaceShard) require.NoError(t, err) require.Contains(t, out, `"uid": 101`, "the primary should still be 101 in the shard info") } @@ -288,16 +288,16 @@ func TestPullFromRdonly(t *testing.T) { // make tablets[1] a rdonly tablet. // rename tablet so that the test is not confusing rdonly := tablets[1] - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonly.Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonly.Alias, "rdonly") require.NoError(t, err) // confirm that all the tablets can replicate successfully right now utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{rdonly, tablets[2], tablets[3]}) // stop replication on the other two tablets - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", tablets[2].Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", tablets[2].Alias) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", tablets[3].Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", tablets[3].Alias) require.NoError(t, err) // stop semi-sync on the primary so that any transaction now added does not require an ack @@ -311,9 +311,9 @@ func TestPullFromRdonly(t *testing.T) { utils.StopTablet(t, tablets[0], true) // start the replication back on the two tablets - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", tablets[2].Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", tablets[2].Alias) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", tablets[3].Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", tablets[3].Alias) require.NoError(t, err) // check that tablets[2] and tablets[3] still only has 1 value @@ -349,12 +349,12 @@ func TestNoReplicationStatusAndIOThreadStopped(t *testing.T) { tablets := clusterInstance.Keyspaces[0].Shards[0].Vttablets utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{tablets[1], tablets[2], tablets[3]}) - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ExecuteFetchAsDba", tablets[1].Alias, `STOP SLAVE`) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ExecuteFetchAsDBA", tablets[1].Alias, `STOP SLAVE`) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ExecuteFetchAsDba", tablets[1].Alias, `RESET SLAVE ALL`) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ExecuteFetchAsDBA", tablets[1].Alias, `RESET SLAVE ALL`) require.NoError(t, err) // - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ExecuteFetchAsDba", tablets[3].Alias, `STOP SLAVE IO_THREAD;`) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ExecuteFetchAsDBA", tablets[3].Alias, `STOP SLAVE IO_THREAD;`) require.NoError(t, err) // Run an additional command in the current primary which will only be acked by tablets[2] and be in its relay log. insertedVal := utils.ConfirmReplication(t, tablets[0], nil) @@ -450,7 +450,7 @@ func TestRecoverWithMultipleFailures(t *testing.T) { utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{tablets[1], tablets[2], tablets[3]}) // make tablets[1] a rdonly tablet. - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") require.NoError(t, err) // Confirm that replication is still working as intended @@ -478,7 +478,7 @@ func TestERSFailFast(t *testing.T) { utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{tablets[1], tablets[2], tablets[3]}) // make tablets[1] a rdonly tablet. - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") require.NoError(t, err) // Confirm that replication is still working as intended @@ -517,9 +517,9 @@ func TestReplicationStopped(t *testing.T) { tablets := clusterInstance.Keyspaces[0].Shards[0].Vttablets utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{tablets[1], tablets[2], tablets[3]}) - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ExecuteFetchAsDba", tablets[1].Alias, `STOP SLAVE SQL_THREAD;`) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ExecuteFetchAsDBA", tablets[1].Alias, `STOP SLAVE SQL_THREAD;`) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ExecuteFetchAsDba", tablets[2].Alias, `STOP SLAVE;`) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ExecuteFetchAsDBA", tablets[2].Alias, `STOP SLAVE;`) require.NoError(t, err) // Run an additional command in the current primary which will only be acked by tablets[3] and be in its relay log. insertedVal := utils.ConfirmReplication(t, tablets[0], nil) @@ -528,7 +528,7 @@ func TestReplicationStopped(t *testing.T) { require.Error(t, err, "ERS should fail with 2 replicas having replication stopped") // Start replication back on tablet[1] - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ExecuteFetchAsDba", tablets[1].Alias, `START SLAVE;`) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ExecuteFetchAsDBA", tablets[1].Alias, `START SLAVE;`) require.NoError(t, err) // Failover to tablets[3] again. This time it should succeed out, err := utils.Ers(clusterInstance, tablets[3], "60s", "30s") From f1a95e1cb6f5c5bf721a8f8cab0ae56865733661 Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Tue, 20 Feb 2024 07:48:40 +0200 Subject: [PATCH 36/79] Enable 'heartbeat_on_demand_duration' in local/examples (#15204) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- examples/common/scripts/vttablet-up.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/common/scripts/vttablet-up.sh b/examples/common/scripts/vttablet-up.sh index 764b7c1f426..daa40aee894 100755 --- a/examples/common/scripts/vttablet-up.sh +++ b/examples/common/scripts/vttablet-up.sh @@ -53,6 +53,7 @@ vttablet \ --grpc_port $grpc_port \ --service_map 'grpc-queryservice,grpc-tabletmanager,grpc-updatestream' \ --pid_file $VTDATAROOT/$tablet_dir/vttablet.pid \ + --heartbeat_on_demand_duration=5s \ > $VTDATAROOT/$tablet_dir/vttablet.out 2>&1 & # Block waiting for the tablet to be listening From c1a176cb008e6530ae773e5b1a020c451a3cbe59 Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Tue, 20 Feb 2024 19:40:38 +0530 Subject: [PATCH 37/79] Fix Go routine leaks in streaming calls (#15293) Signed-off-by: Manan Gupta --- go/vt/vttablet/grpctabletconn/conn.go | 25 +++++ go/vt/vttablet/grpctabletconn/conn_test.go | 116 +++++++++++++++++++++ 2 files changed, 141 insertions(+) diff --git a/go/vt/vttablet/grpctabletconn/conn.go b/go/vt/vttablet/grpctabletconn/conn.go index 775118aee73..8bb8a466b21 100644 --- a/go/vt/vttablet/grpctabletconn/conn.go +++ b/go/vt/vttablet/grpctabletconn/conn.go @@ -473,6 +473,10 @@ func (conn *gRPCQueryClient) BeginExecute(ctx context.Context, target *querypb.T // BeginStreamExecute starts a transaction and runs an Execute. func (conn *gRPCQueryClient) BeginStreamExecute(ctx context.Context, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state queryservice.TransactionState, err error) { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() + conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -650,6 +654,9 @@ func (conn *gRPCQueryClient) StreamHealth(ctx context.Context, callback func(*qu // VStream starts a VReplication stream. func (conn *gRPCQueryClient) VStream(ctx context.Context, request *binlogdatapb.VStreamRequest, send func([]*binlogdatapb.VEvent) error) error { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() stream, err := func() (queryservicepb.Query_VStreamClient, error) { conn.mu.RLock() defer conn.mu.RUnlock() @@ -695,6 +702,9 @@ func (conn *gRPCQueryClient) VStream(ctx context.Context, request *binlogdatapb. // VStreamRows streams rows of a query from the specified starting point. func (conn *gRPCQueryClient) VStreamRows(ctx context.Context, request *binlogdatapb.VStreamRowsRequest, send func(*binlogdatapb.VStreamRowsResponse) error) error { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() stream, err := func() (queryservicepb.Query_VStreamRowsClient, error) { conn.mu.RLock() defer conn.mu.RUnlock() @@ -737,6 +747,9 @@ func (conn *gRPCQueryClient) VStreamRows(ctx context.Context, request *binlogdat // VStreamTables streams rows of a query from the specified starting point. func (conn *gRPCQueryClient) VStreamTables(ctx context.Context, request *binlogdatapb.VStreamTablesRequest, send func(*binlogdatapb.VStreamTablesResponse) error) error { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() stream, err := func() (queryservicepb.Query_VStreamTablesClient, error) { conn.mu.RLock() defer conn.mu.RUnlock() @@ -777,6 +790,9 @@ func (conn *gRPCQueryClient) VStreamTables(ctx context.Context, request *binlogd // VStreamResults streams rows of a query from the specified starting point. func (conn *gRPCQueryClient) VStreamResults(ctx context.Context, target *querypb.Target, query string, send func(*binlogdatapb.VStreamResultsResponse) error) error { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() stream, err := func() (queryservicepb.Query_VStreamResultsClient, error) { conn.mu.RLock() defer conn.mu.RUnlock() @@ -856,6 +872,9 @@ func (conn *gRPCQueryClient) ReserveBeginExecute(ctx context.Context, target *qu // ReserveBeginStreamExecute implements the queryservice interface func (conn *gRPCQueryClient) ReserveBeginStreamExecute(ctx context.Context, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state queryservice.ReservedTransactionState, err error) { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -967,6 +986,9 @@ func (conn *gRPCQueryClient) ReserveExecute(ctx context.Context, target *querypb // ReserveStreamExecute implements the queryservice interface func (conn *gRPCQueryClient) ReserveStreamExecute(ctx context.Context, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state queryservice.ReservedState, err error) { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -1060,6 +1082,9 @@ func (conn *gRPCQueryClient) Release(ctx context.Context, target *querypb.Target // GetSchema implements the queryservice interface func (conn *gRPCQueryClient) GetSchema(ctx context.Context, target *querypb.Target, tableType querypb.SchemaTableType, tableNames []string, callback func(schemaRes *querypb.GetSchemaResponse) error) error { + // Please see comments in StreamExecute to see how this works. + ctx, cancel := context.WithCancel(ctx) + defer cancel() conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { diff --git a/go/vt/vttablet/grpctabletconn/conn_test.go b/go/vt/vttablet/grpctabletconn/conn_test.go index fb182bfe2e4..70e30e337bc 100644 --- a/go/vt/vttablet/grpctabletconn/conn_test.go +++ b/go/vt/vttablet/grpctabletconn/conn_test.go @@ -17,13 +17,21 @@ limitations under the License. package grpctabletconn import ( + "context" + "fmt" "io" "net" "os" + "sync" "testing" + "github.com/stretchr/testify/require" "google.golang.org/grpc" + "vitess.io/vitess/go/sqltypes" + binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" + querypb "vitess.io/vitess/go/vt/proto/query" + queryservicepb "vitess.io/vitess/go/vt/proto/queryservice" "vitess.io/vitess/go/vt/servenv" "vitess.io/vitess/go/vt/vttablet/grpcqueryservice" "vitess.io/vitess/go/vt/vttablet/tabletconntest" @@ -113,3 +121,111 @@ func TestGRPCTabletAuthConn(t *testing.T) { }, }, service, f) } + +// mockQueryClient is a mock query client that returns an error from Streaming calls, +// but only after storing the context that was passed to the RPC. +type mockQueryClient struct { + lastCallCtx context.Context + queryservicepb.QueryClient +} + +func (m *mockQueryClient) StreamExecute(ctx context.Context, in *querypb.StreamExecuteRequest, opts ...grpc.CallOption) (queryservicepb.Query_StreamExecuteClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) BeginStreamExecute(ctx context.Context, in *querypb.BeginStreamExecuteRequest, opts ...grpc.CallOption) (queryservicepb.Query_BeginStreamExecuteClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) ReserveStreamExecute(ctx context.Context, in *querypb.ReserveStreamExecuteRequest, opts ...grpc.CallOption) (queryservicepb.Query_ReserveStreamExecuteClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) ReserveBeginStreamExecute(ctx context.Context, in *querypb.ReserveBeginStreamExecuteRequest, opts ...grpc.CallOption) (queryservicepb.Query_ReserveBeginStreamExecuteClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) VStream(ctx context.Context, in *binlogdatapb.VStreamRequest, opts ...grpc.CallOption) (queryservicepb.Query_VStreamClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) VStreamRows(ctx context.Context, in *binlogdatapb.VStreamRowsRequest, opts ...grpc.CallOption) (queryservicepb.Query_VStreamRowsClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) VStreamTables(ctx context.Context, in *binlogdatapb.VStreamTablesRequest, opts ...grpc.CallOption) (queryservicepb.Query_VStreamTablesClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) VStreamResults(ctx context.Context, in *binlogdatapb.VStreamResultsRequest, opts ...grpc.CallOption) (queryservicepb.Query_VStreamResultsClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +func (m *mockQueryClient) GetSchema(ctx context.Context, in *querypb.GetSchemaRequest, opts ...grpc.CallOption) (queryservicepb.Query_GetSchemaClient, error) { + m.lastCallCtx = ctx + return nil, fmt.Errorf("A general error") +} + +var _ queryservicepb.QueryClient = (*mockQueryClient)(nil) + +// TestGoRoutineLeakPrevention tests that after all the RPCs that stream queries, we end up closing the context that was passed to it, to prevent go routines from being leaked. +func TestGoRoutineLeakPrevention(t *testing.T) { + mqc := &mockQueryClient{} + qc := &gRPCQueryClient{ + mu: sync.RWMutex{}, + cc: &grpc.ClientConn{}, + c: mqc, + } + _ = qc.StreamExecute(context.Background(), nil, "", nil, 0, 0, nil, func(result *sqltypes.Result) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _, _ = qc.BeginStreamExecute(context.Background(), nil, nil, "", nil, 0, nil, func(result *sqltypes.Result) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _, _ = qc.ReserveBeginStreamExecute(context.Background(), nil, nil, nil, "", nil, nil, func(result *sqltypes.Result) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _, _ = qc.ReserveStreamExecute(context.Background(), nil, nil, "", nil, 0, nil, func(result *sqltypes.Result) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _ = qc.VStream(context.Background(), &binlogdatapb.VStreamRequest{}, func(events []*binlogdatapb.VEvent) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _ = qc.VStreamRows(context.Background(), &binlogdatapb.VStreamRowsRequest{}, func(response *binlogdatapb.VStreamRowsResponse) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _ = qc.VStreamResults(context.Background(), nil, "", func(response *binlogdatapb.VStreamResultsResponse) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _ = qc.VStreamTables(context.Background(), &binlogdatapb.VStreamTablesRequest{}, func(response *binlogdatapb.VStreamTablesResponse) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) + + _ = qc.GetSchema(context.Background(), nil, querypb.SchemaTableType_TABLES, nil, func(schemaRes *querypb.GetSchemaResponse) error { + return nil + }) + require.Error(t, mqc.lastCallCtx.Err()) +} From b3a2c9998789da5b5fa8016e179cf3956cc18fc5 Mon Sep 17 00:00:00 2001 From: Arthur Schreiber Date: Tue, 20 Feb 2024 19:55:43 +0100 Subject: [PATCH 38/79] [vtcombo] Expose `--tablet_types_to_wait` flag (#14951) Signed-off-by: Arthur Schreiber --- go/cmd/vtcombo/cli/main.go | 31 +++++++++++++++++++++++-------- go/flags/endtoend/vtcombo.txt | 1 + 2 files changed, 24 insertions(+), 8 deletions(-) diff --git a/go/cmd/vtcombo/cli/main.go b/go/cmd/vtcombo/cli/main.go index 7b9143f1384..a86b98cc250 100644 --- a/go/cmd/vtcombo/cli/main.go +++ b/go/cmd/vtcombo/cli/main.go @@ -40,6 +40,7 @@ import ( "vitess.io/vitess/go/vt/srvtopo" "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/topo/memorytopo" + "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/topotools" "vitess.io/vitess/go/vt/vtcombo" "vitess.io/vitess/go/vt/vtctld" @@ -77,9 +78,10 @@ In particular, it contains: plannerName string vschemaPersistenceDir string - tpb vttestpb.VTTestTopology - ts *topo.Server - resilientServer *srvtopo.ResilientServer + tpb vttestpb.VTTestTopology + ts *topo.Server + resilientServer *srvtopo.ResilientServer + tabletTypesToWait []topodatapb.TabletType env *vtenv.Environment ) @@ -114,6 +116,8 @@ func init() { Main.Flags().Var(vttest.TextTopoData(&tpb), "proto_topo", "vttest proto definition of the topology, encoded in compact text format. See vttest.proto for more information.") Main.Flags().Var(vttest.JSONTopoData(&tpb), "json_topo", "vttest proto definition of the topology, encoded in json format. See vttest.proto for more information.") + Main.Flags().Var((*topoproto.TabletTypeListFlag)(&tabletTypesToWait), "tablet_types_to_wait", "Wait till connected for specified tablet types during Gateway initialization. Should be provided as a comma-separated set of tablet types.") + // We're going to force the value later, so don't even bother letting the // user know about this flag. Main.Flags().MarkHidden("tablet_protocol") @@ -294,11 +298,22 @@ func run(cmd *cobra.Command, args []string) (err error) { // vtgate configuration and init resilientServer = srvtopo.NewResilientServer(context.Background(), ts, "ResilientSrvTopoServer") - tabletTypesToWait := []topodatapb.TabletType{ - topodatapb.TabletType_PRIMARY, - topodatapb.TabletType_REPLICA, - topodatapb.TabletType_RDONLY, + + tabletTypes := make([]topodatapb.TabletType, 0, 1) + if len(tabletTypesToWait) != 0 { + for _, tt := range tabletTypesToWait { + if topoproto.IsServingType(tt) { + tabletTypes = append(tabletTypes, tt) + } + } + + if len(tabletTypes) == 0 { + log.Exitf("tablet_types_to_wait should contain at least one serving tablet type") + } + } else { + tabletTypes = append(tabletTypes, topodatapb.TabletType_PRIMARY, topodatapb.TabletType_REPLICA, topodatapb.TabletType_RDONLY) } + plannerVersion, _ := plancontext.PlannerNameToVersion(plannerName) vtgate.QueryLogHandler = "/debug/vtgate/querylog" @@ -306,7 +321,7 @@ func run(cmd *cobra.Command, args []string) (err error) { vtgate.QueryzHandler = "/debug/vtgate/queryz" // pass nil for healthcheck, it will get created - vtg := vtgate.Init(context.Background(), env, nil, resilientServer, tpb.Cells[0], tabletTypesToWait, plannerVersion) + vtg := vtgate.Init(context.Background(), env, nil, resilientServer, tpb.Cells[0], tabletTypes, plannerVersion) // vtctld configuration and init err = vtctld.InitVtctld(env, ts) diff --git a/go/flags/endtoend/vtcombo.txt b/go/flags/endtoend/vtcombo.txt index 19bef034b10..59dd8969880 100644 --- a/go/flags/endtoend/vtcombo.txt +++ b/go/flags/endtoend/vtcombo.txt @@ -353,6 +353,7 @@ Flags: --tablet_manager_protocol string Protocol to use to make tabletmanager RPCs to vttablets. (default "grpc") --tablet_refresh_interval duration Tablet refresh interval. (default 1m0s) --tablet_refresh_known_tablets Whether to reload the tablet's address/port map from topo in case they change. (default true) + --tablet_types_to_wait strings Wait till connected for specified tablet types during Gateway initialization. Should be provided as a comma-separated set of tablet types. --tablet_url_template string Format string describing debug tablet url formatting. See getTabletDebugURL() for how to customize this. (default "http://{{ "{{.GetTabletHostPort}}" }}") --throttle_tablet_types string Comma separated VTTablet types to be considered by the throttler. default: 'replica'. example: 'replica,rdonly'. 'replica' always implicitly included (default "replica") --topo_consul_lock_delay duration LockDelay for consul session. (default 15s) From 999f1c1428be38c907f953ccde09d2de4c977a11 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Tue, 20 Feb 2024 14:02:20 -0500 Subject: [PATCH 39/79] VReplication: Make Target Sequence Initialization More Robust (#15289) Signed-off-by: Matt Lord --- go/sqltypes/testing.go | 2 +- go/vt/vtctl/workflow/server.go | 25 ++++++------ go/vt/vtctl/workflow/traffic_switcher.go | 17 ++++++--- go/vt/wrangler/traffic_switcher.go | 42 ++++++++++++--------- go/vt/wrangler/traffic_switcher_env_test.go | 4 +- go/vt/wrangler/traffic_switcher_test.go | 2 +- 6 files changed, 54 insertions(+), 38 deletions(-) diff --git a/go/sqltypes/testing.go b/go/sqltypes/testing.go index 63589ee9567..649462333c7 100644 --- a/go/sqltypes/testing.go +++ b/go/sqltypes/testing.go @@ -76,7 +76,7 @@ func MakeTestResult(fields []*querypb.Field, rows ...string) *Result { for i, row := range rows { result.Rows[i] = make([]Value, len(fields)) for j, col := range split(row) { - if col == "null" { + if strings.ToLower(col) == "null" { result.Rows[i][j] = NULL continue } diff --git a/go/vt/vtctl/workflow/server.go b/go/vt/vtctl/workflow/server.go index e298d3f64f3..5e9f3fc9300 100644 --- a/go/vt/vtctl/workflow/server.go +++ b/go/vt/vtctl/workflow/server.go @@ -3301,6 +3301,20 @@ func (s *Server) switchWrites(ctx context.Context, req *vtctldatapb.WorkflowSwit sw.cancelMigration(ctx, sm) return handleError("failed to create the reverse vreplication streams", err) } + + // Initialize any target sequences, if there are any, before allowing new writes. + if req.InitializeTargetSequences && len(sequenceMetadata) > 0 { + ts.Logger().Infof("Initializing target sequences") + // Writes are blocked so we can safely initialize the sequence tables but + // we also want to use a shorter timeout than the parent context. + // We use at most half of the overall timeout. + initSeqCtx, cancel := context.WithTimeout(ctx, timeout/2) + defer cancel() + if err := sw.initializeTargetSequences(initSeqCtx, sequenceMetadata); err != nil { + sw.cancelMigration(ctx, sm) + return handleError(fmt.Sprintf("failed to initialize the sequences used in the %s keyspace", ts.TargetKeyspaceName()), err) + } + } } else { if cancel { return handleError("invalid cancel", vterrors.Errorf(vtrpcpb.Code_FAILED_PRECONDITION, "traffic switching has reached the point of no return, cannot cancel")) @@ -3317,17 +3331,6 @@ func (s *Server) switchWrites(ctx context.Context, req *vtctldatapb.WorkflowSwit if err := sw.createJournals(ctx, sourceWorkflows); err != nil { return handleError("failed to create the journal", err) } - // Initialize any target sequences, if there are any, before allowing new writes. - if req.InitializeTargetSequences && len(sequenceMetadata) > 0 { - // Writes are blocked so we can safely initialize the sequence tables but - // we also want to use a shorter timeout than the parent context. - // We use up at most half of the overall timeout. - initSeqCtx, cancel := context.WithTimeout(ctx, timeout/2) - defer cancel() - if err := sw.initializeTargetSequences(initSeqCtx, sequenceMetadata); err != nil { - return handleError(fmt.Sprintf("failed to initialize the sequences used in the %s keyspace", ts.TargetKeyspaceName()), err) - } - } if err := sw.allowTargetWrites(ctx); err != nil { return handleError(fmt.Sprintf("failed to allow writes in the %s keyspace", ts.TargetKeyspaceName()), err) } diff --git a/go/vt/vtctl/workflow/traffic_switcher.go b/go/vt/vtctl/workflow/traffic_switcher.go index 2a593cfb1db..c8551c5ff73 100644 --- a/go/vt/vtctl/workflow/traffic_switcher.go +++ b/go/vt/vtctl/workflow/traffic_switcher.go @@ -38,6 +38,7 @@ import ( "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/topo" + "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/topotools" "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vtgate/vindexes" @@ -1432,13 +1433,17 @@ func (ts *trafficSwitcher) initializeTargetSequences(ctx context.Context, sequen MaxRows: 1, }) if terr != nil || len(qr.Rows) != 1 { - return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s in order to initialize the backing sequence table: %v", - ts.targetKeyspace, sequenceMetadata.usingTableName, terr) + return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s on tablet %s in order to initialize the backing sequence table: %v", + ts.targetKeyspace, sequenceMetadata.usingTableName, topoproto.TabletAliasString(primary.Alias), terr) } - maxID, terr := sqltypes.Proto3ToResult(qr).Rows[0][0].ToInt64() - if terr != nil { - return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s in order to initialize the backing sequence table: %v", - ts.targetKeyspace, sequenceMetadata.usingTableName, terr) + rawVal := sqltypes.Proto3ToResult(qr).Rows[0][0] + maxID := int64(0) + if !rawVal.IsNull() { // If it's NULL then there are no rows and 0 remains the max + maxID, terr = rawVal.ToInt64() + if terr != nil { + return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s on tablet %s in order to initialize the backing sequence table: %v", + ts.targetKeyspace, sequenceMetadata.usingTableName, topoproto.TabletAliasString(primary.Alias), terr) + } } srMu.Lock() defer srMu.Unlock() diff --git a/go/vt/wrangler/traffic_switcher.go b/go/vt/wrangler/traffic_switcher.go index 9e7e133cd1f..a6b3587c3a1 100644 --- a/go/vt/wrangler/traffic_switcher.go +++ b/go/vt/wrangler/traffic_switcher.go @@ -40,6 +40,7 @@ import ( "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/topo" + "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/topotools" "vitess.io/vitess/go/vt/vtctl/workflow" "vitess.io/vitess/go/vt/vterrors" @@ -619,6 +620,20 @@ func (wr *Wrangler) SwitchWrites(ctx context.Context, targetKeyspace, workflowNa sw.cancelMigration(ctx, sm) return handleError("failed to create the reverse vreplication streams", err) } + + // Initialize any target sequences, if there are any, before allowing new writes. + if initializeTargetSequences && len(sequenceMetadata) > 0 { + ts.Logger().Infof("Initializing target sequences") + // Writes are blocked so we can safely initialize the sequence tables but + // we also want to use a shorter timeout than the parent context. + // We use at most half of the overall timeout. + initSeqCtx, cancel := context.WithTimeout(ctx, timeout/2) + defer cancel() + if err := sw.initializeTargetSequences(initSeqCtx, sequenceMetadata); err != nil { + sw.cancelMigration(ctx, sm) + return handleError(fmt.Sprintf("failed to initialize the sequences used in the %s keyspace", ts.TargetKeyspaceName()), err) + } + } } else { if cancel { return handleError("invalid cancel", fmt.Errorf("traffic switching has reached the point of no return, cannot cancel")) @@ -635,17 +650,6 @@ func (wr *Wrangler) SwitchWrites(ctx context.Context, targetKeyspace, workflowNa if err := sw.createJournals(ctx, sourceWorkflows); err != nil { return handleError("failed to create the journal", err) } - // Initialize any target sequences, if there are any, before allowing new writes. - if initializeTargetSequences && len(sequenceMetadata) > 0 { - // Writes are blocked so we can safely initialize the sequence tables but - // we also want to use a shorter timeout than the parent context. - // We use up at most half of the overall timeout. - initSeqCtx, cancel := context.WithTimeout(ctx, timeout/2) - defer cancel() - if err := sw.initializeTargetSequences(initSeqCtx, sequenceMetadata); err != nil { - return handleError(fmt.Sprintf("failed to initialize the sequences used in the %s keyspace", ts.TargetKeyspaceName()), err) - } - } if err := sw.allowTargetWrites(ctx); err != nil { return handleError(fmt.Sprintf("failed to allow writes in the %s keyspace", ts.TargetKeyspaceName()), err) } @@ -2197,13 +2201,17 @@ func (ts *trafficSwitcher) initializeTargetSequences(ctx context.Context, sequen ) qr, terr := ts.wr.ExecuteFetchAsApp(ictx, primary.GetAlias(), true, query.Query, 1) if terr != nil || len(qr.Rows) != 1 { - return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s in order to initialize the backing sequence table: %v", - ts.targetKeyspace, sequenceMetadata.usingTableName, terr) + return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s on tablet %s in order to initialize the backing sequence table: %v", + ts.targetKeyspace, sequenceMetadata.usingTableName, topoproto.TabletAliasString(primary.Alias), terr) } - maxID, terr := sqltypes.Proto3ToResult(qr).Rows[0][0].ToInt64() - if terr != nil { - return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s in order to initialize the backing sequence table: %v", - ts.targetKeyspace, sequenceMetadata.usingTableName, terr) + rawVal := sqltypes.Proto3ToResult(qr).Rows[0][0] + maxID := int64(0) + if !rawVal.IsNull() { // If it's NULL then there are no rows and 0 remains the max + maxID, terr = rawVal.ToInt64() + if terr != nil { + return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s on tablet %s in order to initialize the backing sequence table: %v", + ts.targetKeyspace, sequenceMetadata.usingTableName, topoproto.TabletAliasString(primary.Alias), terr) + } } srMu.Lock() defer srMu.Unlock() diff --git a/go/vt/wrangler/traffic_switcher_env_test.go b/go/vt/wrangler/traffic_switcher_env_test.go index 9134bb8917e..3838ded0669 100644 --- a/go/vt/wrangler/traffic_switcher_env_test.go +++ b/go/vt/wrangler/traffic_switcher_env_test.go @@ -258,7 +258,7 @@ func newTestTableMigraterCustom(ctx context.Context, t *testing.T, sourceShards, "maxval", "int64", ), - "5", + "NULL", ), ) tme.tmeDB.AddQuery(fmt.Sprintf(maxValForSequence, "ks2", "t2"), @@ -274,7 +274,7 @@ func newTestTableMigraterCustom(ctx context.Context, t *testing.T, sourceShards, // Now tell the fakesqldb used by the global keyspace tablets to expect // the sequence management related queries against the target keyspace. gfdb.AddQuery( - sqlparser.BuildParsedQuery(sqlInitSequenceTable, sqlescape.EscapeID("vt_global"), sqlescape.EscapeID("t1_seq"), 6, 6, 6).Query, + sqlparser.BuildParsedQuery(sqlInitSequenceTable, sqlescape.EscapeID("vt_global"), sqlescape.EscapeID("t1_seq"), 1, 1, 1).Query, &sqltypes.Result{RowsAffected: 0}, ) gfdb.AddQuery( diff --git a/go/vt/wrangler/traffic_switcher_test.go b/go/vt/wrangler/traffic_switcher_test.go index df1eebc013a..e1ae1ce908f 100644 --- a/go/vt/wrangler/traffic_switcher_test.go +++ b/go/vt/wrangler/traffic_switcher_test.go @@ -1011,8 +1011,8 @@ func TestTableMigrateOneToManyDryRun(t *testing.T) { "\tKeyspace ks1, Shard 0 at Position MariaDB/5-456-892", "Wait for VReplication on stopped streams to catchup for up to 1s", "Create reverse replication workflow test_reverse", - "Create journal entries on source databases", "The following sequence backing tables used by tables being moved will be initialized: t1_seq,t2_seq", + "Create journal entries on source databases", "Enable writes on keyspace ks2 tables [t1,t2]", "Switch routing from keyspace ks1 to keyspace ks2", "Routing rules for tables [t1,t2] will be updated", From 27be9166e1ace2708a158e9faf220cf156569e50 Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Wed, 21 Feb 2024 01:26:31 +0530 Subject: [PATCH 40/79] Fix some binaries to print the versions (#15306) Signed-off-by: Manan Gupta --- go/cmd/mysqlctld/cli/mysqlctld.go | 1 + go/cmd/topo2topo/cli/topo2topo.go | 1 + go/cmd/vtexplain/cli/vtexplain.go | 1 + go/cmd/vttestserver/cli/main.go | 1 + go/cmd/zkctld/cli/zkctld.go | 1 + go/flags/endtoend/zkctld.txt | 3 ++- 6 files changed, 7 insertions(+), 1 deletion(-) diff --git a/go/cmd/mysqlctld/cli/mysqlctld.go b/go/cmd/mysqlctld/cli/mysqlctld.go index 7a5ff6a5ce6..2dff7da0f7f 100644 --- a/go/cmd/mysqlctld/cli/mysqlctld.go +++ b/go/cmd/mysqlctld/cli/mysqlctld.go @@ -67,6 +67,7 @@ var ( --mysql_port=17100 \ --socket_file=/path/to/socket_file`, Args: cobra.NoArgs, + Version: servenv.AppVersion.String(), PreRunE: servenv.CobraPreRunE, RunE: run, } diff --git a/go/cmd/topo2topo/cli/topo2topo.go b/go/cmd/topo2topo/cli/topo2topo.go index 5dda62eaed1..f6f69e08eda 100644 --- a/go/cmd/topo2topo/cli/topo2topo.go +++ b/go/cmd/topo2topo/cli/topo2topo.go @@ -52,6 +52,7 @@ var ( It can also be used to compare data between two topologies.`, Args: cobra.NoArgs, PreRunE: servenv.CobraPreRunE, + Version: servenv.AppVersion.String(), RunE: run, } ) diff --git a/go/cmd/vtexplain/cli/vtexplain.go b/go/cmd/vtexplain/cli/vtexplain.go index 5c15112917e..c8671cdb532 100644 --- a/go/cmd/vtexplain/cli/vtexplain.go +++ b/go/cmd/vtexplain/cli/vtexplain.go @@ -84,6 +84,7 @@ If no keyspace name is present, VTExplain will return the following error: "```\nvtexplain -- -shards 128 --vschema-file vschema.json --schema-file schema.sql --replication-mode \"ROW\" --output-mode text --sql \"INSERT INTO users (user_id, name) VALUES(1, 'john')\"\n```\n", Args: cobra.NoArgs, PreRunE: servenv.CobraPreRunE, + Version: servenv.AppVersion.String(), RunE: run, } ) diff --git a/go/cmd/vttestserver/cli/main.go b/go/cmd/vttestserver/cli/main.go index 644796c5bca..35362aa3263 100644 --- a/go/cmd/vttestserver/cli/main.go +++ b/go/cmd/vttestserver/cli/main.go @@ -104,6 +104,7 @@ func New() (cmd *cobra.Command) { Short: "vttestserver allows users to spawn a self-contained Vitess server for local testing/CI.", Args: cobra.NoArgs, PreRunE: servenv.CobraPreRunE, + Version: servenv.AppVersion.String(), RunE: run, } diff --git a/go/cmd/zkctld/cli/zkctld.go b/go/cmd/zkctld/cli/zkctld.go index 101f1013722..5ac3520868e 100644 --- a/go/cmd/zkctld/cli/zkctld.go +++ b/go/cmd/zkctld/cli/zkctld.go @@ -41,6 +41,7 @@ var ( Use: "zkctld", Short: "zkctld is a daemon that starts or initializes ZooKeeper with Vitess-specific configuration. It will stay running as long as the underlying ZooKeeper server, and will pass along SIGTERM.", Args: cobra.NoArgs, + Version: servenv.AppVersion.String(), PersistentPreRunE: servenv.CobraPreRunE, PostRun: func(cmd *cobra.Command, args []string) { logutil.Flush() diff --git a/go/flags/endtoend/zkctld.txt b/go/flags/endtoend/zkctld.txt index d808bd7ce67..20371e9e2d7 100644 --- a/go/flags/endtoend/zkctld.txt +++ b/go/flags/endtoend/zkctld.txt @@ -4,4 +4,5 @@ Usage: zkctld [flags] Flags: - -h, --help help for zkctld + -h, --help help for zkctld + -v, --version version for zkctld From c982a0406a292a7a0ff632b79166eade9621f5f8 Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Wed, 21 Feb 2024 14:46:31 +0530 Subject: [PATCH 41/79] Add memory check for runners for VTOrc tests (#15317) Signed-off-by: Manan Gupta --- .github/workflows/cluster_endtoend_vtorc.yml | 9 +++++++++ .../workflows/cluster_endtoend_vtorc_mysql57.yml | 9 +++++++++ test/ci_workflow_gen.go | 11 +++++++++++ test/templates/cluster_endtoend_test.tpl | 13 +++++++++++++ test/templates/cluster_endtoend_test_mysql57.tpl | 13 +++++++++++++ 5 files changed, 55 insertions(+) diff --git a/.github/workflows/cluster_endtoend_vtorc.yml b/.github/workflows/cluster_endtoend_vtorc.yml index 39413d28cde..3dec9b0262d 100644 --- a/.github/workflows/cluster_endtoend_vtorc.yml +++ b/.github/workflows/cluster_endtoend_vtorc.yml @@ -43,6 +43,15 @@ jobs: draft=$(echo "$PR_DATA" | jq .draft -r) echo "is_draft=${draft}" >> $GITHUB_OUTPUT + - name: Check Memory + run: | + totalMem=$(free -g | awk 'NR==2 {print $2}') + echo "total memory $totalMem GB" + if [[ "$totalMem" -lt 15 ]]; then + echo "Less memory than required" + exit 1 + fi + - name: Check out code if: steps.skip-workflow.outputs.skip-workflow == 'false' uses: actions/checkout@v3 diff --git a/.github/workflows/cluster_endtoend_vtorc_mysql57.yml b/.github/workflows/cluster_endtoend_vtorc_mysql57.yml index c33b13a1323..dc9f3581a62 100644 --- a/.github/workflows/cluster_endtoend_vtorc_mysql57.yml +++ b/.github/workflows/cluster_endtoend_vtorc_mysql57.yml @@ -43,6 +43,15 @@ jobs: draft=$(echo "$PR_DATA" | jq .draft -r) echo "is_draft=${draft}" >> $GITHUB_OUTPUT + - name: Check Memory + run: | + totalMem=$(free -g | awk 'NR==2 {print $2}') + echo "total memory $totalMem GB" + if [[ "$totalMem" -lt 15 ]]; then + echo "Less memory than required" + exit 1 + fi + - name: Check out code if: steps.skip-workflow.outputs.skip-workflow == 'false' uses: actions/checkout@v3 diff --git a/test/ci_workflow_gen.go b/test/ci_workflow_gen.go index c60076e9766..d047d588f2a 100644 --- a/test/ci_workflow_gen.go +++ b/test/ci_workflow_gen.go @@ -137,6 +137,9 @@ var ( "vtgate_topo_consul", "tabletmanager_consul", } + clustersRequiringMemoryCheck = []string{ + "vtorc", + } clusterRequiring16CoresMachines = []string{ "onlineddl_vrepl", "onlineddl_vrepl_stress", @@ -154,6 +157,7 @@ type unitTest struct { type clusterTest struct { Name, Shard, Platform string FileName string + MemoryCheck bool MakeTools, InstallXtraBackup bool Docker bool LimitResourceUsage bool @@ -351,6 +355,13 @@ func generateClusterWorkflows(list []string, tpl string) { break } } + memoryCheckClusters := canonnizeList(clustersRequiringMemoryCheck) + for _, memCheckCluster := range memoryCheckClusters { + if memCheckCluster == cluster { + test.MemoryCheck = true + break + } + } xtraBackupClusters := canonnizeList(clustersRequiringXtraBackup) for _, xtraBackupCluster := range xtraBackupClusters { if xtraBackupCluster == cluster { diff --git a/test/templates/cluster_endtoend_test.tpl b/test/templates/cluster_endtoend_test.tpl index ef1a991c169..d75cdbe817d 100644 --- a/test/templates/cluster_endtoend_test.tpl +++ b/test/templates/cluster_endtoend_test.tpl @@ -41,6 +41,19 @@ jobs: draft=$(echo "$PR_DATA" | jq .draft -r) echo "is_draft=${draft}" >> $GITHUB_OUTPUT + {{if .MemoryCheck}} + + - name: Check Memory + run: | + totalMem=$(free -g | awk 'NR==2 {print $2}') + echo "total memory $totalMem GB" + if [[ "$totalMem" -lt 15 ]]; then + echo "Less memory than required" + exit 1 + fi + + {{end}} + - name: Check out code if: steps.skip-workflow.outputs.skip-workflow == 'false' uses: actions/checkout@v3 diff --git a/test/templates/cluster_endtoend_test_mysql57.tpl b/test/templates/cluster_endtoend_test_mysql57.tpl index 9f9e51fbc69..b4f528eeb2f 100644 --- a/test/templates/cluster_endtoend_test_mysql57.tpl +++ b/test/templates/cluster_endtoend_test_mysql57.tpl @@ -46,6 +46,19 @@ jobs: draft=$(echo "$PR_DATA" | jq .draft -r) echo "is_draft=${draft}" >> $GITHUB_OUTPUT + {{if .MemoryCheck}} + + - name: Check Memory + run: | + totalMem=$(free -g | awk 'NR==2 {print $2}') + echo "total memory $totalMem GB" + if [[ "$totalMem" -lt 15 ]]; then + echo "Less memory than required" + exit 1 + fi + + {{end}} + - name: Check out code if: steps.skip-workflow.outputs.skip-workflow == 'false' uses: actions/checkout@v3 From a9b2c18a2a5d460ef484e6542bb9b8f3fe548809 Mon Sep 17 00:00:00 2001 From: Max Englander Date: Wed, 21 Feb 2024 11:17:11 -0500 Subject: [PATCH 42/79] planner: support union statements with ctes (#15312) Signed-off-by: Max Englander --- go/vt/sqlparser/ast_format.go | 4 + go/vt/sqlparser/ast_format_fast.go | 4 + go/vt/sqlparser/parse_test.go | 3 + .../planbuilder/testdata/cte_cases.json | 103 ++++++++++++++++++ 4 files changed, 114 insertions(+) diff --git a/go/vt/sqlparser/ast_format.go b/go/vt/sqlparser/ast_format.go index 0e7ca0a8231..e90b8b6344b 100644 --- a/go/vt/sqlparser/ast_format.go +++ b/go/vt/sqlparser/ast_format.go @@ -74,6 +74,10 @@ func (node *CommentOnly) Format(buf *TrackedBuffer) { // Format formats the node. func (node *Union) Format(buf *TrackedBuffer) { + if node.With != nil { + buf.astPrintf(node, "%v", node.With) + } + if requiresParen(node.Left) { buf.astPrintf(node, "(%v)", node.Left) } else { diff --git a/go/vt/sqlparser/ast_format_fast.go b/go/vt/sqlparser/ast_format_fast.go index a7f1a3c1e93..4ebdbcf8475 100644 --- a/go/vt/sqlparser/ast_format_fast.go +++ b/go/vt/sqlparser/ast_format_fast.go @@ -86,6 +86,10 @@ func (node *CommentOnly) FormatFast(buf *TrackedBuffer) { // FormatFast formats the node. func (node *Union) FormatFast(buf *TrackedBuffer) { + if node.With != nil { + node.With.FormatFast(buf) + } + if requiresParen(node.Left) { buf.WriteByte('(') node.Left.FormatFast(buf) diff --git a/go/vt/sqlparser/parse_test.go b/go/vt/sqlparser/parse_test.go index f90ae16606e..0dce5eae5bc 100644 --- a/go/vt/sqlparser/parse_test.go +++ b/go/vt/sqlparser/parse_test.go @@ -505,6 +505,9 @@ var ( }, { input: "WITH topsales2003 AS (SELECT salesRepEmployeeNumber employeeNumber, SUM(quantityOrdered * priceEach) sales FROM orders INNER JOIN orderdetails USING (orderNumber) INNER JOIN customers USING (customerNumber) WHERE YEAR(shippedDate) = 2003 AND status = 'Shipped' GROUP BY salesRepEmployeeNumber ORDER BY sales DESC LIMIT 5)SELECT employeeNumber, firstName, lastName, sales FROM employees JOIN topsales2003 USING (employeeNumber)", output: "with topsales2003 as (select salesRepEmployeeNumber as employeeNumber, sum(quantityOrdered * priceEach) as sales from orders join orderdetails using (orderNumber) join customers using (customerNumber) where YEAR(shippedDate) = 2003 and `status` = 'Shipped' group by salesRepEmployeeNumber order by sales desc limit 5) select employeeNumber, firstName, lastName, sales from employees join topsales2003 using (employeeNumber)", + }, { + input: "WITH count_a AS (SELECT COUNT(`id`) AS `num` FROM `tbl_a`), count_b AS (SELECT COUNT(`id`) AS `num` FROM tbl_b) SELECT 'a', `num` FROM `count_a` UNION SELECT 'b', `num` FROM `count_b`", + output: "with count_a as (select count(id) as num from tbl_a) , count_b as (select count(id) as num from tbl_b) select 'a', num from count_a union select 'b', num from count_b", }, { input: "select 1 from t", }, { diff --git a/go/vt/vtgate/planbuilder/testdata/cte_cases.json b/go/vt/vtgate/planbuilder/testdata/cte_cases.json index e43b6320340..a7027f80348 100644 --- a/go/vt/vtgate/planbuilder/testdata/cte_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/cte_cases.json @@ -1863,5 +1863,108 @@ "main.unsharded" ] } + }, + { + "comment": "WITH two common expressions against an unsharded datbase and a SELECT UNION against those expressions", + "query": "WITH `count_a` AS (SELECT COUNT(`id`) AS `num` FROM `unsharded_a`), `count_b` AS (SELECT COUNT(`id`) AS `num` FROM `unsharded_b`) SELECT 'count_a' AS `tab`, `num` FROM `count_a` UNION SELECT 'count_b' AS `tab`, `num` FROM `count_b`", + "plan": { + "QueryType": "SELECT", + "Original": "WITH `count_a` AS (SELECT COUNT(`id`) AS `num` FROM `unsharded_a`), `count_b` AS (SELECT COUNT(`id`) AS `num` FROM `unsharded_b`) SELECT 'count_a' AS `tab`, `num` FROM `count_a` UNION SELECT 'count_b' AS `tab`, `num` FROM `count_b`", + "Instructions": { + "OperatorType": "Route", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "FieldQuery": "select 'count_a' as tab, num from count_a where 1 != 1 union select 'count_b' as tab, num from count_b where 1 != 1", + "Query": "with count_a as (select count(id) as num from unsharded_a) , count_b as (select count(id) as num from unsharded_b) select 'count_a' as tab, num from count_a union select 'count_b' as tab, num from count_b", + "Table": "unsharded_a, unsharded_b" + }, + "TablesUsed": [ + "main.unsharded_a", + "main.unsharded_b" + ] + } + }, + { + "comment": "WITH two common expressions against a sharded datbase and a SELECT UNION against those expressions", + "query": "WITH `count_a` AS (SELECT COUNT(`user_id`) AS `num` FROM `user_metadata`), `count_b` AS (SELECT COUNT(`user_id`) AS `num` FROM `user_extra`) SELECT 'count_a' AS `tab`, `num` FROM `count_a` UNION SELECT 'count_b' AS `tab`, `num` FROM `count_b`", + "plan": { + "QueryType": "SELECT", + "Original": "WITH `count_a` AS (SELECT COUNT(`user_id`) AS `num` FROM `user_metadata`), `count_b` AS (SELECT COUNT(`user_id`) AS `num` FROM `user_extra`) SELECT 'count_a' AS `tab`, `num` FROM `count_a` UNION SELECT 'count_b' AS `tab`, `num` FROM `count_b`", + "Instructions": { + "OperatorType": "Distinct", + "Collations": [ + "0: utf8mb4_0900_ai_ci", + "1" + ], + "Inputs": [ + { + "OperatorType": "Concatenate", + "Inputs": [ + { + "OperatorType": "Projection", + "Expressions": [ + "'count_a' as tab", + ":0 as num" + ], + "Inputs": [ + { + "OperatorType": "Aggregate", + "Variant": "Scalar", + "Aggregates": "sum_count(0) AS num", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select count(user_id) as num from user_metadata where 1 != 1", + "Query": "select count(user_id) as num from user_metadata", + "Table": "user_metadata" + } + ] + } + ] + }, + { + "OperatorType": "Projection", + "Expressions": [ + "'count_b' as tab", + ":0 as num" + ], + "Inputs": [ + { + "OperatorType": "Aggregate", + "Variant": "Scalar", + "Aggregates": "sum_count(0) AS num", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select count(user_id) as num from user_extra where 1 != 1", + "Query": "select count(user_id) as num from user_extra", + "Table": "user_extra" + } + ] + } + ] + } + ] + } + ] + }, + "TablesUsed": [ + "user.user_extra", + "user.user_metadata" + ] + } } ] From e163c9eee03da72eb38160508b38d87cab572f92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vicent=20Mart=C3=AD?= <42793+vmg@users.noreply.github.com> Date: Wed, 21 Feb 2024 18:03:39 +0100 Subject: [PATCH 43/79] tablet: remove max-waiters setting (#15323) Signed-off-by: Vicent Marti --- config/tablet/default.yaml | 3 --- doc/design-docs/TabletServerParamsAsYAML.md | 3 --- go/flags/endtoend/vtcombo.txt | 3 --- go/flags/endtoend/vttablet.txt | 3 --- go/vt/vttablet/tabletserver/tabletenv/config.go | 17 +++++++++-------- .../tabletserver/tabletenv/config_test.go | 6 ------ go/vt/vttablet/tabletserver/tx_pool_test.go | 8 -------- 7 files changed, 9 insertions(+), 34 deletions(-) diff --git a/config/tablet/default.yaml b/config/tablet/default.yaml index f996bb04737..ec9d1f94833 100644 --- a/config/tablet/default.yaml +++ b/config/tablet/default.yaml @@ -57,21 +57,18 @@ oltpReadPool: idleTimeoutSeconds: 1800 # queryserver-config-idle-timeout maxLifetimeSeconds: 0 # queryserver-config-pool-conn-max-lifetime prefillParallelism: 0 # queryserver-config-pool-prefill-parallelism - maxWaiters: 50000 # queryserver-config-query-pool-waiter-cap olapReadPool: size: 200 # queryserver-config-stream-pool-size timeoutSeconds: 0 # queryserver-config-query-pool-timeout idleTimeoutSeconds: 1800 # queryserver-config-idle-timeout prefillParallelism: 0 # queryserver-config-stream-pool-prefill-parallelism - maxWaiters: 0 txPool: size: 20 # queryserver-config-transaction-cap timeoutSeconds: 1 # queryserver-config-txpool-timeout idleTimeoutSeconds: 1800 # queryserver-config-idle-timeout prefillParallelism: 0 # queryserver-config-transaction-prefill-parallelism - maxWaiters: 50000 # queryserver-config-txpool-waiter-cap oltp: queryTimeoutSeconds: 30 # queryserver-config-query-timeout diff --git a/doc/design-docs/TabletServerParamsAsYAML.md b/doc/design-docs/TabletServerParamsAsYAML.md index 49d073d1313..52d48a5e6f6 100644 --- a/doc/design-docs/TabletServerParamsAsYAML.md +++ b/doc/design-docs/TabletServerParamsAsYAML.md @@ -95,21 +95,18 @@ oltpReadPool: timeoutSeconds: 0 # queryserver-config-query-pool-timeout idleTimeoutSeconds: 1800 # queryserver-config-idle-timeout prefillParallelism: 0 # queryserver-config-pool-prefill-parallelism - maxWaiters: 50000 # queryserver-config-query-pool-waiter-cap olapReadPool: size: 200 # queryserver-config-stream-pool-size timeoutSeconds: 0 # queryserver-config-query-pool-timeout idleTimeoutSeconds: 1800 # queryserver-config-idle-timeout prefillParallelism: 0 # queryserver-config-stream-pool-prefill-parallelism - maxWaiters: 0 txPool: size: 20 # queryserver-config-transaction-cap timeoutSeconds: 1 # queryserver-config-txpool-timeout idleTimeoutSeconds: 1800 # queryserver-config-idle-timeout prefillParallelism: 0 # queryserver-config-transaction-prefill-parallelism - maxWaiters: 50000 # queryserver-config-txpool-waiter-cap oltp: queryTimeoutSeconds: 30 # queryserver-config-query-timeout diff --git a/go/flags/endtoend/vtcombo.txt b/go/flags/endtoend/vtcombo.txt index 59dd8969880..0843ee46563 100644 --- a/go/flags/endtoend/vtcombo.txt +++ b/go/flags/endtoend/vtcombo.txt @@ -283,21 +283,18 @@ Flags: --queryserver-config-pool-size int query server read pool size, connection pool is used by regular queries (non streaming, not in a transaction) (default 16) --queryserver-config-query-cache-memory int query server query cache size in bytes, maximum amount of memory to be used for caching. vttablet analyzes every incoming query and generate a query plan, these plans are being cached in a lru cache. This config controls the capacity of the lru cache. (default 33554432) --queryserver-config-query-pool-timeout duration query server query pool timeout, it is how long vttablet waits for a connection from the query pool. If set to 0 (default) then the overall query timeout is used instead. - --queryserver-config-query-pool-waiter-cap int query server query pool waiter limit, this is the maximum number of queries that can be queued waiting to get a connection (default 5000) --queryserver-config-query-timeout duration query server query timeout, this is the query timeout in vttablet side. If a query takes more than this timeout, it will be killed. (default 30s) --queryserver-config-schema-change-signal query server schema signal, will signal connected vtgates that schema has changed whenever this is detected. VTGates will need to have -schema_change_signal enabled for this to work (default true) --queryserver-config-schema-reload-time duration query server schema reload time, how often vttablet reloads schemas from underlying MySQL instance. vttablet keeps table schemas in its own memory and periodically refreshes it from MySQL. This config controls the reload time. (default 30m0s) --queryserver-config-stream-buffer-size int query server stream buffer size, the maximum number of bytes sent from vttablet for each stream call. It's recommended to keep this value in sync with vtgate's stream_buffer_size. (default 32768) --queryserver-config-stream-pool-size int query server stream connection pool size, stream pool is used by stream queries: queries that return results to client in a streaming fashion (default 200) --queryserver-config-stream-pool-timeout duration query server stream pool timeout, it is how long vttablet waits for a connection from the stream pool. If set to 0 (default) then there is no timeout. - --queryserver-config-stream-pool-waiter-cap int query server stream pool waiter limit, this is the maximum number of streaming queries that can be queued waiting to get a connection --queryserver-config-strict-table-acl only allow queries that pass table acl checks --queryserver-config-terse-errors prevent bind vars from escaping in client error messages --queryserver-config-transaction-cap int query server transaction cap is the maximum number of transactions allowed to happen at any given point of a time for a single vttablet. E.g. by setting transaction cap to 100, there are at most 100 transactions will be processed by a vttablet and the 101th transaction will be blocked (and fail if it cannot get connection within specified timeout) (default 20) --queryserver-config-transaction-timeout duration query server transaction timeout, a transaction will be killed if it takes longer than this value (default 30s) --queryserver-config-truncate-error-len int truncate errors sent to client if they are longer than this value (0 means do not truncate) --queryserver-config-txpool-timeout duration query server transaction pool timeout, it is how long vttablet waits if tx pool is full (default 1s) - --queryserver-config-txpool-waiter-cap int query server transaction pool waiter limit, this is the maximum number of transactions that can be queued waiting to get a connection (default 5000) --queryserver-config-warn-result-size int query server result size warning threshold, warn if number of rows returned from vttablet for non-streaming queries exceeds this --queryserver-enable-settings-pool Enable pooling of connections with modified system settings (default true) --queryserver-enable-views Enable views support in vttablet. diff --git a/go/flags/endtoend/vttablet.txt b/go/flags/endtoend/vttablet.txt index ac25179db9b..bb7403ef1cb 100644 --- a/go/flags/endtoend/vttablet.txt +++ b/go/flags/endtoend/vttablet.txt @@ -276,21 +276,18 @@ Flags: --queryserver-config-pool-size int query server read pool size, connection pool is used by regular queries (non streaming, not in a transaction) (default 16) --queryserver-config-query-cache-memory int query server query cache size in bytes, maximum amount of memory to be used for caching. vttablet analyzes every incoming query and generate a query plan, these plans are being cached in a lru cache. This config controls the capacity of the lru cache. (default 33554432) --queryserver-config-query-pool-timeout duration query server query pool timeout, it is how long vttablet waits for a connection from the query pool. If set to 0 (default) then the overall query timeout is used instead. - --queryserver-config-query-pool-waiter-cap int query server query pool waiter limit, this is the maximum number of queries that can be queued waiting to get a connection (default 5000) --queryserver-config-query-timeout duration query server query timeout, this is the query timeout in vttablet side. If a query takes more than this timeout, it will be killed. (default 30s) --queryserver-config-schema-change-signal query server schema signal, will signal connected vtgates that schema has changed whenever this is detected. VTGates will need to have -schema_change_signal enabled for this to work (default true) --queryserver-config-schema-reload-time duration query server schema reload time, how often vttablet reloads schemas from underlying MySQL instance. vttablet keeps table schemas in its own memory and periodically refreshes it from MySQL. This config controls the reload time. (default 30m0s) --queryserver-config-stream-buffer-size int query server stream buffer size, the maximum number of bytes sent from vttablet for each stream call. It's recommended to keep this value in sync with vtgate's stream_buffer_size. (default 32768) --queryserver-config-stream-pool-size int query server stream connection pool size, stream pool is used by stream queries: queries that return results to client in a streaming fashion (default 200) --queryserver-config-stream-pool-timeout duration query server stream pool timeout, it is how long vttablet waits for a connection from the stream pool. If set to 0 (default) then there is no timeout. - --queryserver-config-stream-pool-waiter-cap int query server stream pool waiter limit, this is the maximum number of streaming queries that can be queued waiting to get a connection --queryserver-config-strict-table-acl only allow queries that pass table acl checks --queryserver-config-terse-errors prevent bind vars from escaping in client error messages --queryserver-config-transaction-cap int query server transaction cap is the maximum number of transactions allowed to happen at any given point of a time for a single vttablet. E.g. by setting transaction cap to 100, there are at most 100 transactions will be processed by a vttablet and the 101th transaction will be blocked (and fail if it cannot get connection within specified timeout) (default 20) --queryserver-config-transaction-timeout duration query server transaction timeout, a transaction will be killed if it takes longer than this value (default 30s) --queryserver-config-truncate-error-len int truncate errors sent to client if they are longer than this value (0 means do not truncate) --queryserver-config-txpool-timeout duration query server transaction pool timeout, it is how long vttablet waits if tx pool is full (default 1s) - --queryserver-config-txpool-waiter-cap int query server transaction pool waiter limit, this is the maximum number of transactions that can be queued waiting to get a connection (default 5000) --queryserver-config-warn-result-size int query server result size warning threshold, warn if number of rows returned from vttablet for non-streaming queries exceeds this --queryserver-enable-settings-pool Enable pooling of connections with modified system settings (default true) --queryserver-enable-views Enable views support in vttablet. diff --git a/go/vt/vttablet/tabletserver/tabletenv/config.go b/go/vt/vttablet/tabletserver/tabletenv/config.go index 25352aba91b..233f8951227 100644 --- a/go/vt/vttablet/tabletserver/tabletenv/config.go +++ b/go/vt/vttablet/tabletserver/tabletenv/config.go @@ -142,9 +142,15 @@ func registerTabletEnvFlags(fs *pflag.FlagSet) { fs.DurationVar(¤tConfig.TxPool.Timeout, "queryserver-config-txpool-timeout", defaultConfig.TxPool.Timeout, "query server transaction pool timeout, it is how long vttablet waits if tx pool is full") fs.DurationVar(¤tConfig.OltpReadPool.IdleTimeout, "queryserver-config-idle-timeout", defaultConfig.OltpReadPool.IdleTimeout, "query server idle timeout, vttablet manages various mysql connection pools. This config means if a connection has not been used in given idle timeout, this connection will be removed from pool. This effectively manages number of connection objects and optimize the pool performance.") fs.DurationVar(¤tConfig.OltpReadPool.MaxLifetime, "queryserver-config-pool-conn-max-lifetime", defaultConfig.OltpReadPool.MaxLifetime, "query server connection max lifetime, vttablet manages various mysql connection pools. This config means if a connection has lived at least this long, it connection will be removed from pool upon the next time it is returned to the pool.") - fs.IntVar(¤tConfig.OltpReadPool.MaxWaiters, "queryserver-config-query-pool-waiter-cap", defaultConfig.OltpReadPool.MaxWaiters, "query server query pool waiter limit, this is the maximum number of queries that can be queued waiting to get a connection") - fs.IntVar(¤tConfig.OlapReadPool.MaxWaiters, "queryserver-config-stream-pool-waiter-cap", defaultConfig.OlapReadPool.MaxWaiters, "query server stream pool waiter limit, this is the maximum number of streaming queries that can be queued waiting to get a connection") - fs.IntVar(¤tConfig.TxPool.MaxWaiters, "queryserver-config-txpool-waiter-cap", defaultConfig.TxPool.MaxWaiters, "query server transaction pool waiter limit, this is the maximum number of transactions that can be queued waiting to get a connection") + + var unused int + fs.IntVar(&unused, "queryserver-config-query-pool-waiter-cap", 0, "query server query pool waiter limit, this is the maximum number of queries that can be queued waiting to get a connection") + fs.IntVar(&unused, "queryserver-config-stream-pool-waiter-cap", 0, "query server stream pool waiter limit, this is the maximum number of streaming queries that can be queued waiting to get a connection") + fs.IntVar(&unused, "queryserver-config-txpool-waiter-cap", 0, "query server transaction pool waiter limit, this is the maximum number of transactions that can be queued waiting to get a connection") + fs.MarkDeprecated("queryserver-config-query-pool-waiter-cap", "The new connection pool in v19 does not limit waiter capacity. This flag will be removed in a future release.") + fs.MarkDeprecated("queryserver-config-stream-pool-waiter-cap", "The new connection pool in v19 does not limit waiter capacity. This flag will be removed in a future release.") + fs.MarkDeprecated("queryserver-config-txpool-waiter-cap", "The new connection pool in v19 does not limit waiter capacity. This flag will be removed in a future release.") + // tableacl related configurations. fs.BoolVar(¤tConfig.StrictTableACL, "queryserver-config-strict-table-acl", defaultConfig.StrictTableACL, "only allow queries that pass table acl checks") fs.BoolVar(¤tConfig.EnableTableACLDryRun, "queryserver-config-enable-table-acl-dry-run", defaultConfig.EnableTableACLDryRun, "If this flag is enabled, tabletserver will emit monitoring metrics and let the request pass regardless of table acl check results") @@ -440,7 +446,6 @@ type ConnPoolConfig struct { IdleTimeout time.Duration `json:"idleTimeoutSeconds,omitempty"` MaxLifetime time.Duration `json:"maxLifetimeSeconds,omitempty"` PrefillParallelism int `json:"prefillParallelism,omitempty"` - MaxWaiters int `json:"maxWaiters,omitempty"` } func (cfg *ConnPoolConfig) MarshalJSON() ([]byte, error) { @@ -477,7 +482,6 @@ func (cfg *ConnPoolConfig) UnmarshalJSON(data []byte) (err error) { IdleTimeout string `json:"idleTimeoutSeconds,omitempty"` MaxLifetime string `json:"maxLifetimeSeconds,omitempty"` PrefillParallelism int `json:"prefillParallelism,omitempty"` - MaxWaiters int `json:"maxWaiters,omitempty"` } if err := json.Unmarshal(data, &tmp); err != nil { @@ -507,7 +511,6 @@ func (cfg *ConnPoolConfig) UnmarshalJSON(data []byte) (err error) { cfg.Size = tmp.Size cfg.PrefillParallelism = tmp.PrefillParallelism - cfg.MaxWaiters = tmp.MaxWaiters return nil } @@ -945,7 +948,6 @@ var defaultConfig = TabletConfig{ OltpReadPool: ConnPoolConfig{ Size: 16, IdleTimeout: 30 * time.Minute, - MaxWaiters: 5000, }, OlapReadPool: ConnPoolConfig{ Size: 200, @@ -955,7 +957,6 @@ var defaultConfig = TabletConfig{ Size: 20, Timeout: time.Second, IdleTimeout: 30 * time.Minute, - MaxWaiters: 5000, }, Olap: OlapConfig{ TxTimeout: 30 * time.Second, diff --git a/go/vt/vttablet/tabletserver/tabletenv/config_test.go b/go/vt/vttablet/tabletserver/tabletenv/config_test.go index c6f65cb94cb..98d4cfceb21 100644 --- a/go/vt/vttablet/tabletserver/tabletenv/config_test.go +++ b/go/vt/vttablet/tabletserver/tabletenv/config_test.go @@ -48,7 +48,6 @@ func TestConfigParse(t *testing.T) { }, OltpReadPool: ConnPoolConfig{ Size: 16, - MaxWaiters: 40, Timeout: 10 * time.Second, IdleTimeout: 20 * time.Second, MaxLifetime: 50 * time.Second, @@ -86,7 +85,6 @@ oltp: {} oltpReadPool: idleTimeoutSeconds: 20s maxLifetimeSeconds: 50s - maxWaiters: 40 size: 16 timeoutSeconds: 10s replicationTracker: {} @@ -109,7 +107,6 @@ txPool: {} oltpReadPool: size: 16 idleTimeoutSeconds: 20s - maxWaiters: 40 maxLifetimeSeconds: 50s `) gotCfg := cfg @@ -148,7 +145,6 @@ oltp: txTimeoutSeconds: 30s oltpReadPool: idleTimeoutSeconds: 30m0s - maxWaiters: 5000 size: 16 queryCacheDoorkeeper: true queryCacheMemory: 33554432 @@ -164,7 +160,6 @@ signalWhenSchemaChange: true streamBufferSize: 32768 txPool: idleTimeoutSeconds: 30m0s - maxWaiters: 5000 size: 20 timeoutSeconds: 1s ` @@ -178,7 +173,6 @@ func TestClone(t *testing.T) { cfg1 := &TabletConfig{ OltpReadPool: ConnPoolConfig{ Size: 16, - MaxWaiters: 40, Timeout: 10 * time.Second, IdleTimeout: 20 * time.Second, MaxLifetime: 50 * time.Second, diff --git a/go/vt/vttablet/tabletserver/tx_pool_test.go b/go/vt/vttablet/tabletserver/tx_pool_test.go index 9edbe5b3592..37500ada79a 100644 --- a/go/vt/vttablet/tabletserver/tx_pool_test.go +++ b/go/vt/vttablet/tabletserver/tx_pool_test.go @@ -305,7 +305,6 @@ func TestTxPoolWaitTimeoutError(t *testing.T) { env := newEnv("TabletServerTest") env.Config().TxPool.Size = 1 - env.Config().TxPool.MaxWaiters = 0 env.Config().TxPool.Timeout = time.Second // given db, txPool, _, closer := setupWithEnv(t, env) @@ -428,7 +427,6 @@ func TestTxTimeoutKillsTransactions(t *testing.T) { env := newEnv("TabletServerTest") env.Config().TxPool.Size = 1 - env.Config().TxPool.MaxWaiters = 0 env.Config().Oltp.TxTimeout = time.Second _, txPool, limiter, closer := setupWithEnv(t, env) defer closer() @@ -477,7 +475,6 @@ func TestTxTimeoutDoesNotKillShortLivedTransactions(t *testing.T) { env := newEnv("TabletServerTest") env.Config().TxPool.Size = 1 - env.Config().TxPool.MaxWaiters = 0 env.Config().Oltp.TxTimeout = time.Second _, txPool, _, closer := setupWithEnv(t, env) defer closer() @@ -510,7 +507,6 @@ func TestTxTimeoutKillsOlapTransactions(t *testing.T) { env := newEnv("TabletServerTest") env.Config().TxPool.Size = 1 - env.Config().TxPool.MaxWaiters = 0 env.Config().Oltp.TxTimeout = time.Second env.Config().Olap.TxTimeout = 2 * time.Second _, txPool, _, closer := setupWithEnv(t, env) @@ -548,7 +544,6 @@ func TestTxTimeoutNotEnforcedForZeroLengthTimeouts(t *testing.T) { env := newEnv("TabletServerTest") env.Config().TxPool.Size = 2 - env.Config().TxPool.MaxWaiters = 0 env.Config().Oltp.TxTimeout = 0 env.Config().Olap.TxTimeout = 0 _, txPool, _, closer := setupWithEnv(t, env) @@ -591,7 +586,6 @@ func TestTxTimeoutReservedConn(t *testing.T) { env := newEnv("TabletServerTest") env.Config().TxPool.Size = 1 - env.Config().TxPool.MaxWaiters = 0 env.Config().Oltp.TxTimeout = time.Second env.Config().Olap.TxTimeout = 2 * time.Second _, txPool, _, closer := setupWithEnv(t, env) @@ -634,7 +628,6 @@ func TestTxTimeoutReusedReservedConn(t *testing.T) { env := newEnv("TabletServerTest") env.Config().TxPool.Size = 1 - env.Config().TxPool.MaxWaiters = 0 env.Config().Oltp.TxTimeout = time.Second env.Config().Olap.TxTimeout = 2 * time.Second _, txPool, _, closer := setupWithEnv(t, env) @@ -820,7 +813,6 @@ func newEnv(exporterName string) tabletenv.Env { cfg.TxPool.Size = 300 cfg.Oltp.TxTimeout = 30 * time.Second cfg.TxPool.Timeout = 40 * time.Second - cfg.TxPool.MaxWaiters = 500000 cfg.OltpReadPool.IdleTimeout = 30 * time.Second cfg.OlapReadPool.IdleTimeout = 30 * time.Second cfg.TxPool.IdleTimeout = 30 * time.Second From 0adb706b5799fb655d013104f9fffcccce5b4831 Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Wed, 21 Feb 2024 15:32:35 -0500 Subject: [PATCH 44/79] [e2e] More vtctldclient updates in tests (#15276) Signed-off-by: Andrew Mason --- .../endtoend/cluster/vtctldclient_process.go | 51 ++++++++++++++++++ go/test/endtoend/keyspace/keyspace_test.go | 52 +++++++++--------- .../reparent/newfeaturetest/reparent_test.go | 6 +-- .../reparent/plannedreparent/reparent_test.go | 26 ++++----- go/test/endtoend/reparent/utils/utils.go | 53 ++++++++----------- .../endtoend/sharded/sharded_keyspace_test.go | 18 +++---- .../buffer/reparent/failover_buffer_test.go | 6 +-- .../buffer/reshard/sharded_buffer_test.go | 9 ++-- .../endtoend/tabletmanager/commands_test.go | 37 +++++++------ .../tabletmanager/custom_rule_topo_test.go | 2 +- .../tabletmanager/primary/tablet_test.go | 23 ++++---- .../tabletmanager/tablet_health_test.go | 43 +++++++-------- go/test/endtoend/tabletmanager/tablet_test.go | 6 +-- .../throttler_topo/throttler_test.go | 8 +-- go/test/endtoend/topoconncache/main_test.go | 12 ++--- .../topoconncache/topo_conn_cache_test.go | 4 +- go/test/endtoend/vault/vault_test.go | 2 +- .../endtoend/versionupgrade/upgrade_test.go | 2 +- .../vtgate/createdb_plugin/main_test.go | 4 +- .../endtoend/vtgate/foreignkey/main_test.go | 2 +- .../foreignkey/stress/fk_stress_test.go | 8 +-- go/test/endtoend/vtgate/gen4/main_test.go | 4 +- go/test/endtoend/vtgate/main_test.go | 4 +- .../queries/informationschema/main_test.go | 4 +- .../queries/lookup_queries/main_test.go | 2 +- .../reservedconn/reconnect1/main_test.go | 12 ++--- .../reservedconn/reconnect2/main_test.go | 4 +- .../reservedconn/reconnect3/main_test.go | 2 +- .../reservedconn/reconnect4/main_test.go | 2 +- go/test/endtoend/vtgate/schema/schema_test.go | 30 +++++------ .../sharded_prs/st_sharded_test.go | 2 +- .../tablet_healthcheck/reparent_test.go | 6 +-- .../correctness_test.go | 2 +- go/test/endtoend/vtorc/api/api_test.go | 2 +- go/test/endtoend/vtorc/general/vtorc_test.go | 14 ++--- .../primaryfailure/primary_failure_test.go | 14 ++--- go/test/endtoend/vtorc/utils/utils.go | 24 +++------ 37 files changed, 262 insertions(+), 240 deletions(-) diff --git a/go/test/endtoend/cluster/vtctldclient_process.go b/go/test/endtoend/cluster/vtctldclient_process.go index 959ab5a93b9..c5afd8f1220 100644 --- a/go/test/endtoend/cluster/vtctldclient_process.go +++ b/go/test/endtoend/cluster/vtctldclient_process.go @@ -27,6 +27,7 @@ import ( "vitess.io/vitess/go/vt/vterrors" topodatapb "vitess.io/vitess/go/vt/proto/topodata" + vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata" ) // VtctldClientProcess is a generic handle for a running vtctldclient command . @@ -97,6 +98,11 @@ func VtctldClientProcessInstance(hostname string, grpcPort int, tmpDirectory str return vtctldclient } +// ApplyRoutingRules applies the given routing rules. +func (vtctldclient *VtctldClientProcess) ApplyRoutingRules(json string) error { + return vtctldclient.ExecuteCommand("ApplyRoutingRules", "--rules", json) +} + type ApplySchemaParams struct { DDLStrategy string MigrationContext string @@ -213,6 +219,51 @@ func (vtctldclient *VtctldClientProcess) CreateKeyspace(keyspaceName string, sid return err } +// GetKeyspace executes the vtctldclient command to get a shard, and parses the response. +func (vtctldclient *VtctldClientProcess) GetKeyspace(keyspace string) (*vtctldatapb.Keyspace, error) { + data, err := vtctldclient.ExecuteCommandWithOutput("GetKeyspace", keyspace) + if err != nil { + return nil, err + } + + var ks vtctldatapb.Keyspace + err = json2.Unmarshal([]byte(data), &ks) + if err != nil { + return nil, vterrors.Wrapf(err, "failed to parse keyspace output: %s", data) + } + return &ks, nil +} + +// GetShard executes the vtctldclient command to get a shard, and parses the response. +func (vtctldclient *VtctldClientProcess) GetShard(keyspace string, shard string) (*vtctldatapb.Shard, error) { + data, err := vtctldclient.ExecuteCommandWithOutput("GetShard", fmt.Sprintf("%s/%s", keyspace, shard)) + if err != nil { + return nil, err + } + + var si vtctldatapb.Shard + err = json2.Unmarshal([]byte(data), &si) + if err != nil { + return nil, vterrors.Wrapf(err, "failed to parse shard output: %s", data) + } + return &si, nil +} + +// GetTablet executes vtctldclient command to get a tablet, and parses the response. +func (vtctldclient *VtctldClientProcess) GetTablet(alias string) (*topodatapb.Tablet, error) { + data, err := vtctldclient.ExecuteCommandWithOutput("GetTablet", alias) + if err != nil { + return nil, err + } + + var tablet topodatapb.Tablet + err = json2.Unmarshal([]byte(data), &tablet) + if err != nil { + return nil, vterrors.Wrapf(err, "failed to parse tablet output: %s", data) + } + return &tablet, nil +} + // OnlineDDLShowRecent responds with recent schema migration list func (vtctldclient *VtctldClientProcess) OnlineDDLShowRecent(Keyspace string) (result string, err error) { return vtctldclient.ExecuteCommandWithOutput( diff --git a/go/test/endtoend/keyspace/keyspace_test.go b/go/test/endtoend/keyspace/keyspace_test.go index 142e4b4b442..7f7d4198135 100644 --- a/go/test/endtoend/keyspace/keyspace_test.go +++ b/go/test/endtoend/keyspace/keyspace_test.go @@ -21,17 +21,18 @@ import ( "encoding/json" "flag" "os" - "strings" "testing" - "vitess.io/vitess/go/constants/sidecar" - "vitess.io/vitess/go/vt/key" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "vitess.io/vitess/go/constants/sidecar" + "vitess.io/vitess/go/json2" "vitess.io/vitess/go/test/endtoend/cluster" - "vitess.io/vitess/go/vt/proto/topodata" + "vitess.io/vitess/go/vt/key" + + topodatapb "vitess.io/vitess/go/vt/proto/topodata" + vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata" ) var ( @@ -41,7 +42,7 @@ var ( cell = "zone1" cell2 = "zone2" hostname = "localhost" - servedTypes = map[topodata.TabletType]bool{topodata.TabletType_PRIMARY: true, topodata.TabletType_REPLICA: true, topodata.TabletType_RDONLY: true} + servedTypes = map[topodatapb.TabletType]bool{topodatapb.TabletType_PRIMARY: true, topodatapb.TabletType_REPLICA: true, topodatapb.TabletType_RDONLY: true} sqlSchema = `create table vt_insert_test ( id bigint auto_increment, msg varchar(64), @@ -152,29 +153,31 @@ func TestDurabilityPolicyField(t *testing.T) { out, err = vtctldClientProcess.ExecuteCommandWithOutput("DeleteKeyspace", "ks_durability") require.NoError(t, err, out) - out, err = clusterForKSTest.VtctlProcess.ExecuteCommandWithOutput("CreateKeyspace", "--", "--durability-policy=semi_sync", "ks_durability") + out, err = clusterForKSTest.VtctldClientProcess.ExecuteCommandWithOutput("CreateKeyspace", "--durability-policy=semi_sync", "ks_durability") require.NoError(t, err, out) checkDurabilityPolicy(t, "semi_sync") - out, err = clusterForKSTest.VtctlProcess.ExecuteCommandWithOutput("DeleteKeyspace", "ks_durability") + out, err = clusterForKSTest.VtctldClientProcess.ExecuteCommandWithOutput("DeleteKeyspace", "ks_durability") require.NoError(t, err, out) } func checkDurabilityPolicy(t *testing.T, durabilityPolicy string) { - var keyspace topodata.Keyspace - out, err := clusterForKSTest.VtctlclientProcess.ExecuteCommandWithOutput("GetKeyspace", "ks_durability") - require.NoError(t, err, out) - err = json.Unmarshal([]byte(out), &keyspace) + ks, err := clusterForKSTest.VtctldClientProcess.GetKeyspace("ks_durability") require.NoError(t, err) - require.Equal(t, keyspace.DurabilityPolicy, durabilityPolicy) + require.Equal(t, ks.Keyspace.DurabilityPolicy, durabilityPolicy) } func TestGetSrvKeyspaceNames(t *testing.T) { defer cluster.PanicHandler(t) - output, err := clusterForKSTest.VtctlclientProcess.ExecuteCommandWithOutput("GetSrvKeyspaceNames", cell) + data, err := clusterForKSTest.VtctldClientProcess.ExecuteCommandWithOutput("GetSrvKeyspaceNames", cell) require.Nil(t, err) - assert.Contains(t, strings.Split(output, "\n"), keyspaceUnshardedName) - assert.Contains(t, strings.Split(output, "\n"), keyspaceShardedName) + + var namesByCell = map[string]*vtctldatapb.GetSrvKeyspaceNamesResponse_NameList{} + err = json2.Unmarshal([]byte(data), &namesByCell) + require.NoError(t, err) + + assert.Contains(t, namesByCell[cell].Names, keyspaceUnshardedName) + assert.Contains(t, namesByCell[cell].Names, keyspaceShardedName) } func TestGetSrvKeyspacePartitions(t *testing.T) { @@ -210,7 +213,7 @@ func TestShardNames(t *testing.T) { defer cluster.PanicHandler(t) output, err := clusterForKSTest.VtctlclientProcess.ExecuteCommandWithOutput("GetSrvKeyspace", cell, keyspaceShardedName) require.Nil(t, err) - var srvKeyspace topodata.SrvKeyspace + var srvKeyspace topodatapb.SrvKeyspace err = json.Unmarshal([]byte(output), &srvKeyspace) require.Nil(t, err) @@ -218,12 +221,7 @@ func TestShardNames(t *testing.T) { func TestGetKeyspace(t *testing.T) { defer cluster.PanicHandler(t) - output, err := clusterForKSTest.VtctlclientProcess.ExecuteCommandWithOutput("GetKeyspace", keyspaceUnshardedName) - require.Nil(t, err) - - var keyspace topodata.Keyspace - - err = json.Unmarshal([]byte(output), &keyspace) + _, err := clusterForKSTest.VtctldClientProcess.GetKeyspace(keyspaceUnshardedName) require.Nil(t, err) } @@ -390,7 +388,7 @@ func TestKeyspaceToShardName(t *testing.T) { // for each served type PRIMARY REPLICA RDONLY, the shard ref count should match for _, partition := range srvKeyspace.Partitions { - if partition.ServedType == topodata.TabletType_PRIMARY { + if partition.ServedType == topodatapb.TabletType_PRIMARY { for _, shardRef := range partition.ShardReferences { shardKIDs := shardKIdMap[shardRef.Name] for _, kid := range shardKIDs { @@ -405,7 +403,7 @@ func TestKeyspaceToShardName(t *testing.T) { srvKeyspace = getSrvKeyspace(t, cell, keyspaceUnshardedName) for _, partition := range srvKeyspace.Partitions { - if partition.ServedType == topodata.TabletType_PRIMARY { + if partition.ServedType == topodatapb.TabletType_PRIMARY { for _, shardRef := range partition.ShardReferences { assert.Equal(t, shardRef.Name, keyspaceUnshardedName) } @@ -420,10 +418,10 @@ func packKeyspaceID(keyspaceID uint64) []byte { return (keybytes[:]) } -func getSrvKeyspace(t *testing.T, cell string, ksname string) *topodata.SrvKeyspace { +func getSrvKeyspace(t *testing.T, cell string, ksname string) *topodatapb.SrvKeyspace { output, err := clusterForKSTest.VtctlclientProcess.ExecuteCommandWithOutput("GetSrvKeyspace", cell, ksname) require.Nil(t, err) - var srvKeyspace topodata.SrvKeyspace + var srvKeyspace topodatapb.SrvKeyspace err = json.Unmarshal([]byte(output), &srvKeyspace) require.Nil(t, err) diff --git a/go/test/endtoend/reparent/newfeaturetest/reparent_test.go b/go/test/endtoend/reparent/newfeaturetest/reparent_test.go index b570509f1a7..44cd89a306a 100644 --- a/go/test/endtoend/reparent/newfeaturetest/reparent_test.go +++ b/go/test/endtoend/reparent/newfeaturetest/reparent_test.go @@ -40,7 +40,7 @@ func TestRecoverWithMultipleVttabletFailures(t *testing.T) { utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{tablets[1], tablets[2], tablets[3]}) // make tablets[1] a rdonly tablet. - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "rdonly") require.NoError(t, err) // Confirm that replication is still working as intended @@ -139,10 +139,10 @@ func TestChangeTypeWithoutSemiSync(t *testing.T) { utils.CheckPrimaryTablet(t, clusterInstance, primary) // Change replica's type to rdonly - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", replica.Alias, "rdonly") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", replica.Alias, "rdonly") require.NoError(t, err) // Change tablets type from rdonly back to replica - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", replica.Alias, "replica") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", replica.Alias, "replica") require.NoError(t, err) } diff --git a/go/test/endtoend/reparent/plannedreparent/reparent_test.go b/go/test/endtoend/reparent/plannedreparent/reparent_test.go index 6aa5972b928..07e488b52d0 100644 --- a/go/test/endtoend/reparent/plannedreparent/reparent_test.go +++ b/go/test/endtoend/reparent/plannedreparent/reparent_test.go @@ -44,7 +44,7 @@ func TestPrimaryToSpareStateChangeImpossible(t *testing.T) { tablets := clusterInstance.Keyspaces[0].Shards[0].Vttablets // We cannot change a primary to spare - out, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ChangeTabletType", tablets[0].Alias, "spare") + out, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ChangeTabletType", tablets[0].Alias, "spare") require.Error(t, err, out) require.Contains(t, out, "type change PRIMARY -> SPARE is not an allowed transition for ChangeTabletType") } @@ -92,7 +92,7 @@ func TestPRSWithDrainedLaggingTablet(t *testing.T) { defer utils.TeardownCluster(clusterInstance) tablets := clusterInstance.Keyspaces[0].Shards[0].Vttablets - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "drained") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", tablets[1].Alias, "drained") require.NoError(t, err) utils.ConfirmReplication(t, tablets[0], []*cluster.Vttablet{tablets[1], tablets[2], tablets[3]}) @@ -258,13 +258,13 @@ func reparentFromOutside(t *testing.T, clusterInstance *cluster.LocalProcessClus if downPrimary { err := tablets[0].VttabletProcess.TearDownWithTimeout(30 * time.Second) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", "--", - "--allow_primary", tablets[0].Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", + "--allow-primary", tablets[0].Alias) require.NoError(t, err) } // update topology with the new server - err := clusterInstance.VtctlclientProcess.ExecuteCommand("TabletExternallyReparented", + err := clusterInstance.VtctldClientProcess.ExecuteCommand("TabletExternallyReparented", tablets[1].Alias) require.NoError(t, err) @@ -318,7 +318,7 @@ func TestReparentWithDownReplica(t *testing.T) { // We have to StartReplication on tablets[2] since the MySQL instance is restarted and does not have replication running // We earlier used to rely on replicationManager to fix this but we have disabled it in our testing environment for latest versions of vttablet and vtctl. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", tablets[2].Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", tablets[2].Alias) require.NoError(t, err) // wait until it gets the data @@ -338,9 +338,9 @@ func TestChangeTypeSemiSync(t *testing.T) { primary, replica, rdonly1, rdonly2 := tablets[0], tablets[1], tablets[2], tablets[3] // Updated rdonly tablet and set tablet type to rdonly - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonly1.Alias, "rdonly") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonly1.Alias, "rdonly") require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonly2.Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonly2.Alias, "rdonly") require.NoError(t, err) utils.ValidateTopology(t, clusterInstance, true) @@ -349,7 +349,7 @@ func TestChangeTypeSemiSync(t *testing.T) { // Stop replication on rdonly1, to make sure when we make it replica it doesn't start again. // Note we do a similar test for replica -> rdonly below. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", rdonly1.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", rdonly1.Alias) require.NoError(t, err) // Check semi-sync on replicas. @@ -364,27 +364,27 @@ func TestChangeTypeSemiSync(t *testing.T) { utils.CheckDBstatus(ctx, t, rdonly2, "Rpl_semi_sync_slave_status", "OFF") // Change replica to rdonly while replicating, should turn off semi-sync, and restart replication. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", replica.Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", replica.Alias, "rdonly") require.NoError(t, err) utils.CheckDBvar(ctx, t, replica, "rpl_semi_sync_slave_enabled", "OFF") utils.CheckDBstatus(ctx, t, replica, "Rpl_semi_sync_slave_status", "OFF") // Change rdonly1 to replica, should turn on semi-sync, and not start replication. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonly1.Alias, "replica") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonly1.Alias, "replica") require.NoError(t, err) utils.CheckDBvar(ctx, t, rdonly1, "rpl_semi_sync_slave_enabled", "ON") utils.CheckDBstatus(ctx, t, rdonly1, "Rpl_semi_sync_slave_status", "OFF") utils.CheckReplicaStatus(ctx, t, rdonly1) // Now change from replica back to rdonly, make sure replication is still not enabled. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonly1.Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonly1.Alias, "rdonly") require.NoError(t, err) utils.CheckDBvar(ctx, t, rdonly1, "rpl_semi_sync_slave_enabled", "OFF") utils.CheckDBstatus(ctx, t, rdonly1, "Rpl_semi_sync_slave_status", "OFF") utils.CheckReplicaStatus(ctx, t, rdonly1) // Change rdonly2 to replica, should turn on semi-sync, and restart replication. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonly2.Alias, "replica") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonly2.Alias, "replica") require.NoError(t, err) utils.CheckDBvar(ctx, t, rdonly2, "rpl_semi_sync_slave_enabled", "ON") utils.CheckDBstatus(ctx, t, rdonly2, "Rpl_semi_sync_slave_status", "ON") diff --git a/go/test/endtoend/reparent/utils/utils.go b/go/test/endtoend/reparent/utils/utils.go index 675648dcf37..790fd0028e2 100644 --- a/go/test/endtoend/reparent/utils/utils.go +++ b/go/test/endtoend/reparent/utils/utils.go @@ -34,7 +34,6 @@ import ( querypb "vitess.io/vitess/go/vt/proto/query" "vitess.io/vitess/go/vt/vttablet/tabletconn" - "vitess.io/vitess/go/json2" "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/test/endtoend/cluster" @@ -185,7 +184,7 @@ func setupShard(ctx context.Context, t *testing.T, clusterInstance *cluster.Loca } // Initialize shard - err := clusterInstance.VtctlclientProcess.InitializeShard(KeyspaceName, shardName, tablets[0].Cell, tablets[0].TabletUID) + err := clusterInstance.VtctldClientProcess.InitializeShard(KeyspaceName, shardName, tablets[0].Cell, tablets[0].TabletUID) require.NoError(t, err) ValidateTopology(t, clusterInstance, true) @@ -306,21 +305,21 @@ func PrsAvoid(t *testing.T, clusterInstance *cluster.LocalProcessCluster, tab *c // PrsWithTimeout runs PRS func PrsWithTimeout(t *testing.T, clusterInstance *cluster.LocalProcessCluster, tab *cluster.Vttablet, avoid bool, actionTimeout, waitTimeout string) (string, error) { args := []string{ - "PlannedReparentShard", "--", - "--keyspace_shard", fmt.Sprintf("%s/%s", KeyspaceName, ShardName)} + "PlannedReparentShard", + fmt.Sprintf("%s/%s", KeyspaceName, ShardName)} if actionTimeout != "" { args = append(args, "--action_timeout", actionTimeout) } if waitTimeout != "" { - args = append(args, "--wait_replicas_timeout", waitTimeout) + args = append(args, "--wait-replicas-timeout", waitTimeout) } if avoid { - args = append(args, "--avoid_tablet") + args = append(args, "--avoid-primary") } else { - args = append(args, "--new_primary") + args = append(args, "--new-primary") } args = append(args, tab.Alias) - out, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput(args...) + out, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput(args...) return out, err } @@ -335,15 +334,15 @@ func ErsIgnoreTablet(clusterInstance *cluster.LocalProcessCluster, tab *cluster. if timeout != "" { args = append(args, "--action_timeout", timeout) } - args = append(args, "EmergencyReparentShard", "--", "--keyspace_shard", fmt.Sprintf("%s/%s", KeyspaceName, ShardName)) + args = append(args, "EmergencyReparentShard", fmt.Sprintf("%s/%s", KeyspaceName, ShardName)) if tab != nil { - args = append(args, "--new_primary", tab.Alias) + args = append(args, "--new-primary", tab.Alias) } if waitReplicasTimeout != "" { - args = append(args, "--wait_replicas_timeout", waitReplicasTimeout) + args = append(args, "--wait-replicas-timeout", waitReplicasTimeout) } if preventCrossCellPromotion { - args = append(args, "--prevent_cross_cell_promotion=true") + args = append(args, "--prevent-cross-cell-promotion") } if len(tabletsToIgnore) != 0 { tabsString := "" @@ -354,9 +353,9 @@ func ErsIgnoreTablet(clusterInstance *cluster.LocalProcessCluster, tab *cluster. tabsString = tabsString + "," + vttablet.Alias } } - args = append(args, "--ignore_replicas", tabsString) + args = append(args, "--ignore-replicas", tabsString) } - return clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput(args...) + return clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput(args...) } // ErsWithVtctl runs ERS via vtctl binary @@ -374,10 +373,10 @@ func ValidateTopology(t *testing.T, clusterInstance *cluster.LocalProcessCluster args := []string{"Validate"} if pingTablets { - args = append(args, "--", "--ping-tablets=true") + args = append(args, "--ping-tablets") } - out, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput(args...) - require.Empty(t, out) + out, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput(args...) + require.Contains(t, out, "no issues found") require.NoError(t, err) } @@ -398,17 +397,14 @@ func ConfirmReplication(t *testing.T, primary *cluster.Vttablet, replicas []*clu // ConfirmOldPrimaryIsHangingAround confirms that the old primary is hanging around func ConfirmOldPrimaryIsHangingAround(t *testing.T, clusterInstance *cluster.LocalProcessCluster) { - out, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("Validate") + out, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("Validate") require.Error(t, err) require.Contains(t, out, "already has primary") } // CheckPrimaryTablet makes sure the tablet type is primary, and its health check agrees. func CheckPrimaryTablet(t *testing.T, clusterInstance *cluster.LocalProcessCluster, tablet *cluster.Vttablet) { - result, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetTablet", tablet.Alias) - require.NoError(t, err) - var tabletInfo topodatapb.Tablet - err = json2.Unmarshal([]byte(result), &tabletInfo) + tabletInfo, err := clusterInstance.VtctldClientProcess.GetTablet(tablet.Alias) require.NoError(t, err) assert.Equal(t, topodatapb.TabletType_PRIMARY, tabletInfo.GetType()) @@ -424,10 +420,7 @@ func CheckPrimaryTablet(t *testing.T, clusterInstance *cluster.LocalProcessClust // isHealthyPrimaryTablet will return if tablet is primary AND healthy. func isHealthyPrimaryTablet(t *testing.T, clusterInstance *cluster.LocalProcessCluster, tablet *cluster.Vttablet) bool { - result, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetTablet", tablet.Alias) - require.Nil(t, err) - var tabletInfo topodatapb.Tablet - err = json2.Unmarshal([]byte(result), &tabletInfo) + tabletInfo, err := clusterInstance.VtctldClientProcess.GetTablet(tablet.Alias) require.Nil(t, err) if tabletInfo.GetType() != topodatapb.TabletType_PRIMARY { return false @@ -541,9 +534,9 @@ func ResurrectTablet(ctx context.Context, t *testing.T, clusterInstance *cluster // DeleteTablet is used to delete the given tablet func DeleteTablet(t *testing.T, clusterInstance *cluster.LocalProcessCluster, tab *cluster.Vttablet) { - err := clusterInstance.VtctlclientProcess.ExecuteCommand( - "DeleteTablet", "--", - "--allow_primary", + err := clusterInstance.VtctldClientProcess.ExecuteCommand( + "DeleteTablets", + "--allow-primary", tab.Alias) require.NoError(t, err) } @@ -629,7 +622,7 @@ func CheckReparentFromOutside(t *testing.T, clusterInstance *cluster.LocalProces // make sure the primary health stream says it's the primary too // (health check is disabled on these servers, force it first) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", tablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", tablet.Alias) require.NoError(t, err) shrs, err := clusterInstance.StreamTabletHealth(context.Background(), tablet, 1) diff --git a/go/test/endtoend/sharded/sharded_keyspace_test.go b/go/test/endtoend/sharded/sharded_keyspace_test.go index 857dc455206..f311404ad7e 100644 --- a/go/test/endtoend/sharded/sharded_keyspace_test.go +++ b/go/test/endtoend/sharded/sharded_keyspace_test.go @@ -108,9 +108,9 @@ func TestShardedKeyspace(t *testing.T) { shard1Primary := shard1.Vttablets[0] shard2Primary := shard2.Vttablets[0] - err := clusterInstance.VtctlclientProcess.InitializeShard(keyspaceName, shard1.Name, cell, shard1Primary.TabletUID) + err := clusterInstance.VtctldClientProcess.InitializeShard(keyspaceName, shard1.Name, cell, shard1Primary.TabletUID) require.Nil(t, err) - err = clusterInstance.VtctlclientProcess.InitializeShard(keyspaceName, shard2.Name, cell, shard2Primary.TabletUID) + err = clusterInstance.VtctldClientProcess.InitializeShard(keyspaceName, shard2.Name, cell, shard2Primary.TabletUID) require.Nil(t, err) err = clusterInstance.StartVTOrc(keyspaceName) @@ -125,7 +125,7 @@ func TestShardedKeyspace(t *testing.T) { _, err = shard2Primary.VttabletProcess.QueryTablet(sqlSchemaReverse, keyspaceName, true) require.Nil(t, err) - if err = clusterInstance.VtctlclientProcess.ApplyVSchema(keyspaceName, vSchema); err != nil { + if err = clusterInstance.VtctldClientProcess.ApplyVSchema(keyspaceName, vSchema); err != nil { log.Error(err.Error()) return } @@ -136,13 +136,13 @@ func TestShardedKeyspace(t *testing.T) { shard2Primary.Alias, shard2.Vttablets[1].Alias) - _ = clusterInstance.VtctlclientProcess.ExecuteCommand("SetReadWrite", shard1Primary.Alias) - _ = clusterInstance.VtctlclientProcess.ExecuteCommand("SetReadWrite", shard2Primary.Alias) + _ = clusterInstance.VtctldClientProcess.ExecuteCommand("SetWritable", shard1Primary.Alias, "true") + _ = clusterInstance.VtctldClientProcess.ExecuteCommand("SetWritable", shard2Primary.Alias, "true") _, _ = shard1Primary.VttabletProcess.QueryTablet("insert into vt_select_test (id, msg) values (1, 'test 1')", keyspaceName, true) _, _ = shard2Primary.VttabletProcess.QueryTablet("insert into vt_select_test (id, msg) values (10, 'test 10')", keyspaceName, true) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Validate", "--", "--ping-tablets") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Validate", "--ping-tablets") require.Nil(t, err) rows, err := shard1Primary.VttabletProcess.QueryTablet("select id, msg from vt_select_test order by id", keyspaceName, true) @@ -164,9 +164,9 @@ func TestShardedKeyspace(t *testing.T) { assert.Contains(t, output, shard1Primary.Alias+": CREATE TABLE") assert.Contains(t, output, shard2Primary.Alias+": CREATE TABLE") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ValidateVersionShard", fmt.Sprintf("%s/%s", keyspaceName, shard1.Name)) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ValidateVersionShard", fmt.Sprintf("%s/%s", keyspaceName, shard1.Name)) require.Nil(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("GetPermissions", shard1.Vttablets[1].Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("GetPermissions", shard1.Vttablets[1].Alias) require.Nil(t, err) err = clusterInstance.VtctlclientProcess.ExecuteCommand("ValidatePermissionsShard", fmt.Sprintf("%s/%s", keyspaceName, shard1.Name)) require.Nil(t, err) @@ -184,7 +184,7 @@ func TestShardedKeyspace(t *testing.T) { func reloadSchemas(t *testing.T, aliases ...string) { for _, alias := range aliases { - if err := clusterInstance.VtctlclientProcess.ExecuteCommand("ReloadSchema", alias); err != nil { + if err := clusterInstance.VtctldClientProcess.ExecuteCommand("ReloadSchema", alias); err != nil { assert.Fail(t, "Unable to reload schema") } diff --git a/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go b/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go index 2be57120050..486dc3ef9e5 100644 --- a/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go +++ b/go/test/endtoend/tabletgateway/buffer/reparent/failover_buffer_test.go @@ -83,7 +83,7 @@ func failoverExternalReparenting(t *testing.T, clusterInstance *cluster.LocalPro require.NoError(t, err) // Notify the new vttablet primary about the reparent. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("TabletExternallyReparented", newPrimary.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("TabletExternallyReparented", newPrimary.Alias) require.NoError(t, err) } @@ -92,9 +92,9 @@ func failoverPlannedReparenting(t *testing.T, clusterInstance *cluster.LocalProc reads.ExpectQueries(10) writes.ExpectQueries(10) - err := clusterInstance.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", "--keyspace_shard", + err := clusterInstance.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", fmt.Sprintf("%s/%s", keyspaceUnshardedName, "0"), - "--new_primary", clusterInstance.Keyspaces[0].Shards[0].Vttablets[1].Alias) + "--new-primary", clusterInstance.Keyspaces[0].Shards[0].Vttablets[1].Alias) require.NoError(t, err) } diff --git a/go/test/endtoend/tabletgateway/buffer/reshard/sharded_buffer_test.go b/go/test/endtoend/tabletgateway/buffer/reshard/sharded_buffer_test.go index ae922108012..d58d8901165 100644 --- a/go/test/endtoend/tabletgateway/buffer/reshard/sharded_buffer_test.go +++ b/go/test/endtoend/tabletgateway/buffer/reshard/sharded_buffer_test.go @@ -68,9 +68,8 @@ func reshard02(t *testing.T, clusterInstance *cluster.LocalProcessCluster, keysp err := clusterInstance.StartKeyspace(*keyspace, []string{"-80", "80-"}, 1, false) require.NoError(t, err) workflowName := "buf2buf" - workflow := fmt.Sprintf("%s.%s", keyspaceName, "buf2buf") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "--", "--source_shards", "0", "--target_shards", "-80,80-", "Create", workflow) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "Create", "--target-keyspace", keyspaceName, "--workflow", workflowName, "--source-shards", "0", "--target-shards", "-80,80-") require.NoError(t, err) // Execute the resharding operation @@ -78,13 +77,13 @@ func reshard02(t *testing.T, clusterInstance *cluster.LocalProcessCluster, keysp writes.ExpectQueries(25) waitForLowLag(t, clusterInstance, keyspaceName, workflowName) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "--", "--tablet_types=rdonly,replica", "SwitchTraffic", workflow) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "SwitchTraffic", "--target-keyspace", keyspaceName, "--workflow", workflowName, "--tablet-types=rdonly,replica") require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "--", "--tablet_types=primary", "SwitchTraffic", workflow) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "SwitchTraffic", "--target-keyspace", keyspaceName, "--workflow", workflowName, "--tablet-types=primary") require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Reshard", "Complete", workflow) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Reshard", "--target-keyspace", keyspaceName, "--workflow", workflowName, "Complete") require.NoError(t, err) } diff --git a/go/test/endtoend/tabletmanager/commands_test.go b/go/test/endtoend/tabletmanager/commands_test.go index 1a2d2424cb4..537a3b9d0fc 100644 --- a/go/test/endtoend/tabletmanager/commands_test.go +++ b/go/test/endtoend/tabletmanager/commands_test.go @@ -62,52 +62,52 @@ func TestTabletCommands(t *testing.T) { // make sure direct dba queries work sql := "select * from t1" - result, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ExecuteFetchAsDba", "--", "--json", primaryTablet.Alias, sql) + result, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ExecuteFetchAsDBA", "--json", primaryTablet.Alias, sql) require.Nil(t, err) assertExecuteFetch(t, result) // check Ping / RefreshState / RefreshStateByShard - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Ping", primaryTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("PingTablet", primaryTablet.Alias) require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RefreshState", primaryTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RefreshState", primaryTablet.Alias) require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RefreshStateByShard", keyspaceShard) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RefreshStateByShard", keyspaceShard) require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RefreshStateByShard", "--", "--cells="+cell, keyspaceShard) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RefreshStateByShard", "--cells", cell, keyspaceShard) require.Nil(t, err, "error should be Nil") // Check basic actions. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("SetReadOnly", primaryTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("SetWritable", primaryTablet.Alias, "false") require.Nil(t, err, "error should be Nil") qr := utils.Exec(t, conn, "show variables like 'read_only'") got := fmt.Sprintf("%v", qr.Rows) want := "[[VARCHAR(\"read_only\") VARCHAR(\"ON\")]]" assert.Equal(t, want, got) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("SetReadWrite", primaryTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("SetWritable", primaryTablet.Alias, "true") require.Nil(t, err, "error should be Nil") qr = utils.Exec(t, conn, "show variables like 'read_only'") got = fmt.Sprintf("%v", qr.Rows) want = "[[VARCHAR(\"read_only\") VARCHAR(\"OFF\")]]" assert.Equal(t, want, got) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Validate") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Validate") require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Validate", "--", "--ping-tablets=true") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Validate", "--ping-tablets") require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ValidateKeyspace", keyspaceName) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ValidateKeyspace", keyspaceName) require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ValidateKeyspace", "--", "--ping-tablets=true", keyspaceName) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ValidateKeyspace", "--ping-tablets", keyspaceName) require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ValidateShard", "--", "--ping-tablets=false", keyspaceShard) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ValidateShard", "--ping-tablets", keyspaceShard) require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ValidateShard", "--", "--ping-tablets=true", keyspaceShard) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ValidateShard", "--ping-tablets", keyspaceShard) require.Nil(t, err, "error should be Nil") } @@ -142,14 +142,13 @@ func assertExecuteFetch(t *testing.T, qr string) { // ActionAndTimeout test func TestActionAndTimeout(t *testing.T) { - defer cluster.PanicHandler(t) - err := clusterInstance.VtctlclientProcess.ExecuteCommand("Sleep", primaryTablet.Alias, "5s") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("SleepTablet", primaryTablet.Alias, "5s") require.Nil(t, err) time.Sleep(1 * time.Second) // try a frontend RefreshState that should timeout as the tablet is busy running the other one - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RefreshState", "--", primaryTablet.Alias, "--wait-time", "2s") + err = clusterInstance.VtctlclientProcess.ExecuteCommand("RefreshState", primaryTablet.Alias, "--wait_timeout", "2s") assert.Error(t, err, "timeout as tablet is in Sleep") } @@ -207,14 +206,14 @@ func TestShardReplicationFix(t *testing.T) { assertNodeCount(t, result, int(3)) // Manually add a bogus entry to the replication graph, and check it is removed by ShardReplicationFix - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ShardReplicationAdd", keyspaceShard, fmt.Sprintf("%s-9000", cell)) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ShardReplicationAdd", keyspaceShard, fmt.Sprintf("%s-9000", cell)) require.Nil(t, err, "error should be Nil") result, err = clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetShardReplication", cell, keyspaceShard) require.Nil(t, err, "error should be Nil") assertNodeCount(t, result, int(4)) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ShardReplicationFix", cell, keyspaceShard) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ShardReplicationFix", cell, keyspaceShard) require.Nil(t, err, "error should be Nil") result, err = clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetShardReplication", cell, keyspaceShard) require.Nil(t, err, "error should be Nil") @@ -224,7 +223,7 @@ func TestShardReplicationFix(t *testing.T) { func TestGetSchema(t *testing.T) { defer cluster.PanicHandler(t) - res, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetSchema", "--", + res, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("GetSchema", "--include-views", "--tables", "t1,v1", fmt.Sprintf("%s-%d", clusterInstance.Cell, primaryTablet.TabletUID)) require.Nil(t, err) diff --git a/go/test/endtoend/tabletmanager/custom_rule_topo_test.go b/go/test/endtoend/tabletmanager/custom_rule_topo_test.go index aa09a99e0fe..0c6e056af36 100644 --- a/go/test/endtoend/tabletmanager/custom_rule_topo_test.go +++ b/go/test/endtoend/tabletmanager/custom_rule_topo_test.go @@ -74,7 +74,7 @@ func TestTopoCustomRule(t *testing.T) { err = clusterInstance.StartVttablet(rTablet, false, "SERVING", false, cell, keyspaceName, hostname, shardName) require.Nil(t, err, "error should be Nil") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Validate") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Validate") require.Nil(t, err, "error should be Nil") // And wait until the query is working. diff --git a/go/test/endtoend/tabletmanager/primary/tablet_test.go b/go/test/endtoend/tabletmanager/primary/tablet_test.go index f6255b1f71a..297e5540fac 100644 --- a/go/test/endtoend/tabletmanager/primary/tablet_test.go +++ b/go/test/endtoend/tabletmanager/primary/tablet_test.go @@ -26,7 +26,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "vitess.io/vitess/go/json2" "vitess.io/vitess/go/test/endtoend/cluster" topodatapb "vitess.io/vitess/go/vt/proto/topodata" @@ -121,16 +120,16 @@ func TestRepeatedInitShardPrimary(t *testing.T) { // Test that using InitShardPrimary can go back and forth between 2 hosts. // Make replica tablet as primary - err := clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shardName, cell, replicaTablet.TabletUID) + err := clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shardName, cell, replicaTablet.TabletUID) require.NoError(t, err) // Run health check on both, make sure they are both healthy. // Also make sure the types are correct. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", primaryTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", primaryTablet.Alias) require.NoError(t, err) checkHealth(t, primaryTablet.HTTPPort, false) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", replicaTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", replicaTablet.Alias) require.NoError(t, err) checkHealth(t, replicaTablet.HTTPPort, false) @@ -138,16 +137,16 @@ func TestRepeatedInitShardPrimary(t *testing.T) { checkTabletType(t, replicaTablet.Alias, "PRIMARY") // Come back to the original tablet. - err = clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shardName, cell, primaryTablet.TabletUID) + err = clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shardName, cell, primaryTablet.TabletUID) require.NoError(t, err) // Run health check on both, make sure they are both healthy. // Also make sure the types are correct. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", primaryTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", primaryTablet.Alias) require.NoError(t, err) checkHealth(t, primaryTablet.HTTPPort, false) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", replicaTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", replicaTablet.Alias) require.NoError(t, err) checkHealth(t, replicaTablet.HTTPPort, false) @@ -162,7 +161,7 @@ func TestPrimaryRestartSetsPTSTimestamp(t *testing.T) { // See StreamHealthResponse.primary_term_start_timestamp for details. // Make replica as primary - err := clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shardName, cell, replicaTablet.TabletUID) + err := clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shardName, cell, replicaTablet.TabletUID) require.NoError(t, err) err = replicaTablet.VttabletProcess.WaitForTabletStatus("SERVING") @@ -212,7 +211,7 @@ func TestPrimaryRestartSetsPTSTimestamp(t *testing.T) { streamHealthRes2.GetPrimaryTermStartTimestamp())) // Reset primary - err = clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shardName, cell, primaryTablet.TabletUID) + err = clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shardName, cell, primaryTablet.TabletUID) require.NoError(t, err) err = primaryTablet.VttabletProcess.WaitForTabletStatus("SERVING") require.NoError(t, err) @@ -232,11 +231,7 @@ func checkHealth(t *testing.T, port int, shouldError bool) { } func checkTabletType(t *testing.T, tabletAlias string, typeWant string) { - result, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetTablet", tabletAlias) - require.NoError(t, err) - - var tablet topodatapb.Tablet - err = json2.Unmarshal([]byte(result), &tablet) + tablet, err := clusterInstance.VtctldClientProcess.GetTablet(tabletAlias) require.NoError(t, err) actualType := tablet.GetType() diff --git a/go/test/endtoend/tabletmanager/tablet_health_test.go b/go/test/endtoend/tabletmanager/tablet_health_test.go index 7dc4bcd97d2..c8eb43b682f 100644 --- a/go/test/endtoend/tabletmanager/tablet_health_test.go +++ b/go/test/endtoend/tabletmanager/tablet_health_test.go @@ -30,7 +30,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "vitess.io/vitess/go/json2" "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/test/endtoend/cluster" "vitess.io/vitess/go/test/endtoend/utils" @@ -85,7 +84,7 @@ func TestTabletReshuffle(t *testing.T) { require.NoError(t, err) assertExcludeFields(t, string(result)) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Backup", rTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("Backup", rTablet.Alias) assert.Error(t, err, "cannot perform backup without my.cnf") killTablets(rTablet) @@ -114,7 +113,7 @@ func TestHealthCheck(t *testing.T) { require.NoError(t, err) defer conn.Close() - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", rTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", rTablet.Alias) require.NoError(t, err) checkHealth(t, rTablet.HTTPPort, false) @@ -123,9 +122,9 @@ func TestHealthCheck(t *testing.T) { utils.Exec(t, conn, "stop slave") // stop replication, make sure we don't go unhealthy. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", rTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", rTablet.Alias) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", rTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", rTablet.Alias) require.NoError(t, err) // make sure the health stream is updated @@ -136,9 +135,9 @@ func TestHealthCheck(t *testing.T) { } // then restart replication, make sure we stay healthy - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", rTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", rTablet.Alias) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", rTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", rTablet.Alias) require.NoError(t, err) checkHealth(t, rTablet.HTTPPort, false) @@ -173,16 +172,16 @@ func TestHealthCheck(t *testing.T) { // On a MySQL restart, it comes up as a read-only tablet (check default.cnf file). // We have to explicitly set it to read-write otherwise heartbeat writer is unable // to write the heartbeats - err = clusterInstance.VtctlclientProcess.ExecuteCommand("SetReadWrite", primaryTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("SetWritable", primaryTablet.Alias, "true") require.NoError(t, err) // explicitly start replication on all of the replicas to avoid any test flakiness as they were all // replicating from the primary instance - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", rTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", rTablet.Alias) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", replicaTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", replicaTablet.Alias) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", rdonlyTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", rdonlyTablet.Alias) require.NoError(t, err) time.Sleep(tabletHealthcheckRefreshInterval) @@ -348,11 +347,7 @@ func checkHealth(t *testing.T, port int, shouldError bool) { } func checkTabletType(t *testing.T, tabletAlias string, typeWant string) { - result, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetTablet", tabletAlias) - require.NoError(t, err) - - var tablet topodatapb.Tablet - err = json2.Unmarshal([]byte(result), &tablet) + tablet, err := clusterInstance.VtctldClientProcess.GetTablet(tabletAlias) require.NoError(t, err) actualType := tablet.GetType() @@ -398,16 +393,16 @@ func TestHealthCheckDrainedStateDoesNotShutdownQueryService(t *testing.T) { // Change from rdonly to drained and stop replication. The tablet will stay // healthy, and the query service is still running. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "drained") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "drained") require.NoError(t, err) // Trying to drain the same tablet again, should error - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "drained") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "drained") assert.Error(t, err, "already drained") - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", rdonlyTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", rdonlyTablet.Alias) require.NoError(t, err) // Trigger healthcheck explicitly to avoid waiting for the next interval. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", rdonlyTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", rdonlyTablet.Alias) require.NoError(t, err) checkTabletType(t, rdonlyTablet.Alias, "DRAINED") @@ -417,11 +412,11 @@ func TestHealthCheckDrainedStateDoesNotShutdownQueryService(t *testing.T) { require.NoError(t, err) // Restart replication. Tablet will become healthy again. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "rdonly") require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", rdonlyTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", rdonlyTablet.Alias) require.NoError(t, err) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", rdonlyTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", rdonlyTablet.Alias) require.NoError(t, err) checkHealth(t, rdonlyTablet.HTTPPort, false) } @@ -434,7 +429,7 @@ func killTablets(tablets ...*cluster.Vttablet) { defer wg.Done() _ = tablet.VttabletProcess.TearDown() _ = tablet.MysqlctlProcess.Stop() - _ = clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", tablet.Alias) + _ = clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", tablet.Alias) }(tablet) } wg.Wait() diff --git a/go/test/endtoend/tabletmanager/tablet_test.go b/go/test/endtoend/tabletmanager/tablet_test.go index 6212b4a418b..830502268d1 100644 --- a/go/test/endtoend/tabletmanager/tablet_test.go +++ b/go/test/endtoend/tabletmanager/tablet_test.go @@ -47,7 +47,7 @@ func TestEnsureDB(t *testing.T) { require.NoError(t, err) // Make it the primary. - err = clusterInstance.VtctlclientProcess.ExecuteCommand("TabletExternallyReparented", tablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("TabletExternallyReparented", tablet.Alias) require.EqualError(t, err, "exit status 1") // It is still NOT_SERVING because the db is read-only. @@ -56,8 +56,8 @@ func TestEnsureDB(t *testing.T) { assert.Contains(t, status, "read-only") // Switch to read-write and verify that we go serving. - // Note: for TabletExternallyReparented, we expect SetReadWrite to be called by the user - err = clusterInstance.VtctlclientProcess.ExecuteCommand("SetReadWrite", tablet.Alias) + // Note: for TabletExternallyReparented, we expect SetWritable to be called by the user + err = clusterInstance.VtctldClientProcess.ExecuteCommand("SetWritable", tablet.Alias, "true") require.NoError(t, err) err = tablet.VttabletProcess.WaitForTabletStatus("SERVING") require.NoError(t, err) diff --git a/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go b/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go index 7c0f05bdcc2..9824f28ae2b 100644 --- a/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go +++ b/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go @@ -370,7 +370,7 @@ func TestLag(t *testing.T) { defer clusterInstance.EnableVTOrcRecoveries(t) t.Run("stopping replication", func(t *testing.T) { - err := clusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", replicaTablet.Alias) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", replicaTablet.Alias) assert.NoError(t, err) }) t.Run("accumulating lag, expecting throttler push back", func(t *testing.T) { @@ -415,7 +415,7 @@ func TestLag(t *testing.T) { }) t.Run("starting replication", func(t *testing.T) { - err := clusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", replicaTablet.Alias) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", replicaTablet.Alias) assert.NoError(t, err) }) t.Run("expecting replication to catch up and throttler check to return OK", func(t *testing.T) { @@ -439,7 +439,7 @@ func TestLag(t *testing.T) { func TestNoReplicas(t *testing.T) { defer cluster.PanicHandler(t) t.Run("changing replica to RDONLY", func(t *testing.T) { - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "RDONLY") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "RDONLY") assert.NoError(t, err) // This makes no REPLICA servers available. We expect something like: @@ -447,7 +447,7 @@ func TestNoReplicas(t *testing.T) { waitForThrottleCheckStatus(t, primaryTablet, http.StatusOK) }) t.Run("restoring to REPLICA", func(t *testing.T) { - err := clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "REPLICA") + err := clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "REPLICA") assert.NoError(t, err) waitForThrottleCheckStatus(t, primaryTablet, http.StatusOK) diff --git a/go/test/endtoend/topoconncache/main_test.go b/go/test/endtoend/topoconncache/main_test.go index 4c17481ec84..26eb3918a0b 100644 --- a/go/test/endtoend/topoconncache/main_test.go +++ b/go/test/endtoend/topoconncache/main_test.go @@ -193,14 +193,14 @@ func TestMain(m *testing.M) { return 1, err } } - if err := clusterInstance.VtctlclientProcess.InitializeShard(keyspaceName, shard1.Name, shard1Primary.Cell, shard1Primary.TabletUID); err != nil { + if err := clusterInstance.VtctldClientProcess.InitializeShard(keyspaceName, shard1.Name, shard1Primary.Cell, shard1Primary.TabletUID); err != nil { return 1, err } // run a health check on source replica so it responds to discovery // (for binlog players) and on the source rdonlys (for workers) for _, tablet := range []string{shard1Replica.Alias, shard1Rdonly.Alias} { - if err := clusterInstance.VtctlclientProcess.ExecuteCommand("RunHealthCheck", tablet); err != nil { + if err := clusterInstance.VtctldClientProcess.ExecuteCommand("RunHealthCheck", tablet); err != nil { return 1, err } } @@ -211,7 +211,7 @@ func TestMain(m *testing.M) { } } - if err := clusterInstance.VtctlclientProcess.InitializeShard(keyspaceName, shard2.Name, shard2Primary.Cell, shard2Primary.TabletUID); err != nil { + if err := clusterInstance.VtctldClientProcess.InitializeShard(keyspaceName, shard2.Name, shard2Primary.Cell, shard2Primary.TabletUID); err != nil { return 1, err } @@ -219,14 +219,14 @@ func TestMain(m *testing.M) { return 1, err } - if err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, fmt.Sprintf(sqlSchema, tableName)); err != nil { + if err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, fmt.Sprintf(sqlSchema, tableName)); err != nil { return 1, err } - if err := clusterInstance.VtctlclientProcess.ApplyVSchema(keyspaceName, fmt.Sprintf(vSchema, tableName)); err != nil { + if err := clusterInstance.VtctldClientProcess.ApplyVSchema(keyspaceName, fmt.Sprintf(vSchema, tableName)); err != nil { return 1, err } - _ = clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) + _ = clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildKeyspaceGraph", keyspaceName) return m.Run(), nil }() diff --git a/go/test/endtoend/topoconncache/topo_conn_cache_test.go b/go/test/endtoend/topoconncache/topo_conn_cache_test.go index 504ca218047..4ffcc309e29 100644 --- a/go/test/endtoend/topoconncache/topo_conn_cache_test.go +++ b/go/test/endtoend/topoconncache/topo_conn_cache_test.go @@ -74,7 +74,7 @@ func deleteCell(t *testing.T) { deleteTablet(t, shard2Rdonly) // Delete cell2 info from topo - res, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("DeleteCellInfo", "--", "--force", cell2) + res, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("DeleteCellInfo", "--force", cell2) t.Log(res) require.NoError(t, err) @@ -111,7 +111,7 @@ func deleteTablet(t *testing.T, tablet *cluster.Vttablet) { }(tablet) wg.Wait() - err := clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", tablet.Alias) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", tablet.Alias) require.NoError(t, err) } diff --git a/go/test/endtoend/vault/vault_test.go b/go/test/endtoend/vault/vault_test.go index 684a374707d..f8e19c07a0c 100644 --- a/go/test/endtoend/vault/vault_test.go +++ b/go/test/endtoend/vault/vault_test.go @@ -283,7 +283,7 @@ func initializeClusterLate(t *testing.T) { tablet.MysqlctlProcess.ExtraArgs = append(tablet.MysqlctlProcess.ExtraArgs, mysqlctlArg...) } - err = clusterInstance.VtctlclientProcess.InitShardPrimary(keyspaceName, shard.Name, cell, primary.TabletUID) + err = clusterInstance.VtctldClientProcess.InitShardPrimary(keyspaceName, shard.Name, cell, primary.TabletUID) require.NoError(t, err) err = clusterInstance.StartVTOrc(keyspaceName) diff --git a/go/test/endtoend/versionupgrade/upgrade_test.go b/go/test/endtoend/versionupgrade/upgrade_test.go index 87f7f9e8675..181b5dfc9ad 100644 --- a/go/test/endtoend/versionupgrade/upgrade_test.go +++ b/go/test/endtoend/versionupgrade/upgrade_test.go @@ -148,7 +148,7 @@ func TestDeploySchema(t *testing.T) { { sqlQuery := fmt.Sprintf(createTable, tableName) - result, err := clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, sqlQuery, cluster.VtctlClientParams{DDLStrategy: ""}) + result, err := clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, sqlQuery, cluster.ApplySchemaParams{DDLStrategy: ""}) require.Nil(t, err, result) } for i := range clusterInstance.Keyspaces[0].Shards { diff --git a/go/test/endtoend/vtgate/createdb_plugin/main_test.go b/go/test/endtoend/vtgate/createdb_plugin/main_test.go index e712fee7b36..5bfec3890b5 100644 --- a/go/test/endtoend/vtgate/createdb_plugin/main_test.go +++ b/go/test/endtoend/vtgate/createdb_plugin/main_test.go @@ -164,8 +164,8 @@ func shutdown(t *testing.T, ksName string) { } require.NoError(t, - clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteKeyspace", "--", "--recursive", ksName)) + clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteKeyspace", "--recursive", ksName)) require.NoError(t, - clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildVSchemaGraph")) + clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildVSchemaGraph")) } diff --git a/go/test/endtoend/vtgate/foreignkey/main_test.go b/go/test/endtoend/vtgate/foreignkey/main_test.go index 483c1d05e80..63590df9247 100644 --- a/go/test/endtoend/vtgate/foreignkey/main_test.go +++ b/go/test/endtoend/vtgate/foreignkey/main_test.go @@ -139,7 +139,7 @@ func TestMain(m *testing.M) { return 1 } - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildVSchemaGraph") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildVSchemaGraph") if err != nil { return 1 } diff --git a/go/test/endtoend/vtgate/foreignkey/stress/fk_stress_test.go b/go/test/endtoend/vtgate/foreignkey/stress/fk_stress_test.go index 60eff73b820..341db836fd8 100644 --- a/go/test/endtoend/vtgate/foreignkey/stress/fk_stress_test.go +++ b/go/test/endtoend/vtgate/foreignkey/stress/fk_stress_test.go @@ -597,7 +597,7 @@ func ExecuteFKTest(t *testing.T, tcase *testCase) { artifacts := textutil.SplitDelimitedList(row.AsString("artifacts", "")) for _, artifact := range artifacts { t.Run(artifact, func(t *testing.T) { - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, "drop table if exists "+artifact) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, "drop table if exists "+artifact) require.NoError(t, err) }) } @@ -781,7 +781,7 @@ func createInitialSchema(t *testing.T, tcase *testCase) { t.Run("dropping tables", func(t *testing.T) { for _, tableName := range reverseTableNames { - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, "drop table if exists "+tableName) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, "drop table if exists "+tableName) require.NoError(t, err) } }) @@ -808,7 +808,7 @@ func createInitialSchema(t *testing.T, tcase *testCase) { } b.WriteString(";") } - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, b.String()) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, b.String()) require.NoError(t, err) }) if tcase.preStatement != "" { @@ -862,7 +862,7 @@ func testOnlineDDLStatement(t *testing.T, alterStatement string, ddlStrategy str } } else { var err error - uuid, err = clusterInstance.VtctlclientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.VtctlClientParams{DDLStrategy: ddlStrategy}) + uuid, err = clusterInstance.VtctldClientProcess.ApplySchemaWithOutput(keyspaceName, alterStatement, cluster.ApplySchemaParams{DDLStrategy: ddlStrategy}) assert.NoError(t, err) } uuid = strings.TrimSpace(uuid) diff --git a/go/test/endtoend/vtgate/gen4/main_test.go b/go/test/endtoend/vtgate/gen4/main_test.go index 378b2d2969e..4c94e8e2ec8 100644 --- a/go/test/endtoend/vtgate/gen4/main_test.go +++ b/go/test/endtoend/vtgate/gen4/main_test.go @@ -102,12 +102,12 @@ func TestMain(m *testing.M) { } // apply routing rules - err = clusterInstance.VtctlclientProcess.ApplyRoutingRules(routingRules) + err = clusterInstance.VtctldClientProcess.ApplyRoutingRules(routingRules) if err != nil { return 1 } - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildVSchemaGraph") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildVSchemaGraph") if err != nil { return 1 } diff --git a/go/test/endtoend/vtgate/main_test.go b/go/test/endtoend/vtgate/main_test.go index 12abcf4dd01..b276508f269 100644 --- a/go/test/endtoend/vtgate/main_test.go +++ b/go/test/endtoend/vtgate/main_test.go @@ -79,12 +79,12 @@ func TestMain(m *testing.M) { return 1 } - err = clusterInstance.VtctlclientProcess.ApplyRoutingRules(routingRules) + err = clusterInstance.VtctldClientProcess.ApplyRoutingRules(routingRules) if err != nil { return 1 } - _, err = clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("RebuildVSchemaGraph") + _, err = clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("RebuildVSchemaGraph") if err != nil { return 1 } diff --git a/go/test/endtoend/vtgate/queries/informationschema/main_test.go b/go/test/endtoend/vtgate/queries/informationschema/main_test.go index 06c5b188d18..3696617281e 100644 --- a/go/test/endtoend/vtgate/queries/informationschema/main_test.go +++ b/go/test/endtoend/vtgate/queries/informationschema/main_test.go @@ -78,12 +78,12 @@ func TestMain(m *testing.M) { return 1 } - err = clusterInstance.VtctlclientProcess.ApplyRoutingRules(routingRules) + err = clusterInstance.VtctldClientProcess.ApplyRoutingRules(routingRules) if err != nil { return 1 } - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildVSchemaGraph") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildVSchemaGraph") if err != nil { return 1 } diff --git a/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go b/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go index c385941502a..9486dc194ff 100644 --- a/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go +++ b/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go @@ -74,7 +74,7 @@ func TestMain(m *testing.M) { return 1 } - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RebuildVSchemaGraph") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("RebuildVSchemaGraph") if err != nil { return 1 } diff --git a/go/test/endtoend/vtgate/reservedconn/reconnect1/main_test.go b/go/test/endtoend/vtgate/reservedconn/reconnect1/main_test.go index 11325a0f2f8..491ce6bc6ab 100644 --- a/go/test/endtoend/vtgate/reservedconn/reconnect1/main_test.go +++ b/go/test/endtoend/vtgate/reservedconn/reconnect1/main_test.go @@ -133,7 +133,7 @@ func TestServingChange(t *testing.T) { // changing rdonly tablet to spare (non serving). rdonlyTablet := clusterInstance.Keyspaces[0].Shards[0].Rdonly() - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "replica") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "replica") require.NoError(t, err) rdonlyTablet.Type = "replica" @@ -143,12 +143,12 @@ func TestServingChange(t *testing.T) { // changing replica tablet to rdonly to make rdonly available for serving. replicaTablet := clusterInstance.Keyspaces[0].Shards[0].Replica() - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "rdonly") require.NoError(t, err) replicaTablet.Type = "rdonly" // to see/make the new rdonly available - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Ping", replicaTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("PingTablet", replicaTablet.Alias) require.NoError(t, err) // this should pass now as there is rdonly present @@ -174,7 +174,7 @@ func TestServingChangeStreaming(t *testing.T) { // changing rdonly tablet to spare (non serving). rdonlyTablet := clusterInstance.Keyspaces[0].Shards[0].Rdonly() - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "replica") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", rdonlyTablet.Alias, "replica") require.NoError(t, err) rdonlyTablet.Type = "replica" @@ -192,12 +192,12 @@ func TestServingChangeStreaming(t *testing.T) { // changing replica tablet to rdonly to make rdonly available for serving. replicaTablet := clusterInstance.Keyspaces[0].Shards[0].Replica() - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "rdonly") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ChangeTabletType", replicaTablet.Alias, "rdonly") require.NoError(t, err) replicaTablet.Type = "rdonly" // to see/make the new rdonly available - err = clusterInstance.VtctlclientProcess.ExecuteCommand("Ping", replicaTablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("PingTablet", replicaTablet.Alias) require.NoError(t, err) // this should pass now as there is rdonly present diff --git a/go/test/endtoend/vtgate/reservedconn/reconnect2/main_test.go b/go/test/endtoend/vtgate/reservedconn/reconnect2/main_test.go index b66bb15dbd5..a448574c282 100644 --- a/go/test/endtoend/vtgate/reservedconn/reconnect2/main_test.go +++ b/go/test/endtoend/vtgate/reservedconn/reconnect2/main_test.go @@ -129,7 +129,7 @@ func TestTabletChange(t *testing.T) { utils.Exec(t, conn, "select * from test") // Change Primary - err = clusterInstance.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", "--keyspace_shard", fmt.Sprintf("%s/%s", keyspaceName, "-80")) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", fmt.Sprintf("%s/%s", keyspaceName, "-80")) require.NoError(t, err) // this should pass as there is a new primary tablet and is serving. @@ -150,7 +150,7 @@ func TestTabletChangeStreaming(t *testing.T) { utils.Exec(t, conn, "select * from test") // Change Primary - err = clusterInstance.VtctlclientProcess.ExecuteCommand("PlannedReparentShard", "--", "--keyspace_shard", fmt.Sprintf("%s/%s", keyspaceName, "-80")) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("PlannedReparentShard", fmt.Sprintf("%s/%s", keyspaceName, "-80")) require.NoError(t, err) // this should pass as there is a new primary tablet and is serving. diff --git a/go/test/endtoend/vtgate/reservedconn/reconnect3/main_test.go b/go/test/endtoend/vtgate/reservedconn/reconnect3/main_test.go index 25af85acc00..677c24666b2 100644 --- a/go/test/endtoend/vtgate/reservedconn/reconnect3/main_test.go +++ b/go/test/endtoend/vtgate/reservedconn/reconnect3/main_test.go @@ -102,7 +102,7 @@ func TestMysqlDownServingChange(t *testing.T) { require.NoError(t, primaryTablet.MysqlctlProcess.Stop()) require.NoError(t, - clusterInstance.VtctlclientProcess.ExecuteCommand("EmergencyReparentShard", "--", "--keyspace_shard", "ks/0")) + clusterInstance.VtctldClientProcess.ExecuteCommand("EmergencyReparentShard", "ks/0")) // This should work without any error. _ = utils.Exec(t, conn, "select /*vt+ PLANNER=gen4 */ * from test") diff --git a/go/test/endtoend/vtgate/reservedconn/reconnect4/main_test.go b/go/test/endtoend/vtgate/reservedconn/reconnect4/main_test.go index 28367cd597a..1dc53a89506 100644 --- a/go/test/endtoend/vtgate/reservedconn/reconnect4/main_test.go +++ b/go/test/endtoend/vtgate/reservedconn/reconnect4/main_test.go @@ -104,7 +104,7 @@ func TestVttabletDownServingChange(t *testing.T) { // kill vttablet process _ = primaryTablet.VttabletProcess.TearDown() require.NoError(t, - clusterInstance.VtctlclientProcess.ExecuteCommand("EmergencyReparentShard", "--", "--keyspace_shard", "ks/0")) + clusterInstance.VtctldClientProcess.ExecuteCommand("EmergencyReparentShard", "ks/0")) // This should work without any error. _ = utils.Exec(t, conn, "select /*vt+ PLANNER=gen4 */ * from test") diff --git a/go/test/endtoend/vtgate/schema/schema_test.go b/go/test/endtoend/vtgate/schema/schema_test.go index 04d91d8d978..14b6c13034e 100644 --- a/go/test/endtoend/vtgate/schema/schema_test.go +++ b/go/test/endtoend/vtgate/schema/schema_test.go @@ -120,7 +120,7 @@ func testWithInitialSchema(t *testing.T) { var sqlQuery = "" // nolint for i := 0; i < totalTableCount; i++ { sqlQuery = fmt.Sprintf(createTable, fmt.Sprintf("vt_select_test_%02d", i)) - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, sqlQuery) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, sqlQuery) require.Nil(t, err) } @@ -135,7 +135,7 @@ func testWithInitialSchema(t *testing.T) { // testWithAlterSchema if we alter schema and then apply, the resultant schema should match across shards func testWithAlterSchema(t *testing.T) { sqlQuery := fmt.Sprintf(alterTable, fmt.Sprintf("vt_select_test_%02d", 3), "msg") - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, sqlQuery) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, sqlQuery) require.Nil(t, err) matchSchema(t, clusterInstance.Keyspaces[0].Shards[0].Vttablets[0].VttabletProcess.TabletPath, clusterInstance.Keyspaces[0].Shards[1].Vttablets[0].VttabletProcess.TabletPath) } @@ -143,7 +143,7 @@ func testWithAlterSchema(t *testing.T) { // testWithAlterDatabase tests that ALTER DATABASE is accepted by the validator. func testWithAlterDatabase(t *testing.T) { sql := "create database alter_database_test; alter database alter_database_test default character set = utf8mb4; drop database alter_database_test" - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, sql) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, sql) assert.NoError(t, err) } @@ -157,7 +157,7 @@ func testWithAlterDatabase(t *testing.T) { // See: https://github.com/vitessio/vitess/issues/1731#issuecomment-222914389 func testWithDropCreateSchema(t *testing.T) { dropCreateTable := fmt.Sprintf("DROP TABLE vt_select_test_%02d ;", 2) + fmt.Sprintf(createTable, fmt.Sprintf("vt_select_test_%02d", 2)) - err := clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, dropCreateTable) + err := clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, dropCreateTable) require.NoError(t, err) checkTables(t, totalTableCount) } @@ -186,10 +186,10 @@ func testWithAutoSchemaFromChangeDir(t *testing.T) { // matchSchema schema for supplied tablets should match func matchSchema(t *testing.T, firstTablet string, secondTablet string) { - firstShardSchema, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetSchema", firstTablet) + firstShardSchema, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("GetSchema", firstTablet) require.Nil(t, err) - secondShardSchema, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetSchema", secondTablet) + secondShardSchema, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("GetSchema", secondTablet) require.Nil(t, err) assert.Equal(t, firstShardSchema, secondShardSchema) @@ -203,12 +203,12 @@ func matchSchema(t *testing.T, firstTablet string, secondTablet string) { // is the MySQL behavior the user expects. func testDropNonExistentTables(t *testing.T) { dropNonExistentTable := "DROP TABLE nonexistent_table;" - output, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ApplySchema", "--", "--sql", dropNonExistentTable, keyspaceName) + output, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ApplySchema", "--sql", dropNonExistentTable, keyspaceName) require.Error(t, err) assert.True(t, strings.Contains(output, "Unknown table")) dropIfExists := "DROP TABLE IF EXISTS nonexistent_table;" - err = clusterInstance.VtctlclientProcess.ApplySchema(keyspaceName, dropIfExists) + err = clusterInstance.VtctldClientProcess.ApplySchema(keyspaceName, dropIfExists) require.Nil(t, err) checkTables(t, totalTableCount) @@ -219,7 +219,7 @@ func testDropNonExistentTables(t *testing.T) { func testCreateInvalidView(t *testing.T) { for _, ddlStrategy := range []string{"direct", "direct -allow-zero-in-date"} { createInvalidView := "CREATE OR REPLACE VIEW invalid_view AS SELECT * FROM nonexistent_table;" - output, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ApplySchema", "--", "--ddl_strategy", ddlStrategy, "--sql", createInvalidView, keyspaceName) + output, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ApplySchema", "--ddl-strategy", ddlStrategy, "--sql", createInvalidView, keyspaceName) require.Error(t, err) assert.Contains(t, output, "doesn't exist (errno 1146)") } @@ -228,25 +228,25 @@ func testCreateInvalidView(t *testing.T) { func testApplySchemaBatch(t *testing.T) { { sqls := "create table batch1(id int primary key);create table batch2(id int primary key);create table batch3(id int primary key);create table batch4(id int primary key);create table batch5(id int primary key);" - _, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ApplySchema", "--", "--sql", sqls, "--batch_size", "2", keyspaceName) + _, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ApplySchema", "--sql", sqls, "--batch-size", "2", keyspaceName) require.NoError(t, err) checkTables(t, totalTableCount+5) } { sqls := "drop table batch1; drop table batch2; drop table batch3; drop table batch4; drop table batch5" - _, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ApplySchema", "--", "--sql", sqls, keyspaceName) + _, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ApplySchema", "--sql", sqls, keyspaceName) require.NoError(t, err) checkTables(t, totalTableCount) } { sqls := "create table batch1(id int primary key);create table batch2(id int primary key);create table batch3(id int primary key);create table batch4(id int primary key);create table batch5(id int primary key);" - _, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ApplySchema", "--", "--ddl_strategy", "direct --allow-zero-in-date", "--sql", sqls, "--batch_size", "2", keyspaceName) + _, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ApplySchema", "--ddl-strategy", "direct --allow-zero-in-date", "--sql", sqls, "--batch-size", "2", keyspaceName) require.NoError(t, err) checkTables(t, totalTableCount+5) } { sqls := "drop table batch1; drop table batch2; drop table batch3; drop table batch4; drop table batch5" - _, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("ApplySchema", "--", "--sql", sqls, keyspaceName) + _, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ApplySchema", "--sql", sqls, keyspaceName) require.NoError(t, err) checkTables(t, totalTableCount) } @@ -291,7 +291,7 @@ func testCopySchemaShardWithDifferentDB(t *testing.T, shard int) { source := fmt.Sprintf("%s/0", keyspaceName) tabletAlias := clusterInstance.Keyspaces[0].Shards[shard].Vttablets[0].VttabletProcess.TabletPath - schema, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetSchema", tabletAlias) + schema, err := clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("GetSchema", tabletAlias) require.Nil(t, err) resultMap := make(map[string]any) @@ -305,7 +305,7 @@ func testCopySchemaShardWithDifferentDB(t *testing.T, shard int) { // (The different charset won't be corrected on the destination shard // because we use "CREATE DATABASE IF NOT EXISTS" and this doesn't fail if // there are differences in the options e.g. the character set.) - err = clusterInstance.VtctlclientProcess.ExecuteCommand("ExecuteFetchAsDba", "--", "--json", tabletAlias, "ALTER DATABASE vt_ks CHARACTER SET latin1") + err = clusterInstance.VtctldClientProcess.ExecuteCommand("ExecuteFetchAsDBA", "--json", tabletAlias, "ALTER DATABASE vt_ks CHARACTER SET latin1") require.Nil(t, err) output, err := clusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("CopySchemaShard", source, fmt.Sprintf("%s/%d", keyspaceName, shard)) diff --git a/go/test/endtoend/vtgate/schematracker/sharded_prs/st_sharded_test.go b/go/test/endtoend/vtgate/schematracker/sharded_prs/st_sharded_test.go index 6ff8e69bb52..09bd97eb9fe 100644 --- a/go/test/endtoend/vtgate/schematracker/sharded_prs/st_sharded_test.go +++ b/go/test/endtoend/vtgate/schematracker/sharded_prs/st_sharded_test.go @@ -181,7 +181,7 @@ func TestMain(m *testing.M) { // This is supposed to change the primary tablet in the shards, meaning that a different tablet // will be responsible for sending schema tracking updates. for _, shard := range clusterInstance.Keyspaces[0].Shards { - err := clusterInstance.VtctlclientProcess.InitializeShard(KeyspaceName, shard.Name, Cell, shard.Vttablets[1].TabletUID) + err := clusterInstance.VtctldClientProcess.InitializeShard(KeyspaceName, shard.Name, Cell, shard.Vttablets[1].TabletUID) if err != nil { fmt.Println(err) return 1 diff --git a/go/test/endtoend/vtgate/tablet_healthcheck/reparent_test.go b/go/test/endtoend/vtgate/tablet_healthcheck/reparent_test.go index dbc46bdda77..d6357ce8f2a 100644 --- a/go/test/endtoend/vtgate/tablet_healthcheck/reparent_test.go +++ b/go/test/endtoend/vtgate/tablet_healthcheck/reparent_test.go @@ -145,11 +145,11 @@ func TestHealthCheckExternallyReparentNewTablet(t *testing.T) { tablet := addTablet(t, reparentTabletUID, reparentTabletType) // promote the new tablet to the primary - err = clusterInstance.VtctlclientProcess.ExecuteCommand("TabletExternallyReparented", tablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("TabletExternallyReparented", tablet.Alias) require.NoError(t, err) // update the new primary tablet to be read-write - err = clusterInstance.VtctlclientProcess.ExecuteCommand("SetReadWrite", tablet.Alias) + err = clusterInstance.VtctldClientProcess.ExecuteCommand("SetWritable", tablet.Alias, "true") require.NoError(t, err) // wait for the vtgate to finish updating the new primary tablet @@ -236,7 +236,7 @@ func deleteTablet(t *testing.T, tablet *cluster.Vttablet) { }(tablet) wg.Wait() - err := clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", tablet.Alias) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", tablet.Alias) require.NoError(t, err) t.Logf("Deleted tablet: %s", tablet.Alias) diff --git a/go/test/endtoend/vtgate/tablet_healthcheck_cache/correctness_test.go b/go/test/endtoend/vtgate/tablet_healthcheck_cache/correctness_test.go index 9386c307a12..50529d9fdf9 100644 --- a/go/test/endtoend/vtgate/tablet_healthcheck_cache/correctness_test.go +++ b/go/test/endtoend/vtgate/tablet_healthcheck_cache/correctness_test.go @@ -234,7 +234,7 @@ func deleteTablet(t *testing.T, tablet *cluster.Vttablet) { }(tablet) wg.Wait() - err := clusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", tablet.Alias) + err := clusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", tablet.Alias) require.Nil(t, err) t.Logf("Deleted tablet: %s", tablet.Alias) diff --git a/go/test/endtoend/vtorc/api/api_test.go b/go/test/endtoend/vtorc/api/api_test.go index 7dd5c50eefa..7b277fd7a0f 100644 --- a/go/test/endtoend/vtorc/api/api_test.go +++ b/go/test/endtoend/vtorc/api/api_test.go @@ -106,7 +106,7 @@ func TestAPIEndpoints(t *testing.T) { t.Run("Replication Analysis API", func(t *testing.T) { // use vtctlclient to stop replication - _, err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("StopReplication", replica.Alias) + _, err := clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("StopReplication", replica.Alias) require.NoError(t, err) // We know VTOrc won't fix this since we disabled global recoveries! diff --git a/go/test/endtoend/vtorc/general/vtorc_test.go b/go/test/endtoend/vtorc/general/vtorc_test.go index f7deffe20b3..d79e2964f3e 100644 --- a/go/test/endtoend/vtorc/general/vtorc_test.go +++ b/go/test/endtoend/vtorc/general/vtorc_test.go @@ -163,7 +163,7 @@ func TestVTOrcRepairs(t *testing.T) { t.Run("StopReplication", func(t *testing.T) { // use vtctlclient to stop replication - _, err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("StopReplication", replica.Alias) + _, err := clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("StopReplication", replica.Alias) require.NoError(t, err) // check replication is setup correctly @@ -300,7 +300,7 @@ func TestRepairAfterTER(t *testing.T) { } // TER to other tablet - _, err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("TabletExternallyReparented", newPrimary.Alias) + _, err = clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("TabletExternallyReparented", newPrimary.Alias) require.NoError(t, err) utils.CheckReplication(t, clusterInfo, newPrimary, []*cluster.Vttablet{curPrimary}, 15*time.Second) @@ -404,11 +404,11 @@ func TestVTOrcWithPrs(t *testing.T) { // check that the replication is setup correctly before we failover utils.CheckReplication(t, clusterInfo, curPrimary, shard0.Vttablets, 10*time.Second) - output, err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput( - "PlannedReparentShard", "--", - "--keyspace_shard", fmt.Sprintf("%s/%s", keyspace.Name, shard0.Name), - "--wait_replicas_timeout", "31s", - "--new_primary", replica.Alias) + output, err := clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommandWithOutput( + "PlannedReparentShard", + fmt.Sprintf("%s/%s", keyspace.Name, shard0.Name), + "--wait-replicas-timeout", "31s", + "--new-primary", replica.Alias) require.NoError(t, err, "error in PlannedReparentShard output - %s", output) time.Sleep(40 * time.Second) diff --git a/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go b/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go index e226e8d13ae..d91dadddcb4 100644 --- a/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go +++ b/go/test/endtoend/vtorc/primaryfailure/primary_failure_test.go @@ -113,7 +113,7 @@ func TestDownPrimaryBeforeVTOrc(t *testing.T) { curPrimary := shard0.Vttablets[0] // Promote the first tablet as the primary - err := clusterInfo.ClusterInstance.VtctlclientProcess.InitializeShard(keyspace.Name, shard0.Name, clusterInfo.ClusterInstance.Cell, curPrimary.TabletUID) + err := clusterInfo.ClusterInstance.VtctldClientProcess.InitializeShard(keyspace.Name, shard0.Name, clusterInfo.ClusterInstance.Cell, curPrimary.TabletUID) require.NoError(t, err) // find the replica and rdonly tablets @@ -442,9 +442,9 @@ func TestLostRdonlyOnPrimaryFailure(t *testing.T) { utils.DisableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // stop replication on the replica and rdonly. - err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", replica.Alias) + err := clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", replica.Alias) require.NoError(t, err) - err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", rdonly.Alias) + err = clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", rdonly.Alias) require.NoError(t, err) // check that aheadRdonly is able to replicate. We also want to add some queries to aheadRdonly which will not be there in replica and rdonly @@ -669,7 +669,7 @@ func TestDownPrimaryPromotionRuleWithLag(t *testing.T) { utils.DisableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // stop replication on the crossCellReplica. - err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", crossCellReplica.Alias) + err := clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", crossCellReplica.Alias) require.NoError(t, err) // check that rdonly and replica are able to replicate. We also want to add some queries to replica which will not be there in crossCellReplica @@ -679,7 +679,7 @@ func TestDownPrimaryPromotionRuleWithLag(t *testing.T) { utils.ResetPrimaryLogs(t, curPrimary) // start replication back on the crossCellReplica. - err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", crossCellReplica.Alias) + err = clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", crossCellReplica.Alias) require.NoError(t, err) // enable recoveries back on vtorc so that it can repair @@ -750,7 +750,7 @@ func TestDownPrimaryPromotionRuleWithLagCrossCenter(t *testing.T) { utils.DisableGlobalRecoveries(t, clusterInfo.ClusterInstance.VTOrcProcesses[0]) // stop replication on the replica. - err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StopReplication", replica.Alias) + err := clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommand("StopReplication", replica.Alias) require.NoError(t, err) // check that rdonly and crossCellReplica are able to replicate. We also want to add some queries to crossCenterReplica which will not be there in replica @@ -760,7 +760,7 @@ func TestDownPrimaryPromotionRuleWithLagCrossCenter(t *testing.T) { utils.ResetPrimaryLogs(t, curPrimary) // start replication back on the replica. - err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("StartReplication", replica.Alias) + err = clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommand("StartReplication", replica.Alias) require.NoError(t, err) // enable recoveries back on vtorc so that it can repair diff --git a/go/test/endtoend/vtorc/utils/utils.go b/go/test/endtoend/vtorc/utils/utils.go index 11294319658..dca2c7b1e26 100644 --- a/go/test/endtoend/vtorc/utils/utils.go +++ b/go/test/endtoend/vtorc/utils/utils.go @@ -33,7 +33,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "vitess.io/vitess/go/json2" "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/test/endtoend/cluster" @@ -206,7 +205,7 @@ func shutdownVttablets(clusterInfo *VTOrcClusterInfo) error { // Remove the tablet record for this tablet } // Ignoring error here because some tests delete tablets themselves. - _ = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommand("DeleteTablet", vttablet.Alias) + _ = clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommand("DeleteTablets", vttablet.Alias) } clusterInfo.ClusterInstance.Keyspaces[0].Shards[0].Vttablets = nil return nil @@ -352,19 +351,16 @@ func ShardPrimaryTablet(t *testing.T, clusterInfo *VTOrcClusterInfo, keyspace *c if now.Sub(start) > time.Second*60 { assert.FailNow(t, "failed to elect primary before timeout") } - result, err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetShard", fmt.Sprintf("%s/%s", keyspace.Name, shard.Name)) - assert.Nil(t, err) + si, err := clusterInfo.ClusterInstance.VtctldClientProcess.GetShard(keyspace.Name, shard.Name) + require.NoError(t, err) - var shardInfo topodatapb.Shard - err = json2.Unmarshal([]byte(result), &shardInfo) - assert.Nil(t, err) - if shardInfo.PrimaryAlias == nil { + if si.Shard.PrimaryAlias == nil { log.Warningf("Shard %v/%v has no primary yet, sleep for 1 second\n", keyspace.Name, shard.Name) time.Sleep(time.Second) continue } for _, tablet := range shard.Vttablets { - if tablet.Alias == topoproto.TabletAliasString(shardInfo.PrimaryAlias) { + if tablet.Alias == topoproto.TabletAliasString(si.Shard.PrimaryAlias) { return tablet } } @@ -381,12 +377,8 @@ func CheckPrimaryTablet(t *testing.T, clusterInfo *VTOrcClusterInfo, tablet *clu //log.Exitf("error") assert.FailNow(t, "failed to elect primary before timeout") } - result, err := clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("GetTablet", tablet.Alias) - require.NoError(t, err) - var tabletInfo topodatapb.Tablet - err = json2.Unmarshal([]byte(result), &tabletInfo) + tabletInfo, err := clusterInfo.ClusterInstance.VtctldClientProcess.GetTablet(tablet.Alias) require.NoError(t, err) - if topodatapb.TabletType_PRIMARY != tabletInfo.GetType() { log.Warningf("Tablet %v is not primary yet, sleep for 1 second\n", tablet.Alias) time.Sleep(time.Second) @@ -535,9 +527,9 @@ func validateTopology(t *testing.T, clusterInfo *VTOrcClusterInfo, pingTablets b var err error var output string if pingTablets { - output, err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("Validate", "--", "--ping-tablets=true") + output, err = clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("Validate", "--ping-tablets") } else { - output, err = clusterInfo.ClusterInstance.VtctlclientProcess.ExecuteCommandWithOutput("Validate") + output, err = clusterInfo.ClusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("Validate") } if err != nil { log.Warningf("Validate failed, retrying, output - %s", output) From d8ac5a8359f083c635021a5a7bae29ae2c940c5b Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Thu, 22 Feb 2024 11:07:22 +0530 Subject: [PATCH 45/79] Improve VTOrc startup flow (#15315) Signed-off-by: Manan Gupta --- go/test/endtoend/vtorc/api/api_test.go | 11 ++--- go/vt/vtorc/logic/tablet_discovery.go | 11 ++++- go/vt/vtorc/logic/tablet_discovery_test.go | 22 +++++++++ go/vt/vtorc/logic/vtorc.go | 56 ++++++++++------------ go/vt/vtorc/process/health.go | 4 +- 5 files changed, 64 insertions(+), 40 deletions(-) diff --git a/go/test/endtoend/vtorc/api/api_test.go b/go/test/endtoend/vtorc/api/api_test.go index 7b277fd7a0f..30e43dfc29a 100644 --- a/go/test/endtoend/vtorc/api/api_test.go +++ b/go/test/endtoend/vtorc/api/api_test.go @@ -37,21 +37,18 @@ func TestAPIEndpoints(t *testing.T) { utils.SetupVttabletsAndVTOrcs(t, clusterInfo, 2, 1, nil, cluster.VTOrcConfiguration{ PreventCrossDataCenterPrimaryFailover: true, RecoveryPeriodBlockSeconds: 5, - // The default topo refresh time is 3 seconds. We are intentionally making it slower for the test, so that we have time to verify - // the /debug/health output before and after the first refresh runs. - TopologyRefreshSeconds: 10, }, 1, "") keyspace := &clusterInfo.ClusterInstance.Keyspaces[0] shard0 := &keyspace.Shards[0] vtorc := clusterInfo.ClusterInstance.VTOrcProcesses[0] // Call API with retry to ensure VTOrc is up status, resp := utils.MakeAPICallRetry(t, vtorc, "/debug/health", func(code int, response string) bool { - return code == 0 + return code != 200 }) - // When VTOrc is up and hasn't run the topo-refresh, is should be healthy but HasDiscovered should be false. - assert.Equal(t, 500, status) + // Verify when VTOrc is healthy, it has also run the first discovery. + assert.Equal(t, 200, status) assert.Contains(t, resp, `"Healthy": true,`) - assert.Contains(t, resp, `"DiscoveredOnce": false`) + assert.Contains(t, resp, `"DiscoveredOnce": true`) // find primary from topo primary := utils.ShardPrimaryTablet(t, clusterInfo, keyspace, shard0) diff --git a/go/vt/vtorc/logic/tablet_discovery.go b/go/vt/vtorc/logic/tablet_discovery.go index dd2e65237bf..f08ab2c9c15 100644 --- a/go/vt/vtorc/logic/tablet_discovery.go +++ b/go/vt/vtorc/logic/tablet_discovery.go @@ -40,6 +40,7 @@ import ( "vitess.io/vitess/go/vt/vtorc/config" "vitess.io/vitess/go/vt/vtorc/db" "vitess.io/vitess/go/vt/vtorc/inst" + "vitess.io/vitess/go/vt/vtorc/process" "vitess.io/vitess/go/vt/vttablet/tmclient" topodatapb "vitess.io/vitess/go/vt/proto/topodata" @@ -64,16 +65,24 @@ func RegisterFlags(fs *pflag.FlagSet) { // OpenTabletDiscovery opens the vitess topo if enables and returns a ticker // channel for polling. func OpenTabletDiscovery() <-chan time.Time { - // TODO(sougou): If there's a shutdown signal, we have to close the topo. ts = topo.Open() tmc = tmclient.NewTabletManagerClient() // Clear existing cache and perform a new refresh. if _, err := db.ExecVTOrc("delete from vitess_tablet"); err != nil { log.Error(err) } + // We refresh all information from the topo once before we start the ticks to do it on a timer. + populateAllInformation() return time.Tick(time.Second * time.Duration(config.Config.TopoInformationRefreshSeconds)) //nolint SA1015: using time.Tick leaks the underlying ticker } +// populateAllInformation initializes all the information for VTOrc to function. +func populateAllInformation() { + refreshAllInformation() + // We have completed one full discovery cycle. We should update the process health. + process.FirstDiscoveryCycleComplete.Store(true) +} + // refreshAllTablets reloads the tablets from topo and discovers the ones which haven't been refreshed in a while func refreshAllTablets() { refreshTabletsUsing(func(tabletAlias string) { diff --git a/go/vt/vtorc/logic/tablet_discovery_test.go b/go/vt/vtorc/logic/tablet_discovery_test.go index 0e8ac72fabf..f79cecf9ff5 100644 --- a/go/vt/vtorc/logic/tablet_discovery_test.go +++ b/go/vt/vtorc/logic/tablet_discovery_test.go @@ -34,6 +34,7 @@ import ( "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/vtorc/db" "vitess.io/vitess/go/vt/vtorc/inst" + "vitess.io/vitess/go/vt/vtorc/process" ) var ( @@ -342,3 +343,24 @@ func TestGetLockAction(t *testing.T) { }) } } + +// TestProcessHealth tests that the health of the process reflects that we have run the first discovery once correctly. +func TestProcessHealth(t *testing.T) { + require.False(t, process.FirstDiscoveryCycleComplete.Load()) + originalTs := ts + defer func() { + ts = originalTs + process.FirstDiscoveryCycleComplete.Store(false) + }() + // Verify in the beginning, we have the first DiscoveredOnce field false. + health, err := process.HealthTest() + require.NoError(t, err) + require.False(t, health.DiscoveredOnce) + ts = memorytopo.NewServer(context.Background(), cell1) + populateAllInformation() + require.True(t, process.FirstDiscoveryCycleComplete.Load()) + // Verify after we populate all information, we have the first DiscoveredOnce field true. + health, err = process.HealthTest() + require.NoError(t, err) + require.True(t, health.DiscoveredOnce) +} diff --git a/go/vt/vtorc/logic/vtorc.go b/go/vt/vtorc/logic/vtorc.go index f637956fbfd..66c5590831b 100644 --- a/go/vt/vtorc/logic/vtorc.go +++ b/go/vt/vtorc/logic/vtorc.go @@ -129,6 +129,7 @@ func closeVTOrc() { _ = inst.AuditOperation("shutdown", "", "Triggered via SIGTERM") // wait for the locks to be released waitForLocksRelease() + ts.Close() log.Infof("VTOrc closed") } @@ -335,8 +336,6 @@ func onHealthTick() { // nolint SA1015: using time.Tick leaks the underlying ticker func ContinuousDiscovery() { log.Infof("continuous discovery: setting up") - continuousDiscoveryStartTime := time.Now() - checkAndRecoverWaitPeriod := 3 * instancePollSecondsDuration() recentDiscoveryOperationKeys = cache.New(instancePollSecondsDuration(), time.Second) go handleDiscoveryRequests() @@ -351,10 +350,6 @@ func ContinuousDiscovery() { snapshotTopologiesTick = time.Tick(time.Duration(config.Config.SnapshotTopologiesIntervalHours) * time.Hour) } - runCheckAndRecoverOperationsTimeRipe := func() bool { - return time.Since(continuousDiscoveryStartTime) >= checkAndRecoverWaitPeriod - } - go func() { _ = ometrics.InitMetrics() }() @@ -400,11 +395,7 @@ func ContinuousDiscovery() { } else { return } - if runCheckAndRecoverOperationsTimeRipe() { - CheckAndRecover() - } else { - log.Infof("Waiting for %+v seconds to pass before running failure detection/recovery", checkAndRecoverWaitPeriod.Seconds()) - } + CheckAndRecover() }() } }() @@ -415,27 +406,30 @@ func ContinuousDiscovery() { } }() case <-tabletTopoTick: - // Create a wait group - var wg sync.WaitGroup + refreshAllInformation() + } + } +} - // Refresh all keyspace information. - wg.Add(1) - go func() { - defer wg.Done() - RefreshAllKeyspacesAndShards() - }() +// refreshAllInformation refreshes both shard and tablet information. This is meant to be run on tablet topo ticks. +func refreshAllInformation() { + // Create a wait group + var wg sync.WaitGroup - // Refresh all tablets. - wg.Add(1) - go func() { - defer wg.Done() - refreshAllTablets() - }() + // Refresh all keyspace information. + wg.Add(1) + go func() { + defer wg.Done() + RefreshAllKeyspacesAndShards() + }() - // Wait for both the refreshes to complete - wg.Wait() - // We have completed one discovery cycle in the entirety of it. We should update the process health. - process.FirstDiscoveryCycleComplete.Store(true) - } - } + // Refresh all tablets. + wg.Add(1) + go func() { + defer wg.Done() + refreshAllTablets() + }() + + // Wait for both the refreshes to complete + wg.Wait() } diff --git a/go/vt/vtorc/process/health.go b/go/vt/vtorc/process/health.go index 22db89e1d56..a782b2edf14 100644 --- a/go/vt/vtorc/process/health.go +++ b/go/vt/vtorc/process/health.go @@ -108,7 +108,9 @@ func RegisterNode(nodeHealth *NodeHealth) (healthy bool, err error) { func HealthTest() (health *HealthStatus, err error) { cacheKey := util.ProcessToken.Hash if healthStatus, found := lastHealthCheckCache.Get(cacheKey); found { - return healthStatus.(*HealthStatus), nil + health = healthStatus.(*HealthStatus) + health.DiscoveredOnce = FirstDiscoveryCycleComplete.Load() + return } health = &HealthStatus{Healthy: false, Hostname: ThisHostname, Token: util.ProcessToken.Hash} From e5499807932015dc7fb31569f5557005cc3119db Mon Sep 17 00:00:00 2001 From: Tim Vaillancourt Date: Thu, 22 Feb 2024 07:52:52 +0100 Subject: [PATCH 46/79] Skip for-loop alloc in `go/vt/discovery/healthcheck.go` (#15326) Signed-off-by: Tim Vaillancourt --- go/vt/discovery/healthcheck.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go/vt/discovery/healthcheck.go b/go/vt/discovery/healthcheck.go index 5d6a5e32662..5572e9a41d9 100644 --- a/go/vt/discovery/healthcheck.go +++ b/go/vt/discovery/healthcheck.go @@ -774,6 +774,7 @@ func FilterTargetsByKeyspaces(keyspaces []string, targets []*query.Target) []*qu func (hc *HealthCheckImpl) waitForTablets(ctx context.Context, targets []*query.Target, requireServing bool) error { targets = FilterTargetsByKeyspaces(KeyspacesToWatch, targets) + var tabletHealths []*TabletHealth for { // We nil targets as we find them. allPresent := true @@ -782,7 +783,6 @@ func (hc *HealthCheckImpl) waitForTablets(ctx context.Context, targets []*query. continue } - var tabletHealths []*TabletHealth if requireServing { tabletHealths = hc.GetHealthyTabletStats(target) } else { From c536bb7b26603931f6f2adac0065cf2a0c210869 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20Taylor?= Date: Thu, 22 Feb 2024 08:56:16 +0100 Subject: [PATCH 47/79] Column alias expanding on ORDER BY (#15302) Co-authored-by: Harshit Gangal Co-authored-by: Manan Gupta --- go/mysql/sqlerror/sql_error.go | 1 + .../queries/aggregation/aggregation_test.go | 36 +- .../vtgate/queries/dml/insert_test.go | 12 +- .../queries/lookup_queries/main_test.go | 2 +- .../endtoend/vtgate/queries/misc/misc_test.go | 4 +- .../vtgate/queries/orderby/orderby_test.go | 70 ++++ .../vtgate/queries/orderby/schema.sql | 9 + .../vtgate/queries/orderby/vschema.json | 8 + .../vtgate/queries/union/union_test.go | 9 +- go/vt/schemadiff/schema.go | 2 +- go/vt/vterrors/state.go | 1 + .../testdata/postprocess_cases.json | 134 +++++++ .../testdata/unsupported_cases.json | 5 - go/vt/vtgate/semantics/analyzer.go | 19 +- go/vt/vtgate/semantics/binder.go | 15 +- go/vt/vtgate/semantics/early_rewriter.go | 333 +++++++++++++++--- go/vt/vtgate/semantics/early_rewriter_test.go | 207 ++++++++--- go/vt/vtgate/semantics/errors.go | 26 +- 18 files changed, 749 insertions(+), 144 deletions(-) diff --git a/go/mysql/sqlerror/sql_error.go b/go/mysql/sqlerror/sql_error.go index 3ffbc7f9c8c..bebd9e41ca7 100644 --- a/go/mysql/sqlerror/sql_error.go +++ b/go/mysql/sqlerror/sql_error.go @@ -243,6 +243,7 @@ var stateToMysqlCode = map[vterrors.State]mysqlCode{ vterrors.WrongParametersToNativeFct: {num: ERWrongParametersToNativeFct, state: SSUnknownSQLState}, vterrors.KillDeniedError: {num: ERKillDenied, state: SSUnknownSQLState}, vterrors.BadNullError: {num: ERBadNullError, state: SSConstraintViolation}, + vterrors.InvalidGroupFuncUse: {num: ERInvalidGroupFuncUse, state: SSUnknownSQLState}, } func getStateToMySQLState(state vterrors.State) mysqlCode { diff --git a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go index 89b3d0c8c85..6f4dd01d4e2 100644 --- a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go +++ b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go @@ -73,7 +73,7 @@ func TestAggregateTypes(t *testing.T) { mcmp.AssertMatches("select val1 as a, count(*) from aggr_test group by a order by a", `[[VARCHAR("a") INT64(2)] [VARCHAR("b") INT64(1)] [VARCHAR("c") INT64(2)] [VARCHAR("d") INT64(1)] [VARCHAR("e") INT64(2)]]`) mcmp.AssertMatches("select val1 as a, count(*) from aggr_test group by a order by 2, a", `[[VARCHAR("b") INT64(1)] [VARCHAR("d") INT64(1)] [VARCHAR("a") INT64(2)] [VARCHAR("c") INT64(2)] [VARCHAR("e") INT64(2)]]`) mcmp.AssertMatches("select sum(val1) from aggr_test", `[[FLOAT64(0)]]`) - t.Run("Average for sharded keyspaces", func(t *testing.T) { + mcmp.Run("Average for sharded keyspaces", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches("select avg(val1) from aggr_test", `[[FLOAT64(0)]]`) }) @@ -101,7 +101,7 @@ func TestEqualFilterOnScatter(t *testing.T) { workloads := []string{"oltp", "olap"} for _, workload := range workloads { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = '%s'", workload)) mcmp.AssertMatches("select count(*) as a from aggr_test having 1 = 1", `[[INT64(5)]]`) @@ -177,7 +177,7 @@ func TestAggrOnJoin(t *testing.T) { mcmp.AssertMatches("select a.val1 from aggr_test a join t3 t on a.val2 = t.id7 group by a.val1 having count(*) = 4", `[[VARCHAR("a")]]`) - t.Run("Average in join for sharded", func(t *testing.T) { + mcmp.Run("Average in join for sharded", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches(`select avg(a1.val2), avg(a2.val2) from aggr_test a1 join aggr_test a2 on a1.val2 = a2.id join t3 t on a2.val2 = t.id7`, "[[DECIMAL(1.5000) DECIMAL(1.0000)]]") @@ -196,7 +196,7 @@ func TestNotEqualFilterOnScatter(t *testing.T) { workloads := []string{"oltp", "olap"} for _, workload := range workloads { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = '%s'", workload)) mcmp.AssertMatches("select count(*) as a from aggr_test having a != 5", `[]`) @@ -220,7 +220,7 @@ func TestLessFilterOnScatter(t *testing.T) { workloads := []string{"oltp", "olap"} for _, workload := range workloads { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = '%s'", workload)) mcmp.AssertMatches("select count(*) as a from aggr_test having a < 10", `[[INT64(5)]]`) mcmp.AssertMatches("select count(*) as a from aggr_test having 1 < a", `[[INT64(5)]]`) @@ -243,7 +243,7 @@ func TestLessEqualFilterOnScatter(t *testing.T) { workloads := []string{"oltp", "olap"} for _, workload := range workloads { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = '%s'", workload)) mcmp.AssertMatches("select count(*) as a from aggr_test having a <= 10", `[[INT64(5)]]`) @@ -267,7 +267,7 @@ func TestGreaterFilterOnScatter(t *testing.T) { workloads := []string{"oltp", "olap"} for _, workload := range workloads { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = '%s'", workload)) mcmp.AssertMatches("select count(*) as a from aggr_test having a > 1", `[[INT64(5)]]`) @@ -291,7 +291,7 @@ func TestGreaterEqualFilterOnScatter(t *testing.T) { workloads := []string{"oltp", "olap"} for _, workload := range workloads { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = '%s'", workload)) mcmp.AssertMatches("select count(*) as a from aggr_test having a >= 1", `[[INT64(5)]]`) @@ -326,7 +326,7 @@ func TestAggOnTopOfLimit(t *testing.T) { mcmp.Exec("insert into aggr_test(id, val1, val2) values(1,'a',6), (2,'a',1), (3,'b',1), (4,'c',3), (5,'c',4), (6,'b',null), (7,null,2), (8,null,null)") for _, workload := range []string{"oltp", "olap"} { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = '%s'", workload)) mcmp.AssertMatches("select count(*) from (select id, val1 from aggr_test where val2 < 4 limit 2) as x", "[[INT64(2)]]") mcmp.AssertMatches("select count(val1) from (select id, val1 from aggr_test where val2 < 4 order by val1 desc limit 2) as x", "[[INT64(2)]]") @@ -335,7 +335,7 @@ func TestAggOnTopOfLimit(t *testing.T) { mcmp.AssertMatches("select count(val2) from (select id, val2 from aggr_test where val2 is null limit 2) as x", "[[INT64(0)]]") mcmp.AssertMatches("select val1, count(*) from (select id, val1 from aggr_test where val2 < 4 order by val1 limit 2) as x group by val1", `[[NULL INT64(1)] [VARCHAR("a") INT64(1)]]`) mcmp.AssertMatchesNoOrder("select val1, count(val2) from (select val1, val2 from aggr_test limit 8) as x group by val1", `[[NULL INT64(1)] [VARCHAR("a") INT64(2)] [VARCHAR("b") INT64(1)] [VARCHAR("c") INT64(2)]]`) - t.Run("Average in sharded query", func(t *testing.T) { + mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches("select avg(val2) from (select id, val2 from aggr_test where val2 is null limit 2) as x", "[[NULL]]") mcmp.AssertMatchesNoOrder("select val1, avg(val2) from (select val1, val2 from aggr_test limit 8) as x group by val1", `[[NULL DECIMAL(2.0000)] [VARCHAR("a") DECIMAL(3.5000)] [VARCHAR("b") DECIMAL(1.0000)] [VARCHAR("c") DECIMAL(3.5000)]]`) @@ -347,7 +347,7 @@ func TestAggOnTopOfLimit(t *testing.T) { mcmp.AssertMatches("select count(val1), sum(id) from (select id, val1 from aggr_test where val2 is null limit 2) as x", "[[INT64(1) DECIMAL(14)]]") mcmp.AssertMatches("select count(val2), sum(val2) from (select id, val2 from aggr_test where val2 is null limit 2) as x", "[[INT64(0) NULL]]") mcmp.AssertMatches("select val1, count(*), sum(id) from (select id, val1 from aggr_test where val2 < 4 order by val1 limit 2) as x group by val1", `[[NULL INT64(1) DECIMAL(7)] [VARCHAR("a") INT64(1) DECIMAL(2)]]`) - t.Run("Average in sharded query", func(t *testing.T) { + mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches("select count(*), sum(val1), avg(val1) from (select id, val1 from aggr_test where val2 < 4 order by val1 desc limit 2) as x", "[[INT64(2) FLOAT64(0) FLOAT64(0)]]") mcmp.AssertMatches("select count(val1), sum(id), avg(id) from (select id, val1 from aggr_test where val2 < 4 order by val1 desc limit 2) as x", "[[INT64(2) DECIMAL(7) DECIMAL(3.5000)]]") @@ -363,13 +363,13 @@ func TestEmptyTableAggr(t *testing.T) { defer closer() for _, workload := range []string{"oltp", "olap"} { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = %s", workload)) mcmp.AssertMatches(" select count(*) from t1 inner join t2 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select count(*) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select t1.`name`, count(*) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo' group by t1.`name`", "[]") mcmp.AssertMatches(" select t1.`name`, count(*) from t1 inner join t2 on (t1.t1_id = t2.id) where t1.value = 'foo' group by t1.`name`", "[]") - t.Run("Average in sharded query", func(t *testing.T) { + mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches(" select count(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select avg(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[NULL]]") @@ -380,12 +380,12 @@ func TestEmptyTableAggr(t *testing.T) { mcmp.Exec("insert into t1(t1_id, `name`, `value`, shardkey) values(1,'a1','foo',100), (2,'b1','foo',200), (3,'c1','foo',300), (4,'a1','foo',100), (5,'b1','bar',200)") for _, workload := range []string{"oltp", "olap"} { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = %s", workload)) mcmp.AssertMatches(" select count(*) from t1 inner join t2 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select count(*) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select t1.`name`, count(*) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo' group by t1.`name`", "[]") - t.Run("Average in sharded query", func(t *testing.T) { + mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches(" select count(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select avg(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[NULL]]") @@ -434,7 +434,7 @@ func TestAggregateLeftJoin(t *testing.T) { mcmp.AssertMatches("SELECT sum(t2.shardkey) FROM t1 LEFT JOIN t2 ON t1.t1_id = t2.id", `[[DECIMAL(1)]]`) mcmp.AssertMatches("SELECT count(*) FROM t2 LEFT JOIN t1 ON t1.t1_id = t2.id WHERE IFNULL(t1.name, 'NOTSET') = 'r'", `[[INT64(1)]]`) - t.Run("Average in sharded query", func(t *testing.T) { + mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches("SELECT avg(t1.shardkey) FROM t1 LEFT JOIN t2 ON t1.t1_id = t2.id", `[[DECIMAL(0.5000)]]`) mcmp.AssertMatches("SELECT avg(t2.shardkey) FROM t1 LEFT JOIN t2 ON t1.t1_id = t2.id", `[[DECIMAL(1.0000)]]`) @@ -491,7 +491,7 @@ func TestScalarAggregate(t *testing.T) { mcmp.Exec("insert into aggr_test(id, val1, val2) values(1,'a',1), (2,'A',1), (3,'b',1), (4,'c',3), (5,'c',4)") mcmp.AssertMatches("select count(distinct val1) from aggr_test", `[[INT64(3)]]`) - t.Run("Average in sharded query", func(t *testing.T) { + mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.AssertMatches("select avg(val1) from aggr_test", `[[FLOAT64(0)]]`) }) @@ -551,7 +551,7 @@ func TestComplexAggregation(t *testing.T) { mcmp.Exec(`SELECT shardkey + MIN(t1_id)+MAX(t1_id) FROM t1 GROUP BY shardkey`) mcmp.Exec(`SELECT name+COUNT(t1_id)+1 FROM t1 GROUP BY name`) mcmp.Exec(`SELECT COUNT(*)+shardkey+MIN(t1_id)+1+MAX(t1_id)*SUM(t1_id)+1+name FROM t1 GROUP BY shardkey, name`) - t.Run("Average in sharded query", func(t *testing.T) { + mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") mcmp.Exec(`SELECT COUNT(t1_id)+MAX(shardkey)+AVG(t1_id) FROM t1`) }) diff --git a/go/test/endtoend/vtgate/queries/dml/insert_test.go b/go/test/endtoend/vtgate/queries/dml/insert_test.go index 80d0602b898..ce052b7b2ba 100644 --- a/go/test/endtoend/vtgate/queries/dml/insert_test.go +++ b/go/test/endtoend/vtgate/queries/dml/insert_test.go @@ -38,7 +38,7 @@ func TestSimpleInsertSelect(t *testing.T) { mcmp.Exec("insert into u_tbl(id, num) values (1,2),(3,4)") for i, mode := range []string{"oltp", "olap"} { - t.Run(mode, func(t *testing.T) { + mcmp.Run(mode, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = %s", mode)) qr := mcmp.Exec(fmt.Sprintf("insert into s_tbl(id, num) select id*%d, num*%d from s_tbl where id < 10", 10+i, 20+i)) @@ -65,7 +65,7 @@ func TestFailureInsertSelect(t *testing.T) { mcmp.Exec("insert into u_tbl(id, num) values (1,2),(3,4)") for _, mode := range []string{"oltp", "olap"} { - t.Run(mode, func(t *testing.T) { + mcmp.Run(mode, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = %s", mode)) // primary key same @@ -127,7 +127,7 @@ func TestAutoIncInsertSelect(t *testing.T) { }} for _, tcase := range tcases { - t.Run(tcase.query, func(t *testing.T) { + mcmp.Run(tcase.query, func(mcmp *utils.MySQLCompare) { qr := utils.Exec(t, mcmp.VtConn, tcase.query) assert.EqualValues(t, tcase.expRowsAffected, qr.RowsAffected) assert.EqualValues(t, tcase.expInsertID, qr.InsertID) @@ -178,7 +178,7 @@ func TestAutoIncInsertSelectOlapMode(t *testing.T) { }} for _, tcase := range tcases { - t.Run(tcase.query, func(t *testing.T) { + mcmp.Run(tcase.query, func(mcmp *utils.MySQLCompare) { qr := utils.Exec(t, mcmp.VtConn, tcase.query) assert.EqualValues(t, tcase.expRowsAffected, qr.RowsAffected) assert.EqualValues(t, tcase.expInsertID, qr.InsertID) @@ -386,7 +386,7 @@ func TestInsertSelectUnshardedUsingSharded(t *testing.T) { mcmp.Exec("insert into s_tbl(id, num) values (1,2),(3,4)") for _, mode := range []string{"oltp", "olap"} { - t.Run(mode, func(t *testing.T) { + mcmp.Run(mode, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = %s", mode)) qr := mcmp.Exec("insert into u_tbl(id, num) select id, num from s_tbl where s_tbl.id in (1,3)") assert.EqualValues(t, 2, qr.RowsAffected) @@ -453,7 +453,7 @@ func TestMixedCases(t *testing.T) { }} for _, tc := range tcases { - t.Run(tc.insQuery, func(t *testing.T) { + mcmp.Run(tc.insQuery, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, tc.insQuery) utils.AssertMatches(t, mcmp.VtConn, tc.selQuery, tc.exp) }) diff --git a/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go b/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go index 9486dc194ff..a587f124762 100644 --- a/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go +++ b/go/test/endtoend/vtgate/queries/lookup_queries/main_test.go @@ -134,7 +134,7 @@ func TestLookupQueries(t *testing.T) { (3, 'monkey', 'monkey')`) for _, workload := range []string{"olap", "oltp"} { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, "set workload = "+workload) mcmp.AssertMatches("select id from user where lookup = 'apa'", "[[INT64(1)] [INT64(2)]]") diff --git a/go/test/endtoend/vtgate/queries/misc/misc_test.go b/go/test/endtoend/vtgate/queries/misc/misc_test.go index 0b7671c753d..472d725488c 100644 --- a/go/test/endtoend/vtgate/queries/misc/misc_test.go +++ b/go/test/endtoend/vtgate/queries/misc/misc_test.go @@ -311,7 +311,7 @@ func TestAnalyze(t *testing.T) { defer closer() for _, workload := range []string{"olap", "oltp"} { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, fmt.Sprintf("set workload = %s", workload)) utils.Exec(t, mcmp.VtConn, "analyze table t1") utils.Exec(t, mcmp.VtConn, "analyze table uks.unsharded") @@ -344,7 +344,7 @@ func TestTransactionModeVar(t *testing.T) { }} for _, tcase := range tcases { - t.Run(tcase.setStmt, func(t *testing.T) { + mcmp.Run(tcase.setStmt, func(mcmp *utils.MySQLCompare) { if tcase.setStmt != "" { utils.Exec(t, mcmp.VtConn, tcase.setStmt) } diff --git a/go/test/endtoend/vtgate/queries/orderby/orderby_test.go b/go/test/endtoend/vtgate/queries/orderby/orderby_test.go index 43f800ee24c..993f7834301 100644 --- a/go/test/endtoend/vtgate/queries/orderby/orderby_test.go +++ b/go/test/endtoend/vtgate/queries/orderby/orderby_test.go @@ -83,3 +83,73 @@ func TestOrderBy(t *testing.T) { mcmp.AssertMatches("select id1, id2 from t4 order by reverse(id2) desc", `[[INT64(5) VARCHAR("test")] [INT64(8) VARCHAR("F")] [INT64(7) VARCHAR("e")] [INT64(6) VARCHAR("d")] [INT64(2) VARCHAR("Abc")] [INT64(4) VARCHAR("c")] [INT64(3) VARCHAR("b")] [INT64(1) VARCHAR("a")]]`) } } + +func TestOrderByComplex(t *testing.T) { + // tests written to try to trick the ORDER BY engine and planner + utils.SkipIfBinaryIsBelowVersion(t, 20, "vtgate") + + mcmp, closer := start(t) + defer closer() + + mcmp.Exec("insert into user(id, col, email) values(1,1,'a'), (2,2,'Abc'), (3,3,'b'), (4,4,'c'), (5,2,'test'), (6,1,'test'), (7,2,'a'), (8,3,'b'), (9,4,'c3'), (10,2,'d')") + + queries := []string{ + "select email, max(col) from user group by email order by col", + "select email, max(col) from user group by email order by col + 1", + "select email, max(col) from user group by email order by max(col)", + "select email, max(col) from user group by email order by max(col) + 1", + "select email, max(col) from user group by email order by min(col)", + "select email, max(col) as col from user group by email order by col", + "select email, max(col) as col from user group by email order by max(col)", + "select email, max(col) as col from user group by email order by col + 1", + "select email, max(col) as col from user group by email order by email + col", + "select email, max(col) as col from user group by email order by email + max(col)", + "select email, max(col) as col from user group by email order by email, col", + "select email, max(col) as xyz from user group by email order by email, xyz", + "select email, max(col) as xyz from user group by email order by email, max(xyz)", + "select email, max(col) as xyz from user group by email order by email, abs(xyz)", + "select email, max(col) as xyz from user group by email order by email, max(col)", + "select email, max(col) as xyz from user group by email order by email, abs(col)", + "select email, max(col) as xyz from user group by email order by xyz + email", + "select email, max(col) as xyz from user group by email order by abs(xyz) + email", + "select email, max(col) as xyz from user group by email order by abs(xyz)", + "select email, max(col) as xyz from user group by email order by abs(col)", + "select email, max(col) as max_col from user group by email order by max_col desc, length(email)", + "select email, max(col) as max_col, min(col) as min_col from user group by email order by max_col - min_col", + "select email, max(col) as col1, count(*) as col2 from user group by email order by col2 * col1", + "select email, sum(col) as sum_col from user group by email having sum_col > 10 order by sum_col / count(email)", + "select email, max(col) as max_col, char_length(email) as len_email from user group by email order by len_email, max_col desc", + "select email, max(col) as col_alias from user group by email order by case when col_alias > 100 then 0 else 1 end, col_alias", + "select email, count(*) as cnt, max(col) as max_col from user group by email order by cnt desc, max_col + cnt", + "select email, max(col) as max_col from user group by email order by if(max_col > 50, max_col, -max_col) desc", + "select email, max(col) as col, sum(col) as sum_col from user group by email order by col * sum_col desc", + "select email, max(col) as col, (select min(col) from user as u2 where u2.email = user.email) as min_col from user group by email order by col - min_col", + "select email, max(col) as max_col, (max(col) % 10) as mod_col from user group by email order by mod_col, max_col", + "select email, max(col) as 'value', count(email) as 'number' from user group by email order by 'number', 'value'", + "select email, max(col) as col, concat('email: ', email, ' col: ', max(col)) as complex_alias from user group by email order by complex_alias desc", + "select email, max(col) as max_col from user group by email union select email, min(col) as min_col from user group by email order by email", + "select email, max(col) as col from user where col > 50 group by email order by col desc", + "select email, max(col) as col from user group by email order by length(email), col", + "select email, max(col) as max_col, substring(email, 1, 3) as sub_email from user group by email order by sub_email, max_col desc", + "select email, max(col) as max_col from user group by email order by reverse(email), max_col", + "select email, max(col) as max_col from user group by email having max_col > avg(max_col) order by max_col desc", + "select email, count(*) as count, max(col) as max_col from user group by email order by count * max_col desc", + "select email, max(col) as col_alias from user group by email order by col_alias limit 10", + "select email, max(col) as col from user group by email order by col desc, email", + "select concat(email, ' ', max(col)) as combined from user group by email order by combined desc", + "select email, max(col) as max_col from user group by email order by ascii(email), max_col", + "select email, char_length(email) as email_length, max(col) as max_col from user group by email order by email_length desc, max_col", + "select email, max(col) as col from user group by email having col between 10 and 100 order by col", + "select email, max(col) as max_col, min(col) as min_col from user group by email order by max_col + min_col desc", + "select email, max(col) as 'max', count(*) as 'count' from user group by email order by 'max' desc, 'count'", + "select email, max(col) as max_col from (select email, col from user where col > 20) as filtered group by email order by max_col", + "select a.email, a.max_col from (select email, max(col) as max_col from user group by email) as a order by a.max_col desc", + "select email, max(col) as max_col from user where email like 'a%' group by email order by max_col, email", + } + + for _, query := range queries { + mcmp.Run(query, func(mcmp *utils.MySQLCompare) { + _, _ = mcmp.ExecAllowAndCompareError(query) + }) + } +} diff --git a/go/test/endtoend/vtgate/queries/orderby/schema.sql b/go/test/endtoend/vtgate/queries/orderby/schema.sql index 8f0131db357..efaedc14754 100644 --- a/go/test/endtoend/vtgate/queries/orderby/schema.sql +++ b/go/test/endtoend/vtgate/queries/orderby/schema.sql @@ -27,3 +27,12 @@ create table t4_id2_idx ) Engine = InnoDB DEFAULT charset = utf8mb4 COLLATE = utf8mb4_general_ci; + +create table user +( + id bigint primary key, + col bigint, + email varchar(20) +) Engine = InnoDB + DEFAULT charset = utf8mb4 + COLLATE = utf8mb4_general_ci; \ No newline at end of file diff --git a/go/test/endtoend/vtgate/queries/orderby/vschema.json b/go/test/endtoend/vtgate/queries/orderby/vschema.json index 14418850a35..771676de4b9 100644 --- a/go/test/endtoend/vtgate/queries/orderby/vschema.json +++ b/go/test/endtoend/vtgate/queries/orderby/vschema.json @@ -66,6 +66,14 @@ "name": "unicode_loose_md5" } ] + }, + "user": { + "column_vindexes": [ + { + "column": "id", + "name": "hash" + } + ] } } } \ No newline at end of file diff --git a/go/test/endtoend/vtgate/queries/union/union_test.go b/go/test/endtoend/vtgate/queries/union/union_test.go index 898f8b1d659..d91ea3c4073 100644 --- a/go/test/endtoend/vtgate/queries/union/union_test.go +++ b/go/test/endtoend/vtgate/queries/union/union_test.go @@ -57,7 +57,7 @@ func TestUnionDistinct(t *testing.T) { mcmp.Exec("insert into t2(id3, id4) values (2, 3), (3, 4), (4,4), (5,5)") for _, workload := range []string{"oltp", "olap"} { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, "set workload = "+workload) mcmp.AssertMatches("select 1 union select null", "[[INT64(1)] [NULL]]") mcmp.AssertMatches("select null union select null", "[[NULL]]") @@ -69,10 +69,7 @@ func TestUnionDistinct(t *testing.T) { mcmp.AssertMatchesNoOrder("select id1 from t1 where id1 = 1 union select 452 union select id1 from t1 where id1 = 4", "[[INT64(1)] [INT64(452)] [INT64(4)]]") mcmp.AssertMatchesNoOrder("select id1, id2 from t1 union select 827, 452 union select id3,id4 from t2", "[[INT64(4) INT64(4)] [INT64(1) INT64(1)] [INT64(2) INT64(2)] [INT64(3) INT64(3)] [INT64(827) INT64(452)] [INT64(2) INT64(3)] [INT64(3) INT64(4)] [INT64(5) INT64(5)]]") - t.Run("skipped for now", func(t *testing.T) { - t.Skip() - mcmp.AssertMatches("select 1 from dual where 1 IN (select 1 as col union select 2)", "[[INT64(1)]]") - }) + mcmp.AssertMatches("select 1 from dual where 1 IN (select 1 as col union select 2)", "[[INT64(1)]]") if utils.BinaryIsAtLeastAtVersion(19, "vtgate") { mcmp.AssertMatches(`SELECT 1 from t1 UNION SELECT 2 from t1`, `[[INT64(1)] [INT64(2)]]`) mcmp.AssertMatches(`SELECT 5 from t1 UNION SELECT 6 from t1`, `[[INT64(5)] [INT64(6)]]`) @@ -97,7 +94,7 @@ func TestUnionAll(t *testing.T) { mcmp.Exec("insert into t2(id3, id4) values(3, 3), (4, 4)") for _, workload := range []string{"oltp", "olap"} { - t.Run(workload, func(t *testing.T) { + mcmp.Run(workload, func(mcmp *utils.MySQLCompare) { utils.Exec(t, mcmp.VtConn, "set workload = "+workload) // union all between two selectuniqueequal mcmp.AssertMatches("select id1 from t1 where id1 = 1 union all select id1 from t1 where id1 = 4", "[[INT64(1)]]") diff --git a/go/vt/schemadiff/schema.go b/go/vt/schemadiff/schema.go index 084b703b14f..e3782fdbf0b 100644 --- a/go/vt/schemadiff/schema.go +++ b/go/vt/schemadiff/schema.go @@ -1058,7 +1058,7 @@ func (s *Schema) ValidateViewReferences() error { Column: e.Column, Ambiguous: true, } - case *semantics.ColumnNotFoundError: + case semantics.ColumnNotFoundError: return &InvalidColumnReferencedInViewError{ View: view.Name(), Column: e.Column.Name.String(), diff --git a/go/vt/vterrors/state.go b/go/vt/vterrors/state.go index 00d64dd39a5..2b0ada0bc6d 100644 --- a/go/vt/vterrors/state.go +++ b/go/vt/vterrors/state.go @@ -48,6 +48,7 @@ const ( WrongValue WrongArguments BadNullError + InvalidGroupFuncUse // failed precondition NoDB diff --git a/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json b/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json index 9093fe2f390..0b0c0658175 100644 --- a/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json @@ -2235,5 +2235,139 @@ "user.user" ] } + }, + { + "comment": "ORDER BY literal works fine even when the columns have the same name", + "query": "select a.id, b.id from user as a, user_extra as b union all select 1, 2 order by 1", + "plan": { + "QueryType": "SELECT", + "Original": "select a.id, b.id from user as a, user_extra as b union all select 1, 2 order by 1", + "Instructions": { + "OperatorType": "Sort", + "Variant": "Memory", + "OrderBy": "(0|2) ASC", + "ResultColumns": 2, + "Inputs": [ + { + "OperatorType": "Concatenate", + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "L:0,R:0,L:1", + "TableName": "`user`_user_extra", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select a.id, weight_string(a.id) from `user` as a where 1 != 1", + "Query": "select a.id, weight_string(a.id) from `user` as a", + "Table": "`user`" + }, + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select b.id from user_extra as b where 1 != 1", + "Query": "select b.id from user_extra as b", + "Table": "user_extra" + } + ] + }, + { + "OperatorType": "Route", + "Variant": "Reference", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "FieldQuery": "select 1, 2, weight_string(1) from dual where 1 != 1", + "Query": "select 1, 2, weight_string(1) from dual", + "Table": "dual" + } + ] + } + ] + }, + "TablesUsed": [ + "main.dual", + "user.user", + "user.user_extra" + ] + } + }, + { + "comment": "ORDER BY literal works fine even when the columns have the same name", + "query": "select a.id, b.id from user as a, user_extra as b union all select 1, 2 order by 2", + "plan": { + "QueryType": "SELECT", + "Original": "select a.id, b.id from user as a, user_extra as b union all select 1, 2 order by 2", + "Instructions": { + "OperatorType": "Sort", + "Variant": "Memory", + "OrderBy": "(1|2) ASC", + "ResultColumns": 2, + "Inputs": [ + { + "OperatorType": "Concatenate", + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "L:0,R:0,R:1", + "TableName": "`user`_user_extra", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select a.id from `user` as a where 1 != 1", + "Query": "select a.id from `user` as a", + "Table": "`user`" + }, + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select b.id, weight_string(b.id) from user_extra as b where 1 != 1", + "Query": "select b.id, weight_string(b.id) from user_extra as b", + "Table": "user_extra" + } + ] + }, + { + "OperatorType": "Route", + "Variant": "Reference", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "FieldQuery": "select 1, 2, weight_string(2) from dual where 1 != 1", + "Query": "select 1, 2, weight_string(2) from dual", + "Table": "dual" + } + ] + } + ] + }, + "TablesUsed": [ + "main.dual", + "user.user", + "user.user_extra" + ] + } } ] diff --git a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json index 5c8bcad0c57..8007a0e1a0a 100644 --- a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json @@ -179,11 +179,6 @@ "query": "select id2 from user uu where id in (select id from user where id = uu.id and user.col in (select col from (select col, id, user_id from user_extra where user_id = 5) uu where uu.user_id = uu.id))", "plan": "VT12001: unsupported: correlated subquery is only supported for EXISTS" }, - { - "comment": "rewrite of 'order by 2' that becomes 'order by id', leading to ambiguous binding.", - "query": "select a.id, b.id from user as a, user_extra as b union select 1, 2 order by 2", - "plan": "Column 'id' in field list is ambiguous" - }, { "comment": "unsupported with clause in delete statement", "query": "with x as (select * from user) delete from x", diff --git a/go/vt/vtgate/semantics/analyzer.go b/go/vt/vtgate/semantics/analyzer.go index cf2b3300208..0fe9f4a934e 100644 --- a/go/vt/vtgate/semantics/analyzer.go +++ b/go/vt/vtgate/semantics/analyzer.go @@ -69,10 +69,12 @@ func (a *analyzer) lateInit() { a.binder = newBinder(a.scoper, a, a.tables, a.typer) a.scoper.binder = a.binder a.rewriter = &earlyRewriter{ - env: a.si.Environment(), - scoper: a.scoper, binder: a.binder, + scoper: a.scoper, expandedColumns: map[sqlparser.TableName][]*sqlparser.ColName{}, + env: a.si.Environment(), + aliasMapCache: map[*sqlparser.Select]map[string]exprContainer{}, + reAnalyze: a.lateAnalyze, } } @@ -232,10 +234,6 @@ func (a *analyzer) analyzeUp(cursor *sqlparser.Cursor) bool { return false } - if err := a.scoper.up(cursor); err != nil { - a.setError(err) - return false - } if err := a.tables.up(cursor); err != nil { a.setError(err) return false @@ -256,6 +254,11 @@ func (a *analyzer) analyzeUp(cursor *sqlparser.Cursor) bool { return true } + if err := a.scoper.up(cursor); err != nil { + a.setError(err) + return false + } + a.leaveProjection(cursor) return a.shouldContinue() } @@ -348,6 +351,10 @@ func (a *analyzer) analyze(statement sqlparser.Statement) error { a.lateInit() + return a.lateAnalyze(statement) +} + +func (a *analyzer) lateAnalyze(statement sqlparser.SQLNode) error { _ = sqlparser.Rewrite(statement, a.analyzeDown, a.analyzeUp) return a.err } diff --git a/go/vt/vtgate/semantics/binder.go b/go/vt/vtgate/semantics/binder.go index f5e7d3c6297..b010649e067 100644 --- a/go/vt/vtgate/semantics/binder.go +++ b/go/vt/vtgate/semantics/binder.go @@ -57,7 +57,8 @@ func newBinder(scoper *scoper, org originable, tc *tableCollector, typer *typer) } func (b *binder) up(cursor *sqlparser.Cursor) error { - switch node := cursor.Node().(type) { + node := cursor.Node() + switch node := node.(type) { case *sqlparser.Subquery: currScope := b.scoper.currentScope() b.setSubQueryDependencies(node, currScope) @@ -65,7 +66,7 @@ func (b *binder) up(cursor *sqlparser.Cursor) error { currScope := b.scoper.currentScope() for _, ident := range node.Using { name := sqlparser.NewColName(ident.String()) - deps, err := b.resolveColumn(name, currScope, true) + deps, err := b.resolveColumn(name, currScope, true, true) if err != nil { return err } @@ -73,7 +74,7 @@ func (b *binder) up(cursor *sqlparser.Cursor) error { } case *sqlparser.ColName: currentScope := b.scoper.currentScope() - deps, err := b.resolveColumn(node, currentScope, false) + deps, err := b.resolveColumn(node, currentScope, false, true) if err != nil { if deps.direct.IsEmpty() || !strings.HasSuffix(err.Error(), "is ambiguous") || @@ -185,7 +186,7 @@ func (b *binder) rewriteJoinUsingColName(deps dependency, node *sqlparser.ColNam return dependency{}, err } node.Qualifier = name - deps, err = b.resolveColumn(node, currentScope, false) + deps, err = b.resolveColumn(node, currentScope, false, true) if err != nil { return dependency{}, err } @@ -226,7 +227,7 @@ func (b *binder) setSubQueryDependencies(subq *sqlparser.Subquery, currScope *sc b.direct[subq] = subqDirectDeps.KeepOnly(tablesToKeep) } -func (b *binder) resolveColumn(colName *sqlparser.ColName, current *scope, allowMulti bool) (dependency, error) { +func (b *binder) resolveColumn(colName *sqlparser.ColName, current *scope, allowMulti, singleTableFallBack bool) (dependency, error) { var thisDeps dependencies first := true var tableName *sqlparser.TableName @@ -248,7 +249,7 @@ func (b *binder) resolveColumn(colName *sqlparser.ColName, current *scope, allow } else if err != nil { return dependency{}, err } - if current.parent == nil && len(current.tables) == 1 && first && colName.Qualifier.IsEmpty() { + if current.parent == nil && len(current.tables) == 1 && first && colName.Qualifier.IsEmpty() && singleTableFallBack { // if this is the top scope, and we still haven't been able to find a match, we know we are about to fail // we can check this last scope and see if there is a single table. if there is just one table in the scope // we assume that the column is meant to come from this table. @@ -263,7 +264,7 @@ func (b *binder) resolveColumn(colName *sqlparser.ColName, current *scope, allow first = false current = current.parent } - return dependency{}, ShardedError{&ColumnNotFoundError{Column: colName, Table: tableName}} + return dependency{}, ShardedError{ColumnNotFoundError{Column: colName, Table: tableName}} } func (b *binder) resolveColumnInScope(current *scope, expr *sqlparser.ColName, allowMulti bool) (dependencies, error) { diff --git a/go/vt/vtgate/semantics/early_rewriter.go b/go/vt/vtgate/semantics/early_rewriter.go index ed1f30c670e..646b5b71e41 100644 --- a/go/vt/vtgate/semantics/early_rewriter.go +++ b/go/vt/vtgate/semantics/early_rewriter.go @@ -34,6 +34,12 @@ type earlyRewriter struct { warning string expandedColumns map[sqlparser.TableName][]*sqlparser.ColName env *vtenv.Environment + aliasMapCache map[*sqlparser.Select]map[string]exprContainer + + // reAnalyze is used when we are running in the late stage, after the other parts of semantic analysis + // have happened, and we are introducing or changing the AST. We invoke it so all parts of the query have been + // typed, scoped and bound correctly + reAnalyze func(n sqlparser.SQLNode) error } func (r *earlyRewriter) down(cursor *sqlparser.Cursor) error { @@ -44,14 +50,6 @@ func (r *earlyRewriter) down(cursor *sqlparser.Cursor) error { return r.handleSelectExprs(cursor, node) case *sqlparser.JoinTableExpr: r.handleJoinTableExprDown(node) - case sqlparser.OrderBy: - r.clause = "order clause" - iter := &orderByIterator{ - node: node, - idx: -1, - } - - return r.handleOrderByAndGroupBy(cursor.Parent(), iter) case *sqlparser.OrExpr: rewriteOrExpr(r.env, cursor, node) case *sqlparser.AndExpr: @@ -64,7 +62,7 @@ func (r *earlyRewriter) down(cursor *sqlparser.Cursor) error { node: node, idx: -1, } - return r.handleOrderByAndGroupBy(cursor.Parent(), iter) + return r.handleGroupBy(cursor.Parent(), iter) case *sqlparser.ComparisonExpr: return handleComparisonExpr(cursor, node) case *sqlparser.With: @@ -77,6 +75,26 @@ func (r *earlyRewriter) down(cursor *sqlparser.Cursor) error { return nil } +func (r *earlyRewriter) up(cursor *sqlparser.Cursor) error { + switch node := cursor.Node().(type) { + case *sqlparser.JoinTableExpr: + return r.handleJoinTableExprUp(node) + case *sqlparser.AliasedTableExpr: + // this rewriting is done in the `up` phase, because we need the vindex hints to have been + // processed while collecting the tables. + return removeVindexHints(node) + case sqlparser.OrderBy: + r.clause = "order clause" + iter := &orderByIterator{ + node: node, + idx: -1, + r: r, + } + return r.handleOrderBy(cursor.Parent(), iter) + } + return nil +} + func handleDelete(del *sqlparser.Delete) error { // When we do not have any target, it is a single table delete. // In a single table delete, the table references is always a single aliased table expression. @@ -144,18 +162,6 @@ func rewriteNotExpr(cursor *sqlparser.Cursor, node *sqlparser.NotExpr) { cursor.Replace(cmp) } -func (r *earlyRewriter) up(cursor *sqlparser.Cursor) error { - switch node := cursor.Node().(type) { - case *sqlparser.JoinTableExpr: - return r.handleJoinTableExprUp(node) - case *sqlparser.AliasedTableExpr: - // this rewriting is done in the `up` phase, because we need the vindex hints to have been - // processed while collecting the tables. - return removeVindexHints(node) - } - return nil -} - func (r *earlyRewriter) handleJoinTableExprUp(join *sqlparser.JoinTableExpr) error { // this rewriting is done in the `up` phase, because we need the scope to have been // filled in with the available tables @@ -170,16 +176,8 @@ func (r *earlyRewriter) handleJoinTableExprUp(join *sqlparser.JoinTableExpr) err // since the binder has already been over the join, we need to invoke it again, so it // can bind columns to the right tables - sqlparser.Rewrite(join.Condition.On, nil, func(cursor *sqlparser.Cursor) bool { - innerErr := r.binder.up(cursor) - if innerErr == nil { - return true - } - err = innerErr - return false - }) - return err + return r.reAnalyze(join.Condition.On) } // removeVindexHints removes the vindex hints from the aliased table expression provided. @@ -207,7 +205,7 @@ func (r *earlyRewriter) handleWhereClause(node *sqlparser.Where, parent sqlparse if node.Type != sqlparser.HavingClause { return nil } - expr, err := r.rewriteAliasesInOrderByHavingAndGroupBy(node.Expr, sel) + expr, err := r.rewriteAliasesInHavingAndGroupBy(node.Expr, sel) if err != nil { return err } @@ -237,6 +235,7 @@ func (r *earlyRewriter) handleJoinTableExprDown(node *sqlparser.JoinTableExpr) { type orderByIterator struct { node sqlparser.OrderBy idx int + r *earlyRewriter } func (it *orderByIterator) next() sqlparser.Expr { @@ -249,7 +248,7 @@ func (it *orderByIterator) next() sqlparser.Expr { return it.node[it.idx].Expr } -func (it *orderByIterator) replace(e sqlparser.Expr) error { +func (it *orderByIterator) replace(e sqlparser.Expr) (err error) { if it.idx >= len(it.node) { return vterrors.VT13001("went past the last item") } @@ -285,13 +284,57 @@ type iterator interface { replace(e sqlparser.Expr) error } -func (r *earlyRewriter) replaceLiteralsInOrderByGroupBy(e sqlparser.Expr, iter iterator) (bool, error) { +func (r *earlyRewriter) replaceLiteralsInOrderBy(e sqlparser.Expr, iter iterator) (bool, error) { + lit := getIntLiteral(e) + if lit == nil { + return false, nil + } + + newExpr, recheck, err := r.rewriteOrderByExpr(lit) + if err != nil { + return false, err + } + + if getIntLiteral(newExpr) == nil { + coll, ok := e.(*sqlparser.CollateExpr) + if ok { + coll.Expr = newExpr + newExpr = coll + } + } else { + // the expression is still a literal int. that means that we don't really need to sort by it. + // we'll just replace the number with a string instead, just like mysql would do in this situation + // mysql> explain select 1 as foo from user group by 1; + // + // mysql> show warnings; + // +-------+------+-----------------------------------------------------------------+ + // | Level | Code | Message | + // +-------+------+-----------------------------------------------------------------+ + // | Note | 1003 | /* select#1 */ select 1 AS `foo` from `test`.`user` group by '' | + // +-------+------+-----------------------------------------------------------------+ + newExpr = sqlparser.NewStrLiteral("") + } + + err = iter.replace(newExpr) + if err != nil { + return false, err + } + if recheck { + err = r.reAnalyze(newExpr) + } + if err != nil { + return false, err + } + return true, nil +} + +func (r *earlyRewriter) replaceLiteralsInGroupBy(e sqlparser.Expr, iter iterator) (bool, error) { lit := getIntLiteral(e) if lit == nil { return false, nil } - newExpr, err := r.rewriteOrderByExpr(lit) + newExpr, err := r.rewriteGroupByExpr(lit) if err != nil { return false, err } @@ -341,7 +384,41 @@ func getIntLiteral(e sqlparser.Expr) *sqlparser.Literal { } // handleOrderBy processes the ORDER BY clause. -func (r *earlyRewriter) handleOrderByAndGroupBy(parent sqlparser.SQLNode, iter iterator) error { +func (r *earlyRewriter) handleOrderBy(parent sqlparser.SQLNode, iter iterator) error { + stmt, ok := parent.(sqlparser.SelectStatement) + if !ok { + return nil + } + + sel := sqlparser.GetFirstSelect(stmt) + for e := iter.next(); e != nil; e = iter.next() { + lit, err := r.replaceLiteralsInOrderBy(e, iter) + if err != nil { + return err + } + if lit { + continue + } + + expr, err := r.rewriteAliasesInOrderBy(e, sel) + if err != nil { + return err + } + + if err = iter.replace(expr); err != nil { + return err + } + + if err = r.reAnalyze(expr); err != nil { + return err + } + } + + return nil +} + +// handleGroupBy processes the GROUP BY clause. +func (r *earlyRewriter) handleGroupBy(parent sqlparser.SQLNode, iter iterator) error { stmt, ok := parent.(sqlparser.SelectStatement) if !ok { return nil @@ -349,14 +426,14 @@ func (r *earlyRewriter) handleOrderByAndGroupBy(parent sqlparser.SQLNode, iter i sel := sqlparser.GetFirstSelect(stmt) for e := iter.next(); e != nil; e = iter.next() { - lit, err := r.replaceLiteralsInOrderByGroupBy(e, iter) + lit, err := r.replaceLiteralsInGroupBy(e, iter) if err != nil { return err } if lit { continue } - expr, err := r.rewriteAliasesInOrderByHavingAndGroupBy(e, sel) + expr, err := r.rewriteAliasesInHavingAndGroupBy(e, sel) if err != nil { return err } @@ -375,7 +452,7 @@ func (r *earlyRewriter) handleOrderByAndGroupBy(parent sqlparser.SQLNode, iter i // in SELECT points to that expression, not any table column. // - However, if the aliased expression is an aggregation and the column identifier in // the HAVING/ORDER BY clause is inside an aggregation function, the rule does not apply. -func (r *earlyRewriter) rewriteAliasesInOrderByHavingAndGroupBy(node sqlparser.Expr, sel *sqlparser.Select) (expr sqlparser.Expr, err error) { +func (r *earlyRewriter) rewriteAliasesInHavingAndGroupBy(node sqlparser.Expr, sel *sqlparser.Select) (expr sqlparser.Expr, err error) { type ExprContainer struct { expr sqlparser.Expr ambiguous bool @@ -467,7 +544,176 @@ func (r *earlyRewriter) rewriteAliasesInOrderByHavingAndGroupBy(node sqlparser.E return } -func (r *earlyRewriter) rewriteOrderByExpr(node *sqlparser.Literal) (sqlparser.Expr, error) { +// rewriteAliasesInOrderBy rewrites columns in the ORDER BY and HAVING clauses to use aliases +// from the SELECT expressions when applicable, following MySQL scoping rules: +// - A column identifier without a table qualifier that matches an alias introduced +// in SELECT points to that expression, not any table column. +// - However, if the aliased expression is an aggregation and the column identifier in +// the HAVING/ORDER BY clause is inside an aggregation function, the rule does not apply. +func (r *earlyRewriter) rewriteAliasesInOrderBy(node sqlparser.Expr, sel *sqlparser.Select) (expr sqlparser.Expr, err error) { + currentScope := r.scoper.currentScope() + if currentScope.isUnion { + // It is not safe to rewrite order by clauses in unions. + return node, nil + } + + aliases := r.getAliasMap(sel) + insideAggr := false + dontEnterSubquery := func(node, _ sqlparser.SQLNode) bool { + switch node.(type) { + case *sqlparser.Subquery: + return false + case sqlparser.AggrFunc: + insideAggr = true + } + + _, isSubq := node.(*sqlparser.Subquery) + return !isSubq + } + output := sqlparser.CopyOnRewrite(node, dontEnterSubquery, func(cursor *sqlparser.CopyOnWriteCursor) { + var col *sqlparser.ColName + + switch node := cursor.Node().(type) { + case sqlparser.AggrFunc: + insideAggr = false + return + case *sqlparser.ColName: + col = node + default: + return + } + + if !col.Qualifier.IsEmpty() { + // we are only interested in columns not qualified by table names + return + } + + item, found := aliases[col.Name.Lowered()] + if !found { + // if there is no matching alias, there is no rewriting needed + return + } + + topLevel := col == node + if !topLevel && r.isColumnOnTable(col, currentScope) { + // we only want to replace columns that are not coming from the table + return + } + + if item.ambiguous { + err = &AmbiguousColumnError{Column: sqlparser.String(col)} + } else if insideAggr && sqlparser.ContainsAggregation(item.expr) { + err = &InvalidUserOfGroupFunction{} + } + if err != nil { + cursor.StopTreeWalk() + return + } + + cursor.Replace(sqlparser.CloneExpr(item.expr)) + }, nil) + + expr = output.(sqlparser.Expr) + return +} + +func (r *earlyRewriter) isColumnOnTable(col *sqlparser.ColName, currentScope *scope) bool { + if !currentScope.stmtScope && currentScope.parent != nil { + currentScope = currentScope.parent + } + _, err := r.binder.resolveColumn(col, currentScope, false, false) + return err == nil +} + +func (r *earlyRewriter) getAliasMap(sel *sqlparser.Select) (aliases map[string]exprContainer) { + var found bool + aliases, found = r.aliasMapCache[sel] + if found { + return + } + aliases = map[string]exprContainer{} + for _, e := range sel.SelectExprs { + ae, ok := e.(*sqlparser.AliasedExpr) + if !ok { + continue + } + + var alias string + + item := exprContainer{expr: ae.Expr} + if ae.As.NotEmpty() { + alias = ae.As.Lowered() + } else if col, ok := ae.Expr.(*sqlparser.ColName); ok { + alias = col.Name.Lowered() + } + + if old, alreadyExists := aliases[alias]; alreadyExists && !sqlparser.Equals.Expr(old.expr, item.expr) { + item.ambiguous = true + } + + aliases[alias] = item + } + return aliases +} + +type exprContainer struct { + expr sqlparser.Expr + ambiguous bool +} + +func (r *earlyRewriter) rewriteOrderByExpr(node *sqlparser.Literal) (expr sqlparser.Expr, needReAnalysis bool, err error) { + scope, found := r.scoper.specialExprScopes[node] + if !found { + return node, false, nil + } + num, err := strconv.Atoi(node.Val) + if err != nil { + return nil, false, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "error parsing column number: %s", node.Val) + } + + stmt, isSel := scope.stmt.(*sqlparser.Select) + if !isSel { + return nil, false, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "error invalid statement type, expect Select, got: %T", scope.stmt) + } + + if num < 1 || num > len(stmt.SelectExprs) { + return nil, false, vterrors.NewErrorf(vtrpcpb.Code_INVALID_ARGUMENT, vterrors.BadFieldError, "Unknown column '%d' in '%s'", num, r.clause) + } + + // We loop like this instead of directly accessing the offset, to make sure there are no unexpanded `*` before + for i := 0; i < num; i++ { + if _, ok := stmt.SelectExprs[i].(*sqlparser.AliasedExpr); !ok { + return nil, false, vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "cannot use column offsets in %s when using `%s`", r.clause, sqlparser.String(stmt.SelectExprs[i])) + } + } + + colOffset := num - 1 + aliasedExpr, ok := stmt.SelectExprs[colOffset].(*sqlparser.AliasedExpr) + if !ok { + return nil, false, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "don't know how to handle %s", sqlparser.String(node)) + } + + if scope.isUnion { + colName := sqlparser.NewColName(aliasedExpr.ColumnName()) + vtabl, ok := scope.tables[0].(*vTableInfo) + if !ok { + panic("BUG: not expected") + } + + // since column names can be ambiguous here, we want to do the binding by offset and not by column name + allColExprs := vtabl.cols[colOffset] + direct, recursive, typ := r.binder.org.depsForExpr(allColExprs) + r.binder.direct[colName] = direct + r.binder.recursive[colName] = recursive + r.binder.typer.m[colName] = typ + + return colName, false, nil + } + + return realCloneOfColNames(aliasedExpr.Expr, false), true, nil +} + +func (r *earlyRewriter) rewriteGroupByExpr(node *sqlparser.Literal) (sqlparser.Expr, error) { scope, found := r.scoper.specialExprScopes[node] if !found { return node, nil @@ -499,13 +745,8 @@ func (r *earlyRewriter) rewriteOrderByExpr(node *sqlparser.Literal) (sqlparser.E } if scope.isUnion { - col, isCol := aliasedExpr.Expr.(*sqlparser.ColName) - - if aliasedExpr.As.IsEmpty() && isCol { - return sqlparser.NewColName(col.Name.String()), nil - } - - return sqlparser.NewColName(aliasedExpr.ColumnName()), nil + colName := sqlparser.NewColName(aliasedExpr.ColumnName()) + return colName, nil } return realCloneOfColNames(aliasedExpr.Expr, false), nil diff --git a/go/vt/vtgate/semantics/early_rewriter_test.go b/go/vt/vtgate/semantics/early_rewriter_test.go index e681f722b1d..cf93a52447c 100644 --- a/go/vt/vtgate/semantics/early_rewriter_test.go +++ b/go/vt/vtgate/semantics/early_rewriter_test.go @@ -304,42 +304,84 @@ func TestRewriteJoinUsingColumns(t *testing.T) { } -func TestOrderByGroupByLiteral(t *testing.T) { +func TestGroupByLiteral(t *testing.T) { schemaInfo := &FakeSI{ Tables: map[string]*vindexes.Table{}, } cDB := "db" tcases := []struct { - sql string - expSQL string - expErr string + sql string + expSQL string + expDeps TableSet + expErr string }{{ - sql: "select 1 as id from t1 order by 1", - expSQL: "select 1 as id from t1 order by '' asc", + sql: "select t1.col from t1 group by 1", + expSQL: "select t1.col from t1 group by t1.col", + expDeps: TS0, }, { - sql: "select t1.col from t1 order by 1", - expSQL: "select t1.col from t1 order by t1.col asc", + sql: "select t1.col as xyz from t1 group by 1", + expSQL: "select t1.col as xyz from t1 group by t1.col", + expDeps: TS0, }, { - sql: "select t1.col from t1 order by 1.0", - expSQL: "select t1.col from t1 order by 1.0 asc", + sql: "select id from t1 group by 2", + expErr: "Unknown column '2' in 'group clause'", }, { - sql: "select t1.col from t1 order by 'fubick'", - expSQL: "select t1.col from t1 order by 'fubick' asc", + sql: "select *, id from t1 group by 2", + expErr: "cannot use column offsets in group clause when using `*`", + }} + for _, tcase := range tcases { + t.Run(tcase.sql, func(t *testing.T) { + ast, err := sqlparser.NewTestParser().Parse(tcase.sql) + require.NoError(t, err) + selectStatement := ast.(*sqlparser.Select) + st, err := Analyze(selectStatement, cDB, schemaInfo) + if tcase.expErr == "" { + require.NoError(t, err) + assert.Equal(t, tcase.expSQL, sqlparser.String(selectStatement)) + gb := selectStatement.GroupBy + deps := st.RecursiveDeps(gb[0]) + assert.Equal(t, tcase.expDeps, deps) + } else { + require.EqualError(t, err, tcase.expErr) + } + }) + } +} + +func TestOrderByLiteral(t *testing.T) { + schemaInfo := &FakeSI{ + Tables: map[string]*vindexes.Table{}, + } + cDB := "db" + tcases := []struct { + sql string + expSQL string + expDeps TableSet + expErr string + }{{ + sql: "select 1 as id from t1 order by 1", + expSQL: "select 1 as id from t1 order by '' asc", + expDeps: NoTables, }, { - sql: "select t1.col as foo from t1 order by 1", - expSQL: "select t1.col as foo from t1 order by t1.col asc", + sql: "select t1.col from t1 order by 1", + expSQL: "select t1.col from t1 order by t1.col asc", + expDeps: TS0, }, { - sql: "select t1.col from t1 group by 1", - expSQL: "select t1.col from t1 group by t1.col", + sql: "select t1.col from t1 order by 1.0", + expSQL: "select t1.col from t1 order by 1.0 asc", + expDeps: NoTables, }, { - sql: "select t1.col as xyz from t1 group by 1", - expSQL: "select t1.col as xyz from t1 group by t1.col", + sql: "select t1.col from t1 order by 'fubick'", + expSQL: "select t1.col from t1 order by 'fubick' asc", + expDeps: NoTables, }, { - sql: "select t1.col as xyz, count(*) from t1 group by 1 order by 2", - expSQL: "select t1.col as xyz, count(*) from t1 group by t1.col order by count(*) asc", + sql: "select t1.col as foo from t1 order by 1", + expSQL: "select t1.col as foo from t1 order by t1.col asc", + expDeps: TS0, }, { - sql: "select id from t1 group by 2", - expErr: "Unknown column '2' in 'group clause'", + sql: "select t1.col as xyz, count(*) from t1 group by 1 order by 2", + expSQL: "select t1.col as xyz, count(*) from t1 group by t1.col order by count(*) asc", + expDeps: TS0, }, { sql: "select id from t1 order by 2", expErr: "Unknown column '2' in 'order clause'", @@ -347,27 +389,41 @@ func TestOrderByGroupByLiteral(t *testing.T) { sql: "select *, id from t1 order by 2", expErr: "cannot use column offsets in order clause when using `*`", }, { - sql: "select *, id from t1 group by 2", - expErr: "cannot use column offsets in group clause when using `*`", + sql: "select id from t1 order by 1 collate utf8_general_ci", + expSQL: "select id from t1 order by id collate utf8_general_ci asc", + expDeps: TS0, + }, { + sql: "select id from `user` union select 1 from dual order by 1", + expSQL: "select id from `user` union select 1 from dual order by id asc", + expDeps: TS0, }, { - sql: "select id from t1 order by 1 collate utf8_general_ci", - expSQL: "select id from t1 order by id collate utf8_general_ci asc", + sql: "select id from t1 order by 2", + expErr: "Unknown column '2' in 'order clause'", }, { - sql: "select a.id from `user` union select 1 from dual order by 1", - expSQL: "select a.id from `user` union select 1 from dual order by id asc", + sql: "select a.id, b.id from user as a, user_extra as b union select 1, 2 order by 1", + expSQL: "select a.id, b.id from `user` as a, user_extra as b union select 1, 2 from dual order by id asc", + expDeps: TS0, }, { - sql: "select a.id, b.id from user as a, user_extra as b union select 1, 2 order by 1", - expErr: "Column 'id' in field list is ambiguous", + sql: "select a.id, b.id from user as a, user_extra as b union select 1, 2 order by 2", + expSQL: "select a.id, b.id from `user` as a, user_extra as b union select 1, 2 from dual order by id asc", + expDeps: TS1, + }, { + sql: "select user.id as foo from user union select col from user_extra order by 1", + expSQL: "select `user`.id as foo from `user` union select col from user_extra order by foo asc", + expDeps: MergeTableSets(TS0, TS1), }} for _, tcase := range tcases { t.Run(tcase.sql, func(t *testing.T) { ast, err := sqlparser.NewTestParser().Parse(tcase.sql) require.NoError(t, err) selectStatement := ast.(sqlparser.SelectStatement) - _, err = Analyze(selectStatement, cDB, schemaInfo) + st, err := Analyze(selectStatement, cDB, schemaInfo) if tcase.expErr == "" { require.NoError(t, err) assert.Equal(t, tcase.expSQL, sqlparser.String(selectStatement)) + ordering := selectStatement.GetOrderBy() + deps := st.RecursiveDeps(ordering[0].Expr) + assert.Equal(t, tcase.expDeps, deps) } else { require.EqualError(t, err, tcase.expErr) } @@ -375,7 +431,7 @@ func TestOrderByGroupByLiteral(t *testing.T) { } } -func TestHavingAndOrderByColumnName(t *testing.T) { +func TestHavingColumnName(t *testing.T) { schemaInfo := &FakeSI{ Tables: map[string]*vindexes.Table{}, } @@ -388,28 +444,97 @@ func TestHavingAndOrderByColumnName(t *testing.T) { sql: "select id, sum(foo) as sumOfFoo from t1 having sumOfFoo > 1", expSQL: "select id, sum(foo) as sumOfFoo from t1 having sum(foo) > 1", }, { + sql: "select id, sum(foo) as foo from t1 having sum(foo) > 1", + expSQL: "select id, sum(foo) as foo from t1 having sum(foo) > 1", + }, { + sql: "select foo + 2 as foo from t1 having foo = 42", + expSQL: "select foo + 2 as foo from t1 having foo + 2 = 42", + }} + for _, tcase := range tcases { + t.Run(tcase.sql, func(t *testing.T) { + ast, err := sqlparser.NewTestParser().Parse(tcase.sql) + require.NoError(t, err) + selectStatement := ast.(sqlparser.SelectStatement) + _, err = Analyze(selectStatement, cDB, schemaInfo) + if tcase.expErr == "" { + require.NoError(t, err) + assert.Equal(t, tcase.expSQL, sqlparser.String(selectStatement)) + } else { + require.EqualError(t, err, tcase.expErr) + } + }) + } +} + +func TestOrderByColumnName(t *testing.T) { + schemaInfo := &FakeSI{ + Tables: map[string]*vindexes.Table{ + "t1": { + Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true}, + Name: sqlparser.NewIdentifierCS("t1"), + Columns: []vindexes.Column{{ + Name: sqlparser.NewIdentifierCI("id"), + Type: sqltypes.VarChar, + }, { + Name: sqlparser.NewIdentifierCI("foo"), + Type: sqltypes.VarChar, + }, { + Name: sqlparser.NewIdentifierCI("bar"), + Type: sqltypes.VarChar, + }}, + ColumnListAuthoritative: true, + }, + }, + } + cDB := "db" + tcases := []struct { + sql string + expSQL string + expErr string + }{{ sql: "select id, sum(foo) as sumOfFoo from t1 order by sumOfFoo", expSQL: "select id, sum(foo) as sumOfFoo from t1 order by sum(foo) asc", }, { - sql: "select id, sum(foo) as foo from t1 having sum(foo) > 1", - expSQL: "select id, sum(foo) as foo from t1 having sum(foo) > 1", + sql: "select id, sum(foo) as sumOfFoo from t1 order by sumOfFoo + 1", + expSQL: "select id, sum(foo) as sumOfFoo from t1 order by sum(foo) + 1 asc", + }, { + sql: "select id, sum(foo) as sumOfFoo from t1 order by abs(sumOfFoo)", + expSQL: "select id, sum(foo) as sumOfFoo from t1 order by abs(sum(foo)) asc", + }, { + sql: "select id, sum(foo) as sumOfFoo from t1 order by max(sumOfFoo)", + expErr: "Invalid use of group function", + }, { + sql: "select id, sum(foo) as foo from t1 order by foo + 1", + expSQL: "select id, sum(foo) as foo from t1 order by foo + 1 asc", + }, { + sql: "select id, sum(foo) as foo from t1 order by foo", + expSQL: "select id, sum(foo) as foo from t1 order by sum(foo) asc", }, { sql: "select id, lower(min(foo)) as foo from t1 order by min(foo)", expSQL: "select id, lower(min(foo)) as foo from t1 order by min(foo) asc", }, { - // invalid according to group by rules, but still accepted by mysql - sql: "select id, t1.bar as foo from t1 group by id order by min(foo)", - expSQL: "select id, t1.bar as foo from t1 group by id order by min(t1.bar) asc", + sql: "select id, lower(min(foo)) as foo from t1 order by foo", + expSQL: "select id, lower(min(foo)) as foo from t1 order by lower(min(foo)) asc", }, { - sql: "select foo + 2 as foo from t1 having foo = 42", - expSQL: "select foo + 2 as foo from t1 having foo + 2 = 42", + sql: "select id, lower(min(foo)) as foo from t1 order by abs(foo)", + expSQL: "select id, lower(min(foo)) as foo from t1 order by abs(foo) asc", }, { - sql: "select id, b as id, count(*) from t1 order by id", + sql: "select id, t1.bar as foo from t1 group by id order by min(foo)", + expSQL: "select id, t1.bar as foo from t1 group by id order by min(foo) asc", + }, { + sql: "select id, bar as id, count(*) from t1 order by id", expErr: "Column 'id' in field list is ambiguous", }, { sql: "select id, id, count(*) from t1 order by id", expSQL: "select id, id, count(*) from t1 order by id asc", - }} + }, { + sql: "select id, count(distinct foo) k from t1 group by id order by k", + expSQL: "select id, count(distinct foo) as k from t1 group by id order by count(distinct foo) asc", + }, { + sql: "select user.id as foo from user union select col from user_extra order by foo", + expSQL: "select `user`.id as foo from `user` union select col from user_extra order by foo asc", + }, + } for _, tcase := range tcases { t.Run(tcase.sql, func(t *testing.T) { ast, err := sqlparser.NewTestParser().Parse(tcase.sql) diff --git a/go/vt/vtgate/semantics/errors.go b/go/vt/vtgate/semantics/errors.go index 0be85633632..a903408ba9d 100644 --- a/go/vt/vtgate/semantics/errors.go +++ b/go/vt/vtgate/semantics/errors.go @@ -52,6 +52,7 @@ type ( SubqueryColumnCountError struct{ Expected int } ColumnsMissingInSchemaError struct{} CantUseMultipleVindexHints struct{ Table string } + InvalidUserOfGroupFunction struct{} NoSuchVindexFound struct { Table string @@ -213,18 +214,18 @@ func (e *BuggyError) Error() string { func (e *BuggyError) bug() {} // ColumnNotFoundError -func (e *ColumnNotFoundError) Error() string { +func (e ColumnNotFoundError) Error() string { if e.Table == nil { return eprintf(e, "column '%s' not found", sqlparser.String(e.Column)) } return eprintf(e, "column '%s' not found in table '%s'", sqlparser.String(e.Column), sqlparser.String(e.Table)) } -func (e *ColumnNotFoundError) ErrorCode() vtrpcpb.Code { +func (e ColumnNotFoundError) ErrorCode() vtrpcpb.Code { return vtrpcpb.Code_INVALID_ARGUMENT } -func (e *ColumnNotFoundError) ErrorState() vterrors.State { +func (e ColumnNotFoundError) ErrorState() vterrors.State { return vterrors.BadFieldError } @@ -241,6 +242,7 @@ func (e *AmbiguousColumnError) ErrorCode() vtrpcpb.Code { return vtrpcpb.Code_INVALID_ARGUMENT } +// UnsupportedConstruct func (e *UnsupportedConstruct) unsupported() {} func (e *UnsupportedConstruct) ErrorCode() vtrpcpb.Code { @@ -251,6 +253,7 @@ func (e *UnsupportedConstruct) Error() string { return eprintf(e, e.errString) } +// SubqueryColumnCountError func (e *SubqueryColumnCountError) ErrorCode() vtrpcpb.Code { return vtrpcpb.Code_INVALID_ARGUMENT } @@ -259,7 +262,7 @@ func (e *SubqueryColumnCountError) Error() string { return fmt.Sprintf("Operand should contain %d column(s)", e.Expected) } -// MissingInVSchemaError +// ColumnsMissingInSchemaError func (e *ColumnsMissingInSchemaError) Error() string { return "VT09015: schema tracking required" } @@ -277,7 +280,7 @@ func (c *CantUseMultipleVindexHints) ErrorCode() vtrpcpb.Code { return vtrpcpb.Code_FAILED_PRECONDITION } -// CantUseMultipleVindexHints +// NoSuchVindexFound func (c *NoSuchVindexFound) Error() string { return vterrors.VT09021(c.VindexName, c.Table).Error() } @@ -285,3 +288,16 @@ func (c *NoSuchVindexFound) Error() string { func (c *NoSuchVindexFound) ErrorCode() vtrpcpb.Code { return vtrpcpb.Code_FAILED_PRECONDITION } + +// InvalidUserOfGroupFunction +func (*InvalidUserOfGroupFunction) Error() string { + return "Invalid use of group function" +} + +func (*InvalidUserOfGroupFunction) ErrorCode() vtrpcpb.Code { + return vtrpcpb.Code_INVALID_ARGUMENT +} + +func (*InvalidUserOfGroupFunction) ErrorState() vterrors.State { + return vterrors.InvalidGroupFuncUse +} From ba3531f59d417d053431183d943d6ecd5f206876 Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Thu, 22 Feb 2024 13:47:29 +0100 Subject: [PATCH 48/79] Revert "Skip for-loop alloc in `go/vt/discovery/healthcheck.go`" (#15328) Signed-off-by: Dirkjan Bussink --- go/vt/discovery/healthcheck.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go/vt/discovery/healthcheck.go b/go/vt/discovery/healthcheck.go index 5572e9a41d9..5d6a5e32662 100644 --- a/go/vt/discovery/healthcheck.go +++ b/go/vt/discovery/healthcheck.go @@ -774,7 +774,6 @@ func FilterTargetsByKeyspaces(keyspaces []string, targets []*query.Target) []*qu func (hc *HealthCheckImpl) waitForTablets(ctx context.Context, targets []*query.Target, requireServing bool) error { targets = FilterTargetsByKeyspaces(KeyspacesToWatch, targets) - var tabletHealths []*TabletHealth for { // We nil targets as we find them. allPresent := true @@ -783,6 +782,7 @@ func (hc *HealthCheckImpl) waitForTablets(ctx context.Context, targets []*query. continue } + var tabletHealths []*TabletHealth if requireServing { tabletHealths = hc.GetHealthyTabletStats(target) } else { From 6fec1193efc1393ab3edbab3a1acd56647e7d528 Mon Sep 17 00:00:00 2001 From: Manik Rana Date: Thu, 22 Feb 2024 19:19:15 +0530 Subject: [PATCH 49/79] chore: modernize tests (#15244) Signed-off-by: Manik Rana Signed-off-by: Manik Rana --- go/cache/lru_cache_test.go | 34 ++---- go/cache/theine/singleflight_test.go | 14 ++- go/event/event_test.go | 40 ++---- go/event/syslogger/syslogger_test.go | 63 ++++------ go/flagutil/flagutil_test.go | 10 +- go/history/history_test.go | 12 +- go/mysql/decimal/decimal_test.go | 174 +++++++++------------------ go/streamlog/streamlog_test.go | 2 - go/trace/trace_test.go | 1 - 9 files changed, 116 insertions(+), 234 deletions(-) diff --git a/go/cache/lru_cache_test.go b/go/cache/lru_cache_test.go index e0dbfcda117..af9db72852e 100644 --- a/go/cache/lru_cache_test.go +++ b/go/cache/lru_cache_test.go @@ -18,6 +18,8 @@ package cache import ( "testing" + + "github.com/stretchr/testify/assert" ) type CacheValue struct { @@ -27,24 +29,12 @@ type CacheValue struct { func TestInitialState(t *testing.T) { cache := NewLRUCache[*CacheValue](5) l, sz, c, e, h, m := cache.Len(), cache.UsedCapacity(), cache.MaxCapacity(), cache.Evictions(), cache.Hits(), cache.Misses() - if l != 0 { - t.Errorf("length = %v, want 0", l) - } - if sz != 0 { - t.Errorf("size = %v, want 0", sz) - } - if c != 5 { - t.Errorf("capacity = %v, want 5", c) - } - if e != 0 { - t.Errorf("evictions = %v, want 0", c) - } - if h != 0 { - t.Errorf("hits = %v, want 0", c) - } - if m != 0 { - t.Errorf("misses = %v, want 0", c) - } + assert.Zero(t, l) + assert.EqualValues(t, 0, sz) + assert.EqualValues(t, 5, c) + assert.EqualValues(t, 0, e) + assert.EqualValues(t, 0, h) + assert.EqualValues(t, 0, m) } func TestSetInsertsValue(t *testing.T) { @@ -137,12 +127,8 @@ func TestCapacityIsObeyed(t *testing.T) { // Insert one more; something should be evicted to make room. cache.Set("key4", value) sz, evictions := cache.UsedCapacity(), cache.Evictions() - if sz != size { - t.Errorf("post-evict cache.UsedCapacity() = %v, expected %v", sz, size) - } - if evictions != 1 { - t.Errorf("post-evict cache.Evictions() = %v, expected 1", evictions) - } + assert.Equal(t, size, sz) + assert.EqualValues(t, 1, evictions) // Check various other stats if l := cache.Len(); int64(l) != size { diff --git a/go/cache/theine/singleflight_test.go b/go/cache/theine/singleflight_test.go index 4ae235f97e2..bf5018a8891 100644 --- a/go/cache/theine/singleflight_test.go +++ b/go/cache/theine/singleflight_test.go @@ -43,8 +43,8 @@ func TestDo(t *testing.T) { return "bar", nil }) - assert.Equal(t, "bar (string)", fmt.Sprintf("%v (%T)", v, v), "incorrect Do value") - assert.NoError(t, err, "got Do error") + assert.Equal(t, "bar (string)", fmt.Sprintf("%v (%T)", v, v)) + assert.NoError(t, err) } func TestDoErr(t *testing.T) { @@ -85,11 +85,11 @@ func TestDoDupSuppress(t *testing.T) { defer wg2.Done() wg1.Done() v, err, _ := g.Do("key", fn) - if !assert.NoError(t, err, "unexpected Do error") { + if !assert.NoError(t, err) { return } - assert.Equal(t, "bar", v, "unexpected Do value") + assert.Equal(t, "bar", v) }() } wg1.Wait() @@ -98,7 +98,8 @@ func TestDoDupSuppress(t *testing.T) { c <- "bar" wg2.Wait() got := atomic.LoadInt32(&calls) - assert.True(t, got > 0 && got < n, "number of calls not between 0 and %d", n) + assert.Greater(t, got, int32(0)) + assert.Less(t, got, int32(n)) } // Test singleflight behaves correctly after Do panic. @@ -131,7 +132,7 @@ func TestPanicDo(t *testing.T) { select { case <-done: - assert.Equal(t, int32(n), panicCount, "unexpected number of panics") + assert.EqualValues(t, n, panicCount) case <-time.After(time.Second): require.Fail(t, "Do hangs") } @@ -152,6 +153,7 @@ func TestGoexitDo(t *testing.T) { var err error defer func() { assert.NoError(t, err) + if atomic.AddInt32(&waited, -1) == 0 { close(done) } diff --git a/go/event/event_test.go b/go/event/event_test.go index f7356a98f3e..cdca98abd85 100644 --- a/go/event/event_test.go +++ b/go/event/event_test.go @@ -20,6 +20,8 @@ import ( "reflect" "testing" "time" + + "github.com/stretchr/testify/assert" ) type testInterface1 interface { @@ -56,10 +58,7 @@ func TestStaticListener(t *testing.T) { AddListener(func(testEvent1) { triggered = true }) AddListener(func(testEvent2) { t.Errorf("wrong listener type triggered") }) Dispatch(testEvent1{}) - - if !triggered { - t.Errorf("static listener failed to trigger") - } + assert.True(t, triggered, "static listener failed to trigger") } func TestPointerListener(t *testing.T) { @@ -69,10 +68,7 @@ func TestPointerListener(t *testing.T) { AddListener(func(ev *testEvent2) { ev.triggered = true }) AddListener(func(testEvent2) { t.Errorf("non-pointer listener triggered on pointer type") }) Dispatch(testEvent) - - if !testEvent.triggered { - t.Errorf("pointer listener failed to trigger") - } + assert.True(t, testEvent.triggered, "pointer listener failed to trigger") } func TestInterfaceListener(t *testing.T) { @@ -82,10 +78,7 @@ func TestInterfaceListener(t *testing.T) { AddListener(func(testInterface1) { triggered = true }) AddListener(func(testInterface2) { t.Errorf("interface listener triggered on non-matching type") }) Dispatch(testEvent1{}) - - if !triggered { - t.Errorf("interface listener failed to trigger") - } + assert.True(t, triggered, "interface listener failed to trigger") } func TestEmptyInterfaceListener(t *testing.T) { @@ -94,10 +87,7 @@ func TestEmptyInterfaceListener(t *testing.T) { triggered := false AddListener(func(any) { triggered = true }) Dispatch("this should match any") - - if !triggered { - t.Errorf("any listener failed to trigger") - } + assert.True(t, triggered, "empty listener failed to trigger") } func TestMultipleListeners(t *testing.T) { @@ -144,7 +134,6 @@ func TestBadListenerWrongType(t *testing.T) { defer func() { err := recover() - if err == nil { t.Errorf("bad listener type (not a func) failed to trigger panic") } @@ -186,10 +175,8 @@ func TestDispatchPointerToValueInterfaceListener(t *testing.T) { triggered = true }) Dispatch(&testEvent1{}) + assert.True(t, triggered, "Dispatch by pointer failed to trigger interface listener") - if !triggered { - t.Errorf("Dispatch by pointer failed to trigger interface listener") - } } func TestDispatchValueToValueInterfaceListener(t *testing.T) { @@ -200,10 +187,7 @@ func TestDispatchValueToValueInterfaceListener(t *testing.T) { triggered = true }) Dispatch(testEvent1{}) - - if !triggered { - t.Errorf("Dispatch by value failed to trigger interface listener") - } + assert.True(t, triggered, "Dispatch by value failed to trigger interface listener") } func TestDispatchPointerToPointerInterfaceListener(t *testing.T) { @@ -212,10 +196,8 @@ func TestDispatchPointerToPointerInterfaceListener(t *testing.T) { triggered := false AddListener(func(testInterface2) { triggered = true }) Dispatch(&testEvent2{}) + assert.True(t, triggered, "interface listener failed to trigger for pointer") - if !triggered { - t.Errorf("interface listener failed to trigger for pointer") - } } func TestDispatchValueToPointerInterfaceListener(t *testing.T) { @@ -245,10 +227,8 @@ func TestDispatchUpdate(t *testing.T) { ev := &testUpdateEvent{} DispatchUpdate(ev, "hello") + assert.True(t, triggered, "listener failed to trigger on DispatchUpdate()") - if !triggered { - t.Errorf("listener failed to trigger on DispatchUpdate()") - } want := "hello" if got := ev.update.(string); got != want { t.Errorf("ev.update = %#v, want %#v", got, want) diff --git a/go/event/syslogger/syslogger_test.go b/go/event/syslogger/syslogger_test.go index 28925d2ac52..6c6a181d2e5 100644 --- a/go/event/syslogger/syslogger_test.go +++ b/go/event/syslogger/syslogger_test.go @@ -25,6 +25,8 @@ import ( "testing" "vitess.io/vitess/go/event" + + "github.com/stretchr/testify/assert" ) type TestEvent struct { @@ -70,10 +72,8 @@ func TestSyslog(t *testing.T) { ev := new(TestEvent) event.Dispatch(ev) + assert.True(t, ev.triggered) - if !ev.triggered { - t.Errorf("Syslog() was not called on event that implements Syslogger") - } } // TestBadWriter verifies we are still triggering (to normal logs) if @@ -87,55 +87,40 @@ func TestBadWriter(t *testing.T) { wantLevel := "ERROR" ev := &TestEvent{priority: syslog.LOG_ALERT, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().msg, wantMsg) { - t.Errorf("error log msg [%s], want msg [%s]", tl.getLog().msg, wantMsg) - } - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().msg, wantMsg)) + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) + ev = &TestEvent{priority: syslog.LOG_CRIT, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) + ev = &TestEvent{priority: syslog.LOG_ERR, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) + ev = &TestEvent{priority: syslog.LOG_EMERG, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) wantLevel = "WARNING" ev = &TestEvent{priority: syslog.LOG_WARNING, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) wantLevel = "INFO" ev = &TestEvent{priority: syslog.LOG_INFO, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) + ev = &TestEvent{priority: syslog.LOG_NOTICE, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) + ev = &TestEvent{priority: syslog.LOG_DEBUG, message: wantMsg} event.Dispatch(ev) - if !strings.Contains(tl.getLog().level, wantLevel) { - t.Errorf("error log level [%s], want level [%s]", tl.getLog().level, wantLevel) - } + assert.True(t, strings.Contains(tl.getLog().level, wantLevel)) + assert.True(t, ev.triggered) - if !ev.triggered { - t.Errorf("passed nil writer to client") - } } // TestWriteError checks that we don't panic on a write error. @@ -150,10 +135,8 @@ func TestInvalidSeverity(t *testing.T) { writer = fw event.Dispatch(&TestEvent{priority: syslog.Priority(123), message: "log me"}) + assert.NotEqual(t, "log me", fw.message) - if fw.message == "log me" { - t.Errorf("message was logged despite invalid severity") - } } func testSeverity(sev syslog.Priority, t *testing.T) { @@ -161,13 +144,9 @@ func testSeverity(sev syslog.Priority, t *testing.T) { writer = fw event.Dispatch(&TestEvent{priority: sev, message: "log me"}) + assert.Equal(t, sev, fw.priority) + assert.Equal(t, "log me", fw.message) - if fw.priority != sev { - t.Errorf("wrong priority: got %v, want %v", fw.priority, sev) - } - if fw.message != "log me" { - t.Errorf(`wrong message: got "%v", want "%v"`, fw.message, "log me") - } } func TestEmerg(t *testing.T) { diff --git a/go/flagutil/flagutil_test.go b/go/flagutil/flagutil_test.go index dda17bb13d7..2502213ab73 100644 --- a/go/flagutil/flagutil_test.go +++ b/go/flagutil/flagutil_test.go @@ -21,6 +21,7 @@ import ( "testing" "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -38,12 +39,9 @@ func TestStringList(t *testing.T) { t.Errorf("v.Set(%v): %v", in, err) continue } - if strings.Join(p, ".") != out { - t.Errorf("want %#v, got %#v", strings.Split(out, "."), p) - } - if p.String() != in { - t.Errorf("v.String(): want %#v, got %#v", in, p.String()) - } + assert.Equal(t, out, strings.Join(p, ".")) + assert.Equal(t, in, p.String()) + } } diff --git a/go/history/history_test.go b/go/history/history_test.go index 3e817b34bb2..34c57756315 100644 --- a/go/history/history_test.go +++ b/go/history/history_test.go @@ -18,6 +18,8 @@ package history import ( "testing" + + "github.com/stretchr/testify/assert" ) func TestHistory(t *testing.T) { @@ -33,9 +35,8 @@ func TestHistory(t *testing.T) { t.Errorf("len(records): want %v, got %v. records: %+v", want, got, q) } for i, record := range records { - if record != want[i] { - t.Errorf("record doesn't match: want %v, got %v", want[i], record) - } + assert.Equal(t, want[i], record) + } for ; i < 6; i++ { @@ -48,9 +49,8 @@ func TestHistory(t *testing.T) { t.Errorf("len(records): want %v, got %v. records: %+v", want, got, q) } for i, record := range records { - if record != want[i] { - t.Errorf("record doesn't match: want %v, got %v", want[i], record) - } + assert.Equal(t, want[i], record) + } } diff --git a/go/mysql/decimal/decimal_test.go b/go/mysql/decimal/decimal_test.go index 09819ddcebb..3499ab8f802 100644 --- a/go/mysql/decimal/decimal_test.go +++ b/go/mysql/decimal/decimal_test.go @@ -26,6 +26,8 @@ import ( "strings" "testing" "testing/quick" + + "github.com/stretchr/testify/assert" ) type testEnt struct { @@ -120,11 +122,8 @@ func TestNewFromFloat(t *testing.T) { for _, x := range testTable { s := x.short d := NewFromFloat(x.float) - if d.String() != s { - t.Errorf("expected %s, got %s (float: %v) (%s, %d)", - s, d.String(), x.float, - d.value.String(), d.exp) - } + assert.Equal(t, s, d.String()) + } shouldPanicOn := []float64{ @@ -156,11 +155,8 @@ func TestNewFromFloatRandom(t *testing.T) { continue } got := NewFromFloat(in) - if !want.Equal(got) { - t.Errorf("in: %v, expected %s (%s, %d), got %s (%s, %d) ", - in, want.String(), want.value.String(), want.exp, - got.String(), got.value.String(), got.exp) - } + assert.True(t, want.Equal(got)) + } } @@ -193,11 +189,8 @@ func TestNewFromFloat32Random(t *testing.T) { continue } got := NewFromFloat32(in) - if !want.Equal(got) { - t.Errorf("in: %v, expected %s (%s, %d), got %s (%s, %d) ", - in, want.String(), want.value.String(), want.exp, - got.String(), got.value.String(), got.exp) - } + assert.True(t, want.Equal(got)) + } } @@ -317,14 +310,9 @@ func TestNewFromStringErrs(t *testing.T) { for s, o := range tests { out, err := NewFromString(s) + assert.Error(t, err) + assert.Equal(t, o, out.String()) - if err == nil { - t.Errorf("error expected when parsing %s", s) - } - - if out.String() != o { - t.Errorf("expected %s, got %s", o, out.String()) - } } } @@ -353,11 +341,8 @@ func TestNewFromStringDeepEquals(t *testing.T) { if err1 != nil || err2 != nil { t.Errorf("error parsing strings to decimals") } + assert.Equal(t, cmp.expected, reflect.DeepEqual(d1, d2)) - if reflect.DeepEqual(d1, d2) != cmp.expected { - t.Errorf("comparison result is different from expected results for %s and %s", - cmp.str1, cmp.str2) - } } } @@ -413,11 +398,8 @@ func TestNewFromInt(t *testing.T) { for input, s := range tests { d := NewFromInt(input) - if d.String() != s { - t.Errorf("expected %s, got %s (%s, %d)", - s, d.String(), - d.value.String(), d.exp) - } + assert.Equal(t, s, d.String()) + } } @@ -499,20 +481,15 @@ func TestDecimal_RoundAndStringFixed(t *testing.T) { t.Fatal(err) } got := d.Round(test.places) - if !got.Equal(expected) { - t.Errorf("Rounding %s to %d places, got %s, expected %s", - d, test.places, got, expected) - } + assert.True(t, got.Equal(expected)) // test StringFixed if test.expectedFixed == "" { test.expectedFixed = test.expected } gotStr := d.StringFixed(test.places) - if gotStr != test.expectedFixed { - t.Errorf("(%s).StringFixed(%d): got %s, expected %s", - d, test.places, gotStr, test.expectedFixed) - } + assert.Equal(t, test.expectedFixed, gotStr) + } } @@ -541,9 +518,8 @@ func TestDecimal_Add(t *testing.T) { t.FailNow() } c := a.Add(b) - if c.String() != res { - t.Errorf("expected %s, got %s", res, c.String()) - } + assert.Equal(t, res, c.String()) + } } @@ -576,9 +552,8 @@ func TestDecimal_Sub(t *testing.T) { t.FailNow() } c := a.sub(b) - if c.String() != res { - t.Errorf("expected %s, got %s", res, c.String()) - } + assert.Equal(t, res, c.String()) + } } @@ -597,18 +572,16 @@ func TestDecimal_Neg(t *testing.T) { t.FailNow() } b := a.Neg() - if b.String() != res { - t.Errorf("expected %s, got %s", res, b.String()) - } + assert.Equal(t, res, b.String()) + } } func TestDecimal_NegFromEmpty(t *testing.T) { a := Decimal{} b := a.Neg() - if b.String() != "0" { - t.Errorf("expected %s, got %s", "0", b) - } + assert.Equal(t, "0", b.String()) + } func TestDecimal_Mul(t *testing.T) { @@ -635,16 +608,14 @@ func TestDecimal_Mul(t *testing.T) { t.FailNow() } c := a.mul(b) - if c.String() != res { - t.Errorf("expected %s, got %s", res, c.String()) - } + assert.Equal(t, res, c.String()) + } // positive scale c := New(1234, 5).mul(New(45, -1)) - if c.String() != "555300000" { - t.Errorf("Expected %s, got %s", "555300000", c.String()) - } + assert.Equal(t, "555300000", c.String()) + } func TestDecimal_Div(t *testing.T) { @@ -679,14 +650,11 @@ func TestDecimal_Div(t *testing.T) { } got := num.div(denom) expected, _ := NewFromString(expectedStr) - if !got.Equal(expected) { - t.Errorf("expected %v when dividing %v by %v, got %v", - expected, num, denom, got) - } + assert.True(t, got.Equal(expected)) + got2 := num.divRound(denom, int32(divisionPrecision)) - if !got2.Equal(expected) { - t.Errorf("expected %v on divRound (%v,%v), got %v", expected, num, denom, got2) - } + assert.True(t, got2.Equal(expected)) + } type Inp2 struct { @@ -717,10 +685,8 @@ func TestDecimal_Div(t *testing.T) { expected = "-" + expectedAbs } got := num.div(denom) - if got.String() != expected { - t.Errorf("expected %s when dividing %v by %v, got %v", - expected, num, denom, got) - } + assert.Equal(t, expected, got.String()) + } } } @@ -761,14 +727,8 @@ func TestDecimal_QuoRem(t *testing.T) { t.Errorf("bad QuoRem division %s , %s , %d got %v, %v expected %s , %s", inp4.d, inp4.d2, prec, q, r, inp4.q, inp4.r) } - if !d.Equal(d2.mul(q).Add(r)) { - t.Errorf("not fitting: d=%v, d2= %v, prec=%d, q=%v, r=%v", - d, d2, prec, q, r) - } - if !q.Equal(q.Truncate(prec)) { - t.Errorf("quotient wrong precision: d=%v, d2= %v, prec=%d, q=%v, r=%v", - d, d2, prec, q, r) - } + assert.True(t, d.Equal(d2.mul(q).Add(r))) + assert.True(t, q.Equal(q.Truncate(prec))) if r.Abs().Cmp(d2.Abs().mul(New(1, -prec))) >= 0 { t.Errorf("remainder too large: d=%v, d2= %v, prec=%d, q=%v, r=%v", d, d2, prec, q, r) @@ -823,15 +783,10 @@ func TestDecimal_QuoRem2(t *testing.T) { prec := tc.prec q, r := d.QuoRem(d2, prec) // rule 1: d = d2*q +r - if !d.Equal(d2.mul(q).Add(r)) { - t.Errorf("not fitting, d=%v, d2=%v, prec=%d, q=%v, r=%v", - d, d2, prec, q, r) - } + assert.True(t, d.Equal(d2.mul(q).Add(r))) // rule 2: q is integral multiple of 10^(-prec) - if !q.Equal(q.Truncate(prec)) { - t.Errorf("quotient wrong precision, d=%v, d2=%v, prec=%d, q=%v, r=%v", - d, d2, prec, q, r) - } + assert.True(t, q.Equal(q.Truncate(prec))) + // rule 3: abs(r)= 0 { t.Errorf("remainder too large, d=%v, d2=%v, prec=%d, q=%v, r=%v", @@ -894,9 +849,8 @@ func TestDecimal_DivRound(t *testing.T) { if x.Cmp(d2.Abs().mul(New(-1, -prec))) <= 0 { t.Errorf("wrong rounding, got: %v/%v prec=%d is about %v", d, d2, prec, q) } - if !q.Equal(result) { - t.Errorf("rounded division wrong %s / %s scale %d = %s, got %v", s.d, s.d2, prec, s.result, q) - } + assert.True(t, q.Equal(result)) + } } @@ -953,9 +907,8 @@ func TestDecimal_Mod(t *testing.T) { t.FailNow() } c := a.mod(b) - if c.String() != res { - t.Errorf("expected %s, got %s", res, c.String()) - } + assert.Equal(t, res, c.String()) + } } @@ -972,9 +925,8 @@ func TestDecimal_Overflow(t *testing.T) { func TestDecimal_Scale(t *testing.T) { a := New(1234, -3) - if a.Exponent() != -3 { - t.Errorf("error") - } + assert.EqualValues(t, -3, a.Exponent()) + } func TestDecimal_Abs1(t *testing.T) { @@ -982,9 +934,8 @@ func TestDecimal_Abs1(t *testing.T) { b := New(1234, -4) c := a.Abs() - if c.Cmp(b) != 0 { - t.Errorf("error") - } + assert.Zero(t, c.Cmp(b)) + } func TestDecimal_Abs2(t *testing.T) { @@ -992,9 +943,8 @@ func TestDecimal_Abs2(t *testing.T) { b := New(1234, -4) c := b.Abs() - if c.Cmp(a) == 0 { - t.Errorf("error") - } + assert.NotZero(t, c.Cmp(a)) + } func TestDecimal_ScalesNotEqual(t *testing.T) { @@ -1008,19 +958,15 @@ func TestDecimal_ScalesNotEqual(t *testing.T) { func TestDecimal_Cmp1(t *testing.T) { a := New(123, 3) b := New(-1234, 2) + assert.Equal(t, 1, a.Cmp(b)) - if a.Cmp(b) != 1 { - t.Errorf("Error") - } } func TestDecimal_Cmp2(t *testing.T) { a := New(123, 3) b := New(1234, 2) + assert.Equal(t, -1, a.Cmp(b)) - if a.Cmp(b) != -1 { - t.Errorf("Error") - } } func TestDecimal_IsInteger(t *testing.T) { @@ -1045,26 +991,20 @@ func TestDecimal_IsInteger(t *testing.T) { if err != nil { t.Fatal(err) } - if d.isInteger() != testCase.IsInteger { - t.Errorf("expect %t, got %t, for %s", testCase.IsInteger, d.isInteger(), testCase.Dec) - } + assert.Equal(t, testCase.IsInteger, d.isInteger()) + } } func TestDecimal_Sign(t *testing.T) { - if Zero.Sign() != 0 { - t.Errorf("%q should have sign 0", Zero) - } + assert.Zero(t, Zero.Sign()) one := New(1, 0) - if one.Sign() != 1 { - t.Errorf("%q should have sign 1", one) - } + assert.Equal(t, 1, one.Sign()) mone := New(-1, 0) - if mone.Sign() != -1 { - t.Errorf("%q should have sign -1", mone) - } + assert.Equal(t, -1, mone.Sign()) + } func didPanic(f func()) bool { diff --git a/go/streamlog/streamlog_test.go b/go/streamlog/streamlog_test.go index e653de74ea8..ab01dd4ccb2 100644 --- a/go/streamlog/streamlog_test.go +++ b/go/streamlog/streamlog_test.go @@ -315,7 +315,6 @@ func TestShouldEmitLog(t *testing.T) { } for _, tt := range tests { - tt := tt t.Run(tt.sql, func(t *testing.T) { SetQueryLogFilterTag(tt.qLogFilterTag) SetQueryLogRowThreshold(tt.qLogRowThreshold) @@ -360,7 +359,6 @@ func TestGetFormatter(t *testing.T) { } for _, tt := range tests { - tt := tt t.Run(tt.name, func(t *testing.T) { var buffer bytes.Buffer logFormatterFunc := GetFormatter[string](tt.logger) diff --git a/go/trace/trace_test.go b/go/trace/trace_test.go index 6b5bdf491bb..7f1f6d8c528 100644 --- a/go/trace/trace_test.go +++ b/go/trace/trace_test.go @@ -96,7 +96,6 @@ func TestNewFromString(t *testing.T) { }, } for _, tt := range tests { - tt := tt t.Run(tt.label, func(t *testing.T) { span, ctx, err := NewFromString(context.Background(), tt.parent, tt.label) if tt.expectedErr == "" { From 89bc131fb2e64a191da221aa317d9d7cecdbf0a7 Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Thu, 22 Feb 2024 09:34:18 -0500 Subject: [PATCH 50/79] delete TestActionAndTimeout (#15322) Signed-off-by: Andrew Mason --- go/test/endtoend/tabletmanager/commands_test.go | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/go/test/endtoend/tabletmanager/commands_test.go b/go/test/endtoend/tabletmanager/commands_test.go index 537a3b9d0fc..d23413e0269 100644 --- a/go/test/endtoend/tabletmanager/commands_test.go +++ b/go/test/endtoend/tabletmanager/commands_test.go @@ -22,7 +22,6 @@ import ( "fmt" "reflect" "testing" - "time" "vitess.io/vitess/go/test/endtoend/utils" @@ -140,18 +139,6 @@ func assertExecuteFetch(t *testing.T, qr string) { assert.Equal(t, want, got) } -// ActionAndTimeout test -func TestActionAndTimeout(t *testing.T) { - defer cluster.PanicHandler(t) - err := clusterInstance.VtctldClientProcess.ExecuteCommand("SleepTablet", primaryTablet.Alias, "5s") - require.Nil(t, err) - time.Sleep(1 * time.Second) - - // try a frontend RefreshState that should timeout as the tablet is busy running the other one - err = clusterInstance.VtctlclientProcess.ExecuteCommand("RefreshState", primaryTablet.Alias, "--wait_timeout", "2s") - assert.Error(t, err, "timeout as tablet is in Sleep") -} - func TestHook(t *testing.T) { // test a regular program works defer cluster.PanicHandler(t) From a78ccbf716ce46bf218861ddb7e70aad5fe6ef19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20Taylor?= Date: Thu, 22 Feb 2024 16:09:34 +0100 Subject: [PATCH 51/79] test: skip should mark the correct *testing.T (#15333) --- go/test/endtoend/utils/cmp.go | 6 ++++++ .../queries/aggregation/aggregation_test.go | 18 +++++++++--------- 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/go/test/endtoend/utils/cmp.go b/go/test/endtoend/utils/cmp.go index 38726d6c3aa..8d0b56ac6b3 100644 --- a/go/test/endtoend/utils/cmp.go +++ b/go/test/endtoend/utils/cmp.go @@ -70,6 +70,12 @@ func (mcmp *MySQLCompare) AssertMatches(query, expected string) { } } +// SkipIfBinaryIsBelowVersion should be used instead of using utils.SkipIfBinaryIsBelowVersion(t, +// This is because we might be inside a Run block that has a different `t` variable +func (mcmp *MySQLCompare) SkipIfBinaryIsBelowVersion(majorVersion int, binary string) { + SkipIfBinaryIsBelowVersion(mcmp.t, majorVersion, binary) +} + // AssertMatchesAny ensures the given query produces any one of the expected results. func (mcmp *MySQLCompare) AssertMatchesAny(query string, expected ...string) { mcmp.t.Helper() diff --git a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go index 6f4dd01d4e2..da2e14218fe 100644 --- a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go +++ b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go @@ -74,7 +74,7 @@ func TestAggregateTypes(t *testing.T) { mcmp.AssertMatches("select val1 as a, count(*) from aggr_test group by a order by 2, a", `[[VARCHAR("b") INT64(1)] [VARCHAR("d") INT64(1)] [VARCHAR("a") INT64(2)] [VARCHAR("c") INT64(2)] [VARCHAR("e") INT64(2)]]`) mcmp.AssertMatches("select sum(val1) from aggr_test", `[[FLOAT64(0)]]`) mcmp.Run("Average for sharded keyspaces", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches("select avg(val1) from aggr_test", `[[FLOAT64(0)]]`) }) } @@ -178,7 +178,7 @@ func TestAggrOnJoin(t *testing.T) { `[[VARCHAR("a")]]`) mcmp.Run("Average in join for sharded", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches(`select avg(a1.val2), avg(a2.val2) from aggr_test a1 join aggr_test a2 on a1.val2 = a2.id join t3 t on a2.val2 = t.id7`, "[[DECIMAL(1.5000) DECIMAL(1.0000)]]") @@ -336,7 +336,7 @@ func TestAggOnTopOfLimit(t *testing.T) { mcmp.AssertMatches("select val1, count(*) from (select id, val1 from aggr_test where val2 < 4 order by val1 limit 2) as x group by val1", `[[NULL INT64(1)] [VARCHAR("a") INT64(1)]]`) mcmp.AssertMatchesNoOrder("select val1, count(val2) from (select val1, val2 from aggr_test limit 8) as x group by val1", `[[NULL INT64(1)] [VARCHAR("a") INT64(2)] [VARCHAR("b") INT64(1)] [VARCHAR("c") INT64(2)]]`) mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches("select avg(val2) from (select id, val2 from aggr_test where val2 is null limit 2) as x", "[[NULL]]") mcmp.AssertMatchesNoOrder("select val1, avg(val2) from (select val1, val2 from aggr_test limit 8) as x group by val1", `[[NULL DECIMAL(2.0000)] [VARCHAR("a") DECIMAL(3.5000)] [VARCHAR("b") DECIMAL(1.0000)] [VARCHAR("c") DECIMAL(3.5000)]]`) }) @@ -348,7 +348,7 @@ func TestAggOnTopOfLimit(t *testing.T) { mcmp.AssertMatches("select count(val2), sum(val2) from (select id, val2 from aggr_test where val2 is null limit 2) as x", "[[INT64(0) NULL]]") mcmp.AssertMatches("select val1, count(*), sum(id) from (select id, val1 from aggr_test where val2 < 4 order by val1 limit 2) as x group by val1", `[[NULL INT64(1) DECIMAL(7)] [VARCHAR("a") INT64(1) DECIMAL(2)]]`) mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches("select count(*), sum(val1), avg(val1) from (select id, val1 from aggr_test where val2 < 4 order by val1 desc limit 2) as x", "[[INT64(2) FLOAT64(0) FLOAT64(0)]]") mcmp.AssertMatches("select count(val1), sum(id), avg(id) from (select id, val1 from aggr_test where val2 < 4 order by val1 desc limit 2) as x", "[[INT64(2) DECIMAL(7) DECIMAL(3.5000)]]") mcmp.AssertMatchesNoOrder("select val1, count(val2), sum(val2), avg(val2) from (select val1, val2 from aggr_test limit 8) as x group by val1", @@ -370,7 +370,7 @@ func TestEmptyTableAggr(t *testing.T) { mcmp.AssertMatches(" select t1.`name`, count(*) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo' group by t1.`name`", "[]") mcmp.AssertMatches(" select t1.`name`, count(*) from t1 inner join t2 on (t1.t1_id = t2.id) where t1.value = 'foo' group by t1.`name`", "[]") mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches(" select count(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select avg(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[NULL]]") }) @@ -386,7 +386,7 @@ func TestEmptyTableAggr(t *testing.T) { mcmp.AssertMatches(" select count(*) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select t1.`name`, count(*) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo' group by t1.`name`", "[]") mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches(" select count(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[INT64(0)]]") mcmp.AssertMatches(" select avg(t1.value) from t2 inner join t1 on (t1.t1_id = t2.id) where t1.value = 'foo'", "[[NULL]]") mcmp.AssertMatches(" select t1.`name`, count(*) from t1 inner join t2 on (t1.t1_id = t2.id) where t1.value = 'foo' group by t1.`name`", "[]") @@ -435,7 +435,7 @@ func TestAggregateLeftJoin(t *testing.T) { mcmp.AssertMatches("SELECT count(*) FROM t2 LEFT JOIN t1 ON t1.t1_id = t2.id WHERE IFNULL(t1.name, 'NOTSET') = 'r'", `[[INT64(1)]]`) mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches("SELECT avg(t1.shardkey) FROM t1 LEFT JOIN t2 ON t1.t1_id = t2.id", `[[DECIMAL(0.5000)]]`) mcmp.AssertMatches("SELECT avg(t2.shardkey) FROM t1 LEFT JOIN t2 ON t1.t1_id = t2.id", `[[DECIMAL(1.0000)]]`) aggregations := []string{ @@ -492,7 +492,7 @@ func TestScalarAggregate(t *testing.T) { mcmp.Exec("insert into aggr_test(id, val1, val2) values(1,'a',1), (2,'A',1), (3,'b',1), (4,'c',3), (5,'c',4)") mcmp.AssertMatches("select count(distinct val1) from aggr_test", `[[INT64(3)]]`) mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.AssertMatches("select avg(val1) from aggr_test", `[[FLOAT64(0)]]`) }) } @@ -552,7 +552,7 @@ func TestComplexAggregation(t *testing.T) { mcmp.Exec(`SELECT name+COUNT(t1_id)+1 FROM t1 GROUP BY name`) mcmp.Exec(`SELECT COUNT(*)+shardkey+MIN(t1_id)+1+MAX(t1_id)*SUM(t1_id)+1+name FROM t1 GROUP BY shardkey, name`) mcmp.Run("Average in sharded query", func(mcmp *utils.MySQLCompare) { - utils.SkipIfBinaryIsBelowVersion(t, 19, "vtgate") + mcmp.SkipIfBinaryIsBelowVersion(19, "vtgate") mcmp.Exec(`SELECT COUNT(t1_id)+MAX(shardkey)+AVG(t1_id) FROM t1`) }) } From 229bbaa7f6e2e5eb5589bf7c3ccfb3cc3732d6cd Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Fri, 23 Feb 2024 14:51:49 +0100 Subject: [PATCH 52/79] srvtopo: Setup metrics in init() function (#15304) Signed-off-by: Dirkjan Bussink --- go/cmd/vtcombo/cli/main.go | 10 +++-- go/cmd/vtexplain/cli/vtexplain.go | 4 +- go/cmd/vtgate/cli/cli.go | 9 ++++- go/cmd/vttablet/cli/cli.go | 13 ++++-- go/vt/srvtopo/discover_test.go | 4 +- go/vt/srvtopo/resilient_server.go | 10 +---- go/vt/srvtopo/resilient_server_test.go | 31 ++++++++------ go/vt/srvtopo/resolver_test.go | 8 ++-- go/vt/vtadmin/api.go | 4 +- go/vt/vtcombo/tablet_map.go | 14 ++++--- go/vt/vtexplain/vtexplain.go | 5 ++- go/vt/vtexplain/vtexplain_test.go | 7 +++- go/vt/vtexplain/vtexplain_vtgate.go | 9 +++-- go/vt/vtexplain/vtexplain_vttablet.go | 5 ++- go/vt/vtexplain/vtexplain_vttablet_test.go | 8 ++-- go/vt/vttablet/endtoend/framework/server.go | 4 +- .../tabletserver/query_executor_test.go | 4 +- go/vt/vttablet/tabletserver/tabletserver.go | 14 ++----- .../tabletserver/tabletserver_test.go | 40 +++++++++++++------ .../tabletserver/vstreamer/testenv/testenv.go | 7 ++-- 20 files changed, 129 insertions(+), 81 deletions(-) diff --git a/go/cmd/vtcombo/cli/main.go b/go/cmd/vtcombo/cli/main.go index a86b98cc250..16e625a6ae6 100644 --- a/go/cmd/vtcombo/cli/main.go +++ b/go/cmd/vtcombo/cli/main.go @@ -32,6 +32,7 @@ import ( "vitess.io/vitess/go/acl" "vitess.io/vitess/go/mysql/replication" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/dbconfigs" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/logutil" @@ -84,6 +85,8 @@ In particular, it contains: tabletTypesToWait []topodatapb.TabletType env *vtenv.Environment + + srvTopoCounts *stats.CountersWithSingleLabel ) func init() { @@ -131,6 +134,7 @@ func init() { if err != nil { log.Fatalf("unable to initialize env: %v", err) } + srvTopoCounts = stats.NewCountersWithSingleLabel("ResilientSrvTopoServer", "Resilient srvtopo server operations", "type") } func startMysqld(uid uint32) (mysqld *mysqlctl.Mysqld, cnf *mysqlctl.Mycnf, err error) { @@ -234,7 +238,7 @@ func run(cmd *cobra.Command, args []string) (err error) { // to be the "internal" protocol that InitTabletMap registers. cmd.Flags().Set("tablet_manager_protocol", "internal") cmd.Flags().Set("tablet_protocol", "internal") - uid, err := vtcombo.InitTabletMap(env, ts, &tpb, mysqld, &dbconfigs.GlobalDBConfigs, schemaDir, startMysql) + uid, err := vtcombo.InitTabletMap(env, ts, &tpb, mysqld, &dbconfigs.GlobalDBConfigs, schemaDir, startMysql, srvTopoCounts) if err != nil { // ensure we start mysql in the event we fail here if startMysql { @@ -260,7 +264,7 @@ func run(cmd *cobra.Command, args []string) (err error) { } wr := wrangler.New(env, logutil.NewConsoleLogger(), ts, nil) - newUID, err := vtcombo.CreateKs(ctx, env, ts, &tpb, mysqld, &dbconfigs.GlobalDBConfigs, schemaDir, ks, true, uid, wr) + newUID, err := vtcombo.CreateKs(ctx, env, ts, &tpb, mysqld, &dbconfigs.GlobalDBConfigs, schemaDir, ks, true, uid, wr, srvTopoCounts) if err != nil { return err } @@ -297,7 +301,7 @@ func run(cmd *cobra.Command, args []string) (err error) { } // vtgate configuration and init - resilientServer = srvtopo.NewResilientServer(context.Background(), ts, "ResilientSrvTopoServer") + resilientServer = srvtopo.NewResilientServer(context.Background(), ts, srvTopoCounts) tabletTypes := make([]topodatapb.TabletType, 0, 1) if len(tabletTypesToWait) != 0 { diff --git a/go/cmd/vtexplain/cli/vtexplain.go b/go/cmd/vtexplain/cli/vtexplain.go index c8671cdb532..fe17d9af47c 100644 --- a/go/cmd/vtexplain/cli/vtexplain.go +++ b/go/cmd/vtexplain/cli/vtexplain.go @@ -22,6 +22,7 @@ import ( "os" "vitess.io/vitess/go/acl" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/servenv" "vitess.io/vitess/go/vt/topo/memorytopo" @@ -186,7 +187,8 @@ func parseAndRun() error { } ctx := context.Background() ts := memorytopo.NewServer(ctx, vtexplain.Cell) - vte, err := vtexplain.Init(ctx, env, ts, vschema, schema, ksShardMap, opts) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + vte, err := vtexplain.Init(ctx, env, ts, vschema, schema, ksShardMap, opts, srvTopoCounts) if err != nil { return err } diff --git a/go/cmd/vtgate/cli/cli.go b/go/cmd/vtgate/cli/cli.go index c348c4d8296..312396a5a3c 100644 --- a/go/cmd/vtgate/cli/cli.go +++ b/go/cmd/vtgate/cli/cli.go @@ -25,6 +25,7 @@ import ( "vitess.io/vitess/go/acl" "vitess.io/vitess/go/exit" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/discovery" "vitess.io/vitess/go/vt/servenv" "vitess.io/vitess/go/vt/srvtopo" @@ -73,8 +74,14 @@ var ( PreRunE: servenv.CobraPreRunE, RunE: run, } + + srvTopoCounts *stats.CountersWithSingleLabel ) +func init() { + srvTopoCounts = stats.NewCountersWithSingleLabel("ResilientSrvTopoServer", "Resilient srvtopo server operations", "type") +} + // CheckCellFlags will check validation of cell and cells_to_watch flag // it will help to avoid strange behaviors when vtgate runs but actually does not work func CheckCellFlags(ctx context.Context, serv srvtopo.Server, cell string, cellsToWatch string) error { @@ -139,7 +146,7 @@ func run(cmd *cobra.Command, args []string) error { ts := topo.Open() defer ts.Close() - resilientServer = srvtopo.NewResilientServer(context.Background(), ts, "ResilientSrvTopoServer") + resilientServer = srvtopo.NewResilientServer(context.Background(), ts, srvTopoCounts) tabletTypes := make([]topodatapb.TabletType, 0, 1) for _, tt := range tabletTypesToWait { diff --git a/go/cmd/vttablet/cli/cli.go b/go/cmd/vttablet/cli/cli.go index 872d7a5ef69..ab212127457 100644 --- a/go/cmd/vttablet/cli/cli.go +++ b/go/cmd/vttablet/cli/cli.go @@ -27,6 +27,7 @@ import ( "vitess.io/vitess/go/acl" "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/binlog" "vitess.io/vitess/go/vt/dbconfigs" "vitess.io/vitess/go/vt/log" @@ -102,8 +103,14 @@ vttablet \ PreRunE: servenv.CobraPreRunE, RunE: run, } + + srvTopoCounts *stats.CountersWithSingleLabel ) +func init() { + srvTopoCounts = stats.NewCountersWithSingleLabel("TabletSrvTopo", "Resilient srvtopo server operations", "type") +} + func run(cmd *cobra.Command, args []string) error { servenv.Init() @@ -129,7 +136,7 @@ func run(cmd *cobra.Command, args []string) error { } ts := topo.Open() - qsc, err := createTabletServer(context.Background(), env, config, ts, tabletAlias) + qsc, err := createTabletServer(context.Background(), env, config, ts, tabletAlias, srvTopoCounts) if err != nil { ts.Close() return err @@ -249,7 +256,7 @@ func extractOnlineDDL() error { return nil } -func createTabletServer(ctx context.Context, env *vtenv.Environment, config *tabletenv.TabletConfig, ts *topo.Server, tabletAlias *topodatapb.TabletAlias) (*tabletserver.TabletServer, error) { +func createTabletServer(ctx context.Context, env *vtenv.Environment, config *tabletenv.TabletConfig, ts *topo.Server, tabletAlias *topodatapb.TabletAlias, srvTopoCounts *stats.CountersWithSingleLabel) (*tabletserver.TabletServer, error) { if tableACLConfig != "" { // To override default simpleacl, other ACL plugins must set themselves to be default ACL factory tableacl.Register("simpleacl", &simpleacl.Factory{}) @@ -258,7 +265,7 @@ func createTabletServer(ctx context.Context, env *vtenv.Environment, config *tab } // creates and registers the query service - qsc := tabletserver.NewTabletServer(ctx, env, "", config, ts, tabletAlias) + qsc := tabletserver.NewTabletServer(ctx, env, "", config, ts, tabletAlias, srvTopoCounts) servenv.OnRun(func() { qsc.Register() addStatusParts(qsc) diff --git a/go/vt/srvtopo/discover_test.go b/go/vt/srvtopo/discover_test.go index ca4774a1b84..81279b7d61a 100644 --- a/go/vt/srvtopo/discover_test.go +++ b/go/vt/srvtopo/discover_test.go @@ -23,6 +23,7 @@ import ( "testing" "time" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/topo/memorytopo" querypb "vitess.io/vitess/go/vt/proto/query" @@ -59,7 +60,8 @@ func TestFindAllTargets(t *testing.T) { srvTopoCacheTTL = 1 * time.Second }() - rs := NewResilientServer(ctx, ts, "TestFindAllKeyspaceShards") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) // No keyspace / shards. ks, err := FindAllTargets(ctx, rs, "cell1", []topodatapb.TabletType{topodatapb.TabletType_PRIMARY}) diff --git a/go/vt/srvtopo/resilient_server.go b/go/vt/srvtopo/resilient_server.go index 0cbccbdb31c..78fc9134bce 100644 --- a/go/vt/srvtopo/resilient_server.go +++ b/go/vt/srvtopo/resilient_server.go @@ -70,7 +70,6 @@ const ( // - return the last known value of the data if there is an error type ResilientServer struct { topoServer *topo.Server - counts *stats.CountersWithSingleLabel *SrvKeyspaceWatcher *SrvVSchemaWatcher @@ -79,20 +78,13 @@ type ResilientServer struct { // NewResilientServer creates a new ResilientServer // based on the provided topo.Server. -func NewResilientServer(ctx context.Context, base *topo.Server, counterPrefix string) *ResilientServer { +func NewResilientServer(ctx context.Context, base *topo.Server, counts *stats.CountersWithSingleLabel) *ResilientServer { if srvTopoCacheRefresh > srvTopoCacheTTL { log.Fatalf("srv_topo_cache_refresh must be less than or equal to srv_topo_cache_ttl") } - metric := "" - if counterPrefix != "" { - metric = counterPrefix + "Counts" - } - counts := stats.NewCountersWithSingleLabel(metric, "Resilient srvtopo server operations", "type") - return &ResilientServer{ topoServer: base, - counts: counts, SrvKeyspaceWatcher: NewSrvKeyspaceWatcher(ctx, base, counts, srvTopoCacheRefresh, srvTopoCacheTTL), SrvVSchemaWatcher: NewSrvVSchemaWatcher(ctx, base, counts, srvTopoCacheRefresh, srvTopoCacheTTL), SrvKeyspaceNamesQuery: NewSrvKeyspaceNamesQuery(base, counts, srvTopoCacheRefresh, srvTopoCacheTTL), diff --git a/go/vt/srvtopo/resilient_server_test.go b/go/vt/srvtopo/resilient_server_test.go index fe248f56087..dbcf48ce176 100644 --- a/go/vt/srvtopo/resilient_server_test.go +++ b/go/vt/srvtopo/resilient_server_test.go @@ -28,6 +28,7 @@ import ( "github.com/google/safehtml/template" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/key" "github.com/stretchr/testify/assert" @@ -53,7 +54,8 @@ func TestGetSrvKeyspace(t *testing.T) { srvTopoCacheRefresh = 1 * time.Second }() - rs := NewResilientServer(ctx, ts, "TestGetSrvKeyspace") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) // Ask for a not-yet-created keyspace _, err := rs.GetSrvKeyspace(context.Background(), "test_cell", "test_ks") @@ -175,7 +177,7 @@ func TestGetSrvKeyspace(t *testing.T) { // Now simulate a topo service error and see that the last value is // cached for at least half of the expected ttl. errorTestStart := time.Now() - errorReqsBefore := rs.counts.Counts()[errorCategory] + errorReqsBefore := counts.Counts()[errorCategory] forceErr := topo.NewError(topo.Timeout, "test topo error") factory.SetError(forceErr) @@ -271,7 +273,7 @@ func TestGetSrvKeyspace(t *testing.T) { // Check that the expected number of errors were counted during the // interval - errorReqs := rs.counts.Counts()[errorCategory] + errorReqs := counts.Counts()[errorCategory] expectedErrors := int64(time.Since(errorTestStart) / srvTopoCacheRefresh) if errorReqs-errorReqsBefore > expectedErrors { t.Errorf("expected <= %v error requests got %d", expectedErrors, errorReqs-errorReqsBefore) @@ -370,7 +372,8 @@ func TestSrvKeyspaceCachedError(t *testing.T) { srvTopoCacheTTL = 1 * time.Second srvTopoCacheRefresh = 1 * time.Second }() - rs := NewResilientServer(ctx, ts, "TestSrvKeyspaceCachedErrors") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) // Ask for an unknown keyspace, should get an error. _, err := rs.GetSrvKeyspace(ctx, "test_cell", "unknown_ks") @@ -401,7 +404,8 @@ func TestGetSrvKeyspaceCreated(t *testing.T) { defer cancel() ts := memorytopo.NewServer(ctx, "test_cell") defer ts.Close() - rs := NewResilientServer(ctx, ts, "TestGetSrvKeyspaceCreated") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) // Set SrvKeyspace with value. want := &topodatapb.SrvKeyspace{} @@ -435,7 +439,8 @@ func TestWatchSrvVSchema(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() ts := memorytopo.NewServer(ctx, "test_cell") - rs := NewResilientServer(ctx, ts, "TestWatchSrvVSchema") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) // mu protects watchValue and watchErr. mu := sync.Mutex{} @@ -529,7 +534,8 @@ func TestGetSrvKeyspaceNames(t *testing.T) { srvTopoCacheTTL = 1 * time.Second srvTopoCacheRefresh = 1 * time.Second }() - rs := NewResilientServer(ctx, ts, "TestGetSrvKeyspaceNames") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) // Set SrvKeyspace with value want := &topodatapb.SrvKeyspace{} @@ -614,7 +620,7 @@ func TestGetSrvKeyspaceNames(t *testing.T) { // Check that we only checked the topo service 1 or 2 times during the // period where we got the cached error. - cachedReqs, ok := rs.counts.Counts()[cachedCategory] + cachedReqs, ok := counts.Counts()[cachedCategory] if !ok || cachedReqs > 2 { t.Errorf("expected <= 2 cached requests got %v", cachedReqs) } @@ -640,7 +646,7 @@ func TestGetSrvKeyspaceNames(t *testing.T) { t.Errorf("GetSrvKeyspaceNames got %v want %v", names, wantNames) } - errorReqs, ok := rs.counts.Counts()[errorCategory] + errorReqs, ok := counts.Counts()[errorCategory] if !ok || errorReqs == 0 { t.Errorf("expected non-zero error requests got %v", errorReqs) } @@ -684,8 +690,8 @@ func TestSrvKeyspaceWatcher(t *testing.T) { srvTopoCacheTTL = 1 * time.Second srvTopoCacheRefresh = 1 * time.Second }() - - rs := NewResilientServer(ctx, ts, "TestGetSrvKeyspaceWatcher") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) var wmu sync.Mutex var wseen []watched @@ -811,7 +817,8 @@ func TestSrvKeyspaceListener(t *testing.T) { srvTopoCacheRefresh = 1 * time.Second }() - rs := NewResilientServer(ctx, ts, "TestGetSrvKeyspaceListener") + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) cancelCtx, cancelFunc := context.WithCancel(context.Background()) var callbackCount atomic.Int32 diff --git a/go/vt/srvtopo/resolver_test.go b/go/vt/srvtopo/resolver_test.go index 95e6dbe620c..fae8bef1fb2 100644 --- a/go/vt/srvtopo/resolver_test.go +++ b/go/vt/srvtopo/resolver_test.go @@ -23,6 +23,7 @@ import ( "github.com/stretchr/testify/require" "vitess.io/vitess/go/sqltypes" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/key" "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/topo/memorytopo" @@ -33,10 +34,11 @@ import ( topodatapb "vitess.io/vitess/go/vt/proto/topodata" ) -func initResolver(t *testing.T, ctx context.Context, name string) *Resolver { +func initResolver(t *testing.T, ctx context.Context) *Resolver { cell := "cell1" ts := memorytopo.NewServer(ctx, cell) - rs := NewResilientServer(ctx, ts, name) + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + rs := NewResilientServer(ctx, ts, counts) // Create sharded keyspace and shards. if err := ts.CreateKeyspace(ctx, "sks", &topodatapb.Keyspace{}); err != nil { @@ -97,7 +99,7 @@ func initResolver(t *testing.T, ctx context.Context, name string) *Resolver { func TestResolveDestinations(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - resolver := initResolver(t, ctx, "TestResolveDestinations") + resolver := initResolver(t, ctx) id1 := &querypb.Value{ Type: sqltypes.VarChar, diff --git a/go/vt/vtadmin/api.go b/go/vt/vtadmin/api.go index dce4ff041c9..1e83875de35 100644 --- a/go/vt/vtadmin/api.go +++ b/go/vt/vtadmin/api.go @@ -32,6 +32,7 @@ import ( "github.com/gorilla/mux" "github.com/patrickmn/go-cache" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/sets" @@ -2384,7 +2385,8 @@ func (api *API) VTExplain(ctx context.Context, req *vtadminpb.VTExplainRequest) } ts := memorytopo.NewServer(ctx, vtexplain.Cell) - vte, err := vtexplain.Init(ctx, api.env, ts, srvVSchema, schema, shardMap, &vtexplain.Options{ReplicationMode: "ROW"}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + vte, err := vtexplain.Init(ctx, api.env, ts, srvVSchema, schema, shardMap, &vtexplain.Options{ReplicationMode: "ROW"}, srvTopoCounts) if err != nil { return nil, fmt.Errorf("error initilaizing vtexplain: %w", err) } diff --git a/go/vt/vtcombo/tablet_map.go b/go/vt/vtcombo/tablet_map.go index 369a8138b5a..25cc28d366d 100644 --- a/go/vt/vtcombo/tablet_map.go +++ b/go/vt/vtcombo/tablet_map.go @@ -24,6 +24,7 @@ import ( "time" "vitess.io/vitess/go/sqltypes" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/dbconfigs" "vitess.io/vitess/go/vt/grpcclient" "vitess.io/vitess/go/vt/hook" @@ -84,6 +85,7 @@ func CreateTablet( tabletType topodatapb.TabletType, mysqld mysqlctl.MysqlDaemon, dbcfgs *dbconfigs.DBConfigs, + srvTopoCounts *stats.CountersWithSingleLabel, ) error { alias := &topodatapb.TabletAlias{ Cell: cell, @@ -91,7 +93,7 @@ func CreateTablet( } log.Infof("Creating %v tablet %v for %v/%v", tabletType, topoproto.TabletAliasString(alias), keyspace, shard) - controller := tabletserver.NewServer(ctx, env, topoproto.TabletAliasString(alias), ts, alias) + controller := tabletserver.NewServer(ctx, env, topoproto.TabletAliasString(alias), ts, alias, srvTopoCounts) initTabletType := tabletType if tabletType == topodatapb.TabletType_PRIMARY { initTabletType = topodatapb.TabletType_REPLICA @@ -173,6 +175,7 @@ func InitTabletMap( dbcfgs *dbconfigs.DBConfigs, schemaDir string, ensureDatabase bool, + srvTopoCounts *stats.CountersWithSingleLabel, ) (uint32, error) { tabletMap = make(map[uint32]*comboTablet) @@ -192,7 +195,7 @@ func InitTabletMap( var uid uint32 = 1 for _, kpb := range tpb.Keyspaces { var err error - uid, err = CreateKs(ctx, env, ts, tpb, mysqld, dbcfgs, schemaDir, kpb, ensureDatabase, uid, wr) + uid, err = CreateKs(ctx, env, ts, tpb, mysqld, dbcfgs, schemaDir, kpb, ensureDatabase, uid, wr, srvTopoCounts) if err != nil { return 0, err } @@ -293,6 +296,7 @@ func CreateKs( ensureDatabase bool, uid uint32, wr *wrangler.Wrangler, + srvTopoCounts *stats.CountersWithSingleLabel, ) (uint32, error) { keyspace := kpb.Name @@ -342,7 +346,7 @@ func CreateKs( replicas-- // create the primary - if err := CreateTablet(ctx, env, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_PRIMARY, mysqld, dbcfgs.Clone()); err != nil { + if err := CreateTablet(ctx, env, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_PRIMARY, mysqld, dbcfgs.Clone(), srvTopoCounts); err != nil { return 0, err } uid++ @@ -350,7 +354,7 @@ func CreateKs( for i := 0; i < replicas; i++ { // create a replica tablet - if err := CreateTablet(ctx, env, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_REPLICA, mysqld, dbcfgs.Clone()); err != nil { + if err := CreateTablet(ctx, env, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_REPLICA, mysqld, dbcfgs.Clone(), srvTopoCounts); err != nil { return 0, err } uid++ @@ -358,7 +362,7 @@ func CreateKs( for i := 0; i < rdonlys; i++ { // create a rdonly tablet - if err := CreateTablet(ctx, env, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_RDONLY, mysqld, dbcfgs.Clone()); err != nil { + if err := CreateTablet(ctx, env, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_RDONLY, mysqld, dbcfgs.Clone(), srvTopoCounts); err != nil { return 0, err } uid++ diff --git a/go/vt/vtexplain/vtexplain.go b/go/vt/vtexplain/vtexplain.go index e16dea89d2b..64f1ca3cea1 100644 --- a/go/vt/vtexplain/vtexplain.go +++ b/go/vt/vtexplain/vtexplain.go @@ -28,6 +28,7 @@ import ( "github.com/spf13/pflag" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/vtenv" @@ -184,7 +185,7 @@ type TabletActions struct { } // Init sets up the fake execution environment -func Init(ctx context.Context, env *vtenv.Environment, ts *topo.Server, vSchemaStr, sqlSchema, ksShardMapStr string, opts *Options) (*VTExplain, error) { +func Init(ctx context.Context, env *vtenv.Environment, ts *topo.Server, vSchemaStr, sqlSchema, ksShardMapStr string, opts *Options, srvTopoCounts *stats.CountersWithSingleLabel) (*VTExplain, error) { // Verify options if opts.ReplicationMode != "ROW" && opts.ReplicationMode != "STATEMENT" { return nil, fmt.Errorf("invalid replication mode \"%s\"", opts.ReplicationMode) @@ -207,7 +208,7 @@ func Init(ctx context.Context, env *vtenv.Environment, ts *topo.Server, vSchemaS env: env, } vte.setGlobalTabletEnv(tabletEnv) - err = vte.initVtgateExecutor(ctx, ts, vSchemaStr, ksShardMapStr, opts) + err = vte.initVtgateExecutor(ctx, ts, vSchemaStr, ksShardMapStr, opts, srvTopoCounts) if err != nil { return nil, fmt.Errorf("initVtgateExecutor: %v", err.Error()) } diff --git a/go/vt/vtexplain/vtexplain_test.go b/go/vt/vtexplain/vtexplain_test.go index e7a6f4bdfc8..49bb94fedb1 100644 --- a/go/vt/vtexplain/vtexplain_test.go +++ b/go/vt/vtexplain/vtexplain_test.go @@ -28,6 +28,7 @@ import ( "github.com/google/go-cmp/cmp" "github.com/stretchr/testify/require" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/vtenv" @@ -68,7 +69,8 @@ func initTest(ctx context.Context, ts *topo.Server, mode string, opts *Options, } opts.ExecutionMode = mode - vte, err := Init(ctx, vtenv.NewTestEnv(), ts, string(vSchema), string(schema), shardmap, opts) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + vte, err := Init(ctx, vtenv.NewTestEnv(), ts, string(vSchema), string(schema), shardmap, opts, srvTopoCounts) require.NoError(t, err, "vtexplain Init error\n%s", string(schema)) return vte } @@ -349,7 +351,8 @@ func TestInit(t *testing.T) { }` schema := "create table table_missing_primary_vindex (id int primary key)" ts := memorytopo.NewServer(ctx, Cell) - _, err := Init(ctx, vtenv.NewTestEnv(), ts, vschema, schema, "", defaultTestOpts()) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + _, err := Init(ctx, vtenv.NewTestEnv(), ts, vschema, schema, "", defaultTestOpts(), srvTopoCounts) require.Error(t, err) require.Contains(t, err.Error(), "missing primary col vindex") } diff --git a/go/vt/vtexplain/vtexplain_vtgate.go b/go/vt/vtexplain/vtexplain_vtgate.go index a5d9677f02a..22939efde20 100644 --- a/go/vt/vtexplain/vtexplain_vtgate.go +++ b/go/vt/vtexplain/vtexplain_vtgate.go @@ -28,6 +28,7 @@ import ( "vitess.io/vitess/go/cache/theine" "vitess.io/vitess/go/json2" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/streamlog" "vitess.io/vitess/go/vt/discovery" "vitess.io/vitess/go/vt/key" @@ -47,14 +48,14 @@ import ( vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" ) -func (vte *VTExplain) initVtgateExecutor(ctx context.Context, ts *topo.Server, vSchemaStr, ksShardMapStr string, opts *Options) error { +func (vte *VTExplain) initVtgateExecutor(ctx context.Context, ts *topo.Server, vSchemaStr, ksShardMapStr string, opts *Options, srvTopoCounts *stats.CountersWithSingleLabel) error { vte.explainTopo = &ExplainTopo{NumShards: opts.NumShards} vte.explainTopo.TopoServer = ts vte.healthCheck = discovery.NewFakeHealthCheck(nil) resolver := vte.newFakeResolver(ctx, opts, vte.explainTopo, Cell) - err := vte.buildTopology(ctx, ts, opts, vSchemaStr, ksShardMapStr, opts.NumShards) + err := vte.buildTopology(ctx, ts, opts, vSchemaStr, ksShardMapStr, opts.NumShards, srvTopoCounts) if err != nil { return err } @@ -92,7 +93,7 @@ func (vte *VTExplain) newFakeResolver(ctx context.Context, opts *Options, serv s return vtgate.NewResolver(srvResolver, serv, cell, sc) } -func (vte *VTExplain) buildTopology(ctx context.Context, ts *topo.Server, opts *Options, vschemaStr string, ksShardMapStr string, numShardsPerKeyspace int) error { +func (vte *VTExplain) buildTopology(ctx context.Context, ts *topo.Server, opts *Options, vschemaStr string, ksShardMapStr string, numShardsPerKeyspace int, srvTopoCounts *stats.CountersWithSingleLabel) error { vte.explainTopo.Lock.Lock() defer vte.explainTopo.Lock.Unlock() @@ -170,7 +171,7 @@ func (vte *VTExplain) buildTopology(ctx context.Context, ts *topo.Server, opts * log.Infof("registering test tablet %s for keyspace %s shard %s", hostname, ks, shard.Name) tablet := vte.healthCheck.AddFakeTablet(Cell, hostname, 1, ks, shard.Name, topodatapb.TabletType_PRIMARY, true, 1, nil, func(t *topodatapb.Tablet) queryservice.QueryService { - return vte.newTablet(ctx, vte.env, opts, t, ts) + return vte.newTablet(ctx, vte.env, opts, t, ts, srvTopoCounts) }) vte.explainTopo.TabletConns[hostname] = tablet.(*explainTablet) vte.explainTopo.KeyspaceShards[ks][shard.Name] = shard diff --git a/go/vt/vtexplain/vtexplain_vttablet.go b/go/vt/vtexplain/vtexplain_vttablet.go index b573fe29774..53e09445c17 100644 --- a/go/vt/vtexplain/vtexplain_vttablet.go +++ b/go/vt/vtexplain/vtexplain_vttablet.go @@ -23,6 +23,7 @@ import ( "strings" "sync" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/sidecardb" "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/vtenv" @@ -105,7 +106,7 @@ type explainTablet struct { var _ queryservice.QueryService = (*explainTablet)(nil) -func (vte *VTExplain) newTablet(ctx context.Context, env *vtenv.Environment, opts *Options, t *topodatapb.Tablet, ts *topo.Server) *explainTablet { +func (vte *VTExplain) newTablet(ctx context.Context, env *vtenv.Environment, opts *Options, t *topodatapb.Tablet, ts *topo.Server, srvTopoCounts *stats.CountersWithSingleLabel) *explainTablet { db := fakesqldb.New(nil) sidecardb.AddSchemaInitQueries(db, true, env.Parser()) @@ -120,7 +121,7 @@ func (vte *VTExplain) newTablet(ctx context.Context, env *vtenv.Environment, opt config.EnableTableGC = false // XXX much of this is cloned from the tabletserver tests - tsv := tabletserver.NewTabletServer(ctx, env, topoproto.TabletAliasString(t.Alias), config, ts, t.Alias) + tsv := tabletserver.NewTabletServer(ctx, env, topoproto.TabletAliasString(t.Alias), config, ts, t.Alias, srvTopoCounts) tablet := explainTablet{db: db, tsv: tsv, vte: vte, collationEnv: env.CollationEnv()} db.Handler = &tablet diff --git a/go/vt/vtexplain/vtexplain_vttablet_test.go b/go/vt/vtexplain/vtexplain_vttablet_test.go index a4350316d82..ddf24b90afa 100644 --- a/go/vt/vtexplain/vtexplain_vttablet_test.go +++ b/go/vt/vtexplain/vtexplain_vttablet_test.go @@ -26,6 +26,7 @@ import ( "github.com/stretchr/testify/require" "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/topo/memorytopo" "vitess.io/vitess/go/vt/vtenv" @@ -76,7 +77,8 @@ create table t2 ( ctx, cancel := context.WithCancel(context.Background()) defer cancel() ts := memorytopo.NewServer(ctx, Cell) - vte, err := Init(ctx, vtenv.NewTestEnv(), ts, testVSchema, testSchema, "", opts) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + vte, err := Init(ctx, vtenv.NewTestEnv(), ts, testVSchema, testSchema, "", opts, srvTopoCounts) require.NoError(t, err) defer vte.Stop() @@ -141,14 +143,14 @@ create table test_partitioned ( tabletEnv, _ := newTabletEnvironment(ddls, defaultTestOpts(), env.CollationEnv()) vte.setGlobalTabletEnv(tabletEnv) - + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") tablet := vte.newTablet(ctx, env, defaultTestOpts(), &topodatapb.Tablet{ Keyspace: "ks_sharded", Shard: "-80", Alias: &topodatapb.TabletAlias{ Cell: Cell, }, - }, ts) + }, ts, srvTopoCounts) time.Sleep(10 * time.Millisecond) se := tablet.tsv.SchemaEngine() diff --git a/go/vt/vttablet/endtoend/framework/server.go b/go/vt/vttablet/endtoend/framework/server.go index 0258dee9186..42f2994a22c 100644 --- a/go/vt/vttablet/endtoend/framework/server.go +++ b/go/vt/vttablet/endtoend/framework/server.go @@ -23,6 +23,7 @@ import ( "net/http" "time" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/servenv" "vitess.io/vitess/go/vt/topo" @@ -78,7 +79,8 @@ func StartCustomServer(ctx context.Context, connParams, connAppDebugParams mysql } TopoServer = memorytopo.NewServer(ctx, "") - Server = tabletserver.NewTabletServer(ctx, vtenv.NewTestEnv(), "", cfg, TopoServer, &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + Server = tabletserver.NewTabletServer(ctx, vtenv.NewTestEnv(), "", cfg, TopoServer, &topodatapb.TabletAlias{}, srvTopoCounts) Server.Register() err := Server.StartService(Target, dbcfgs, nil /* mysqld */) if err != nil { diff --git a/go/vt/vttablet/tabletserver/query_executor_test.go b/go/vt/vttablet/tabletserver/query_executor_test.go index 3466a55133d..afc42113522 100644 --- a/go/vt/vttablet/tabletserver/query_executor_test.go +++ b/go/vt/vttablet/tabletserver/query_executor_test.go @@ -28,6 +28,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/vtenv" @@ -1528,7 +1529,8 @@ func newTestTabletServer(ctx context.Context, flags executorFlags, db *fakesqldb } dbconfigs := newDBConfigs(db) cfg.DB = dbconfigs - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) target := &querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} err := tsv.StartService(target, dbconfigs, nil /* mysqld */) if cfg.TwoPCEnable { diff --git a/go/vt/vttablet/tabletserver/tabletserver.go b/go/vt/vttablet/tabletserver/tabletserver.go index 6ecc46c68ab..dad637a6daf 100644 --- a/go/vt/vttablet/tabletserver/tabletserver.go +++ b/go/vt/vttablet/tabletserver/tabletserver.go @@ -28,7 +28,6 @@ import ( "sort" "strconv" "strings" - "sync" "sync/atomic" "syscall" "time" @@ -140,18 +139,13 @@ var _ queryservice.QueryService = (*TabletServer)(nil) var RegisterFunctions []func(Controller) // NewServer creates a new TabletServer based on the command line flags. -func NewServer(ctx context.Context, env *vtenv.Environment, name string, topoServer *topo.Server, alias *topodatapb.TabletAlias) *TabletServer { - return NewTabletServer(ctx, env, name, tabletenv.NewCurrentConfig(), topoServer, alias) +func NewServer(ctx context.Context, env *vtenv.Environment, name string, topoServer *topo.Server, alias *topodatapb.TabletAlias, srvTopoCounts *stats.CountersWithSingleLabel) *TabletServer { + return NewTabletServer(ctx, env, name, tabletenv.NewCurrentConfig(), topoServer, alias, srvTopoCounts) } -var ( - tsOnce sync.Once - srvTopoServer srvtopo.Server -) - // NewTabletServer creates an instance of TabletServer. Only the first // instance of TabletServer will expose its state variables. -func NewTabletServer(ctx context.Context, env *vtenv.Environment, name string, config *tabletenv.TabletConfig, topoServer *topo.Server, alias *topodatapb.TabletAlias) *TabletServer { +func NewTabletServer(ctx context.Context, env *vtenv.Environment, name string, config *tabletenv.TabletConfig, topoServer *topo.Server, alias *topodatapb.TabletAlias, srvTopoCounts *stats.CountersWithSingleLabel) *TabletServer { exporter := servenv.NewExporter(name, "Tablet") tsv := &TabletServer{ exporter: exporter, @@ -166,7 +160,7 @@ func NewTabletServer(ctx context.Context, env *vtenv.Environment, name string, c } tsv.QueryTimeout.Store(config.Oltp.QueryTimeout.Nanoseconds()) - tsOnce.Do(func() { srvTopoServer = srvtopo.NewResilientServer(ctx, topoServer, "TabletSrvTopo") }) + srvTopoServer := srvtopo.NewResilientServer(ctx, topoServer, srvTopoCounts) tabletTypeFunc := func() topodatapb.TabletType { if tsv.sm == nil || tsv.sm.Target() == nil { diff --git a/go/vt/vttablet/tabletserver/tabletserver_test.go b/go/vt/vttablet/tabletserver/tabletserver_test.go index 97777c0245f..9744b971946 100644 --- a/go/vt/vttablet/tabletserver/tabletserver_test.go +++ b/go/vt/vttablet/tabletserver/tabletserver_test.go @@ -32,6 +32,7 @@ import ( "vitess.io/vitess/go/mysql/config" "vitess.io/vitess/go/mysql/sqlerror" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/callerid" "vitess.io/vitess/go/vt/sidecardb" "vitess.io/vitess/go/vt/vtenv" @@ -1560,7 +1561,8 @@ func TestHandleExecUnknownError(t *testing.T) { defer cancel() logStats := tabletenv.NewLogStats(ctx, "TestHandleExecError") cfg := tabletenv.NewDefaultConfig() - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) defer tsv.handlePanicAndSendLogStats("select * from test_table", nil, logStats) panic("unknown exec error") } @@ -1730,7 +1732,8 @@ func TestHandleExecTabletError(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() cfg := tabletenv.NewDefaultConfig() - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() err := tsv.convertAndLogError( @@ -1755,7 +1758,8 @@ func TestTerseErrors(t *testing.T) { cfg := tabletenv.NewDefaultConfig() cfg.TerseErrors = true cfg.SanitizeLogMessages = false - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() @@ -1789,7 +1793,8 @@ func TestSanitizeLogMessages(t *testing.T) { cfg := tabletenv.NewDefaultConfig() cfg.TerseErrors = false cfg.SanitizeLogMessages = true - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() @@ -1822,7 +1827,8 @@ func TestTerseErrorsNonSQLError(t *testing.T) { defer cancel() cfg := tabletenv.NewDefaultConfig() cfg.TerseErrors = true - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() err := tsv.convertAndLogError( @@ -1847,7 +1853,8 @@ func TestSanitizeLogMessagesNonSQLError(t *testing.T) { cfg := tabletenv.NewDefaultConfig() cfg.TerseErrors = false cfg.SanitizeLogMessages = true - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() err := tsv.convertAndLogError( @@ -1872,7 +1879,8 @@ func TestSanitizeMessagesBindVars(t *testing.T) { cfg := tabletenv.NewDefaultConfig() cfg.TerseErrors = true cfg.SanitizeLogMessages = true - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() @@ -1903,7 +1911,8 @@ func TestSanitizeMessagesNoBindVars(t *testing.T) { cfg := tabletenv.NewDefaultConfig() cfg.TerseErrors = true cfg.SanitizeLogMessages = true - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() err := tsv.convertAndLogError(ctx, "", nil, vterrors.Errorf(vtrpcpb.Code_DEADLINE_EXCEEDED, "sensitive message"), nil) @@ -1921,7 +1930,8 @@ func TestTruncateErrorLen(t *testing.T) { defer cancel() cfg := tabletenv.NewDefaultConfig() cfg.TruncateErrorLen = 32 - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() err := tsv.convertAndLogError( @@ -1952,7 +1962,8 @@ func TestTruncateMessages(t *testing.T) { TruncateErrLen: 52, }) require.NoError(t, err) - tsv := NewTabletServer(ctx, env, "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, env, "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() @@ -2006,7 +2017,8 @@ func TestTerseErrorsIgnoreFailoverInProgress(t *testing.T) { defer cancel() cfg := tabletenv.NewDefaultConfig() cfg.TerseErrors = true - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) tl := newTestLogger() defer tl.Close() err := tsv.convertAndLogError(ctx, "select * from test_table where id = :a", @@ -2048,7 +2060,8 @@ func TestACLHUP(t *testing.T) { defer cancel() tableacl.Register("simpleacl", &simpleacl.Factory{}) cfg := tabletenv.NewDefaultConfig() - tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, vtenv.NewTestEnv(), "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) f, err := os.CreateTemp("", "tableacl") require.NoError(t, err) @@ -2564,7 +2577,8 @@ func setupTabletServerTest(t testing.TB, ctx context.Context, keyspaceName strin func setupTabletServerTestCustom(t testing.TB, ctx context.Context, cfg *tabletenv.TabletConfig, keyspaceName string, env *vtenv.Environment) (*fakesqldb.DB, *TabletServer) { db := setupFakeDB(t) sidecardb.AddSchemaInitQueries(db, true, env.Parser()) - tsv := NewTabletServer(ctx, env, "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}) + srvTopoCounts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + tsv := NewTabletServer(ctx, env, "TabletServerTest", cfg, memorytopo.NewServer(ctx, ""), &topodatapb.TabletAlias{}, srvTopoCounts) require.Equal(t, StateNotConnected, tsv.sm.State()) dbcfgs := newDBConfigs(db) target := &querypb.Target{ diff --git a/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go b/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go index 9c77ca18594..c09f73c0354 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go +++ b/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go @@ -20,12 +20,12 @@ package testenv import ( "context" "fmt" - "math/rand" "os" "regexp" "strings" "vitess.io/vitess/go/json2" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/dbconfigs" "vitess.io/vitess/go/vt/mysqlctl" "vitess.io/vitess/go/vt/srvtopo" @@ -79,9 +79,8 @@ func Init(ctx context.Context) (*Env, error) { if err := te.TopoServ.CreateShard(ctx, te.KeyspaceName, te.ShardName); err != nil { panic(err) } - // Add a random suffix to metric name to avoid panic. Another option would have been to generate a random string. - suffix := rand.Int() - te.SrvTopo = srvtopo.NewResilientServer(ctx, te.TopoServ, "TestTopo"+fmt.Sprint(suffix)) + counts := stats.NewCountersWithSingleLabel("", "Resilient srvtopo server operations", "type") + te.SrvTopo = srvtopo.NewResilientServer(ctx, te.TopoServ, counts) cfg := vttest.Config{ Topology: &vttestpb.VTTestTopology{ From 6c6817748c99f43a3caeddf55c4a5036a3fbfb25 Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Fri, 23 Feb 2024 14:52:06 +0100 Subject: [PATCH 53/79] discovery: Remove unused code (#15332) Signed-off-by: Dirkjan Bussink --- go/vt/discovery/utils.go | 22 ------ go/vt/discovery/utils_test.go | 134 ---------------------------------- 2 files changed, 156 deletions(-) delete mode 100644 go/vt/discovery/utils_test.go diff --git a/go/vt/discovery/utils.go b/go/vt/discovery/utils.go index 3a601830d35..253fead89a8 100644 --- a/go/vt/discovery/utils.go +++ b/go/vt/discovery/utils.go @@ -26,28 +26,6 @@ import ( // This file contains helper filter methods to process the unfiltered list of // tablets returned by HealthCheckImpl.GetTabletHealth*. -func TabletHealthReferenceListToValue(thl []*TabletHealth) []TabletHealth { - newTh := []TabletHealth{} - for _, th := range thl { - newTh = append(newTh, *th) - } - return newTh -} - -// RemoveUnhealthyTablets filters all unhealthy tablets out. -// NOTE: Non-serving tablets are considered healthy. -func RemoveUnhealthyTablets(tabletStatsList []TabletHealth) []TabletHealth { - result := make([]TabletHealth, 0, len(tabletStatsList)) - for _, ts := range tabletStatsList { - // Note we do not check the 'Serving' flag here. - if ts.LastError != nil || ts.Stats != nil && (ts.Stats.HealthError != "" || IsReplicationLagHigh(&ts)) { - continue - } - result = append(result, ts) - } - return result -} - func ParseTabletTypesAndOrder(tabletTypesStr string) ([]topodatapb.TabletType, bool, error) { inOrder := false if strings.HasPrefix(tabletTypesStr, InOrderHint) { diff --git a/go/vt/discovery/utils_test.go b/go/vt/discovery/utils_test.go deleted file mode 100644 index edca8c17602..00000000000 --- a/go/vt/discovery/utils_test.go +++ /dev/null @@ -1,134 +0,0 @@ -/* -Copyright 2018 The Vitess Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package discovery - -import ( - "errors" - "testing" - - querypb "vitess.io/vitess/go/vt/proto/query" - topodatapb "vitess.io/vitess/go/vt/proto/topodata" -) - -func TestRemoveUnhealthyTablets(t *testing.T) { - var testcases = []struct { - desc string - input []TabletHealth - want []TabletHealth - }{{ - desc: "tablets missing Stats", - input: []TabletHealth{replica(1), replica(2)}, - want: []TabletHealth{replica(1), replica(2)}, - }, { - desc: "all tablets healthy", - input: []TabletHealth{healthy(replica(1)), healthy(replica(2))}, - want: []TabletHealth{healthy(replica(1)), healthy(replica(2))}, - }, { - desc: "one unhealthy tablet (error)", - input: []TabletHealth{healthy(replica(1)), unhealthyError(replica(2))}, - want: []TabletHealth{healthy(replica(1))}, - }, { - desc: "one error tablet", - input: []TabletHealth{healthy(replica(1)), unhealthyLastError(replica(2))}, - want: []TabletHealth{healthy(replica(1))}, - }, { - desc: "one unhealthy tablet (lag)", - input: []TabletHealth{healthy(replica(1)), unhealthyLag(replica(2))}, - want: []TabletHealth{healthy(replica(1))}, - }, { - desc: "no filtering by tablet type", - input: []TabletHealth{healthy(primary(1)), healthy(replica(2)), healthy(rdonly(3))}, - want: []TabletHealth{healthy(primary(1)), healthy(replica(2)), healthy(rdonly(3))}, - }, { - desc: "non-serving tablets won't be removed", - input: []TabletHealth{notServing(healthy(replica(1)))}, - want: []TabletHealth{notServing(healthy(replica(1)))}, - }} - - for _, tc := range testcases { - t.Run(tc.desc, func(t *testing.T) { - got := RemoveUnhealthyTablets(tc.input) - if len(got) != len(tc.want) { - t.Errorf("test case '%v' failed: RemoveUnhealthyTablets(%v) = %#v, want: %#v", tc.desc, tc.input, got, tc.want) - } else { - for i := range tc.want { - if !got[i].DeepEqual(&tc.want[i]) { - t.Errorf("test case '%v' failed: RemoveUnhealthyTablets(%v) = %#v, want: %#v", tc.desc, tc.input, got, tc.want) - } - } - } - }) - } -} - -func primary(uid uint32) TabletHealth { - return minimalTabletStats(uid, topodatapb.TabletType_PRIMARY) -} - -func replica(uid uint32) TabletHealth { - return minimalTabletStats(uid, topodatapb.TabletType_REPLICA) -} - -func rdonly(uid uint32) TabletHealth { - return minimalTabletStats(uid, topodatapb.TabletType_RDONLY) -} - -func minimalTabletStats(uid uint32, tabletType topodatapb.TabletType) TabletHealth { - return TabletHealth{ - Tablet: &topodatapb.Tablet{ - Alias: &topodatapb.TabletAlias{ - Uid: uid}, - }, - Target: &querypb.Target{ - Keyspace: "test_keyspace", - Shard: "-80", - TabletType: tabletType, - }, - Serving: true, - } -} - -func healthy(ts TabletHealth) TabletHealth { - ts.Stats = &querypb.RealtimeStats{ - ReplicationLagSeconds: uint32(1), - } - return ts -} - -func unhealthyLag(ts TabletHealth) TabletHealth { - ts.Stats = &querypb.RealtimeStats{ - ReplicationLagSeconds: uint32(3600), - } - return ts -} - -func unhealthyError(ts TabletHealth) TabletHealth { - ts.Stats = &querypb.RealtimeStats{ - HealthError: "unhealthy", - } - return ts -} - -func unhealthyLastError(ts TabletHealth) TabletHealth { - ts.LastError = errors.New("err") - return ts -} - -func notServing(ts TabletHealth) TabletHealth { - ts.Serving = false - return ts -} From 4f8e465b3c437b8973569c91d0cd62503acbed5f Mon Sep 17 00:00:00 2001 From: Dirkjan Bussink Date: Fri, 23 Feb 2024 19:11:26 +0100 Subject: [PATCH 54/79] wranger: Clean up leak check and use existing version (#15334) Signed-off-by: Dirkjan Bussink --- go/vt/wrangler/materializer_env_test.go | 76 +-------- go/vt/wrangler/materializer_test.go | 209 ++++++------------------ 2 files changed, 56 insertions(+), 229 deletions(-) diff --git a/go/vt/wrangler/materializer_env_test.go b/go/vt/wrangler/materializer_env_test.go index 3d5797a6bff..e3a3364c8fd 100644 --- a/go/vt/wrangler/materializer_env_test.go +++ b/go/vt/wrangler/materializer_env_test.go @@ -19,19 +19,14 @@ package wrangler import ( "context" "fmt" - "os" "regexp" - "runtime" "strconv" "strings" "sync" "testing" - "time" - - "go.uber.org/goleak" "vitess.io/vitess/go/sqltypes" - "vitess.io/vitess/go/vt/log" + "vitess.io/vitess/go/test/utils" "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/mysqlctl/tmutils" "vitess.io/vitess/go/vt/sqlparser" @@ -40,7 +35,6 @@ import ( "vitess.io/vitess/go/vt/vtenv" "vitess.io/vitess/go/vt/vttablet/tmclient" - _flag "vitess.io/vitess/go/internal/flag" querypb "vitess.io/vitess/go/vt/proto/query" tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata" topodatapb "vitess.io/vitess/go/vt/proto/topodata" @@ -61,66 +55,9 @@ type testMaterializerEnv struct { //---------------------------------------------- // testMaterializerEnv -// EnsureNoLeaks is a helper function to fail tests if there are goroutine leaks. -// At this moment we still have a lot of goroutine leaks in the unit tests in this package. -// So we only use this while debugging and fixing the leaks. Once fixed we will use this -// in TestMain instead of just logging the number of leaked goroutines. -func EnsureNoLeaks(t testing.TB) { - if t.Failed() { - return - } - err := ensureNoGoroutines() - if err != nil { - t.Fatal(err) - } -} - -func ensureNoGoroutines() error { - // These goroutines have been found to stay around. - // Need to investigate and fix the Vitess ones at some point, if we indeed find out that they are unintended leaks. - var leaksToIgnore = []goleak.Option{ - goleak.IgnoreTopFunction("github.com/golang/glog.(*fileSink).flushDaemon"), - goleak.IgnoreTopFunction("github.com/golang/glog.(*loggingT).flushDaemon"), - goleak.IgnoreTopFunction("vitess.io/vitess/go/vt/dbconfigs.init.0.func1"), - goleak.IgnoreTopFunction("vitess.io/vitess/go/vt/vtgate.resetAggregators"), - goleak.IgnoreTopFunction("vitess.io/vitess/go/vt/vtgate.processQueryInfo"), - goleak.IgnoreTopFunction("github.com/patrickmn/go-cache.(*janitor).Run"), - } - - const ( - // give ample time for the goroutines to exit in CI. - waitTime = 100 * time.Millisecond - numIterations = 50 // 5 seconds - ) - var err error - for i := 0; i < numIterations; i++ { - err = goleak.Find(leaksToIgnore...) - if err == nil { - return nil - } - time.Sleep(waitTime) - } - return err -} - -func testMainWrapper(m *testing.M) int { - startingNumGoRoutines := runtime.NumGoroutine() - defer func() { - numGoroutines := runtime.NumGoroutine() - if numGoroutines > startingNumGoRoutines { - log.Infof("!!!!!!!!!!!! Wrangler unit tests Leaked %d goroutines", numGoroutines-startingNumGoRoutines) - } - }() - _flag.ParseFlagsForTest() - return m.Run() -} - -func TestMain(m *testing.M) { - os.Exit(testMainWrapper(m)) -} - -func newTestMaterializerEnv(t *testing.T, ctx context.Context, ms *vtctldatapb.MaterializeSettings, sources, targets []string) *testMaterializerEnv { +func newTestMaterializerEnv(t *testing.T, ms *vtctldatapb.MaterializeSettings, sources, targets []string) (*testMaterializerEnv, context.Context) { t.Helper() + ctx, cancel := context.WithCancel(context.Background()) env := &testMaterializerEnv{ ms: ms, sources: sources, @@ -167,7 +104,12 @@ func newTestMaterializerEnv(t *testing.T, ctx context.Context, ms *vtctldatapb.M if ms.Workflow != "" { env.expectValidation() } - return env + t.Cleanup(func() { + defer utils.EnsureNoLeaks(t) + env.close() + cancel() + }) + return env, ctx } func (env *testMaterializerEnv) expectValidation() { diff --git a/go/vt/wrangler/materializer_test.go b/go/vt/wrangler/materializer_test.go index bdeee1e6ac3..e7bb66f1003 100644 --- a/go/vt/wrangler/materializer_test.go +++ b/go/vt/wrangler/materializer_test.go @@ -65,10 +65,7 @@ func TestMoveTablesNoRoutingRules(t *testing.T) { SourceExpression: "select * from t1", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(100, mzCheckJournal, &sqltypes.Result{}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) @@ -93,11 +90,7 @@ func TestMigrateTables(t *testing.T) { SourceExpression: "select * from t1", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() - + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(100, mzCheckJournal, &sqltypes.Result{}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) env.tmc.expectVRQuery(200, insertPrefix, &sqltypes.Result{}) @@ -135,12 +128,8 @@ func TestMissingTables(t *testing.T) { SourceExpression: "select * from t3", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(100, mzCheckJournal, &sqltypes.Result{}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) env.tmc.expectVRQuery(200, insertPrefix, &sqltypes.Result{}) @@ -199,11 +188,7 @@ func TestMoveTablesAllAndExclude(t *testing.T) { } for _, tcase := range testCases { t.Run("", func(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(100, mzCheckJournal, &sqltypes.Result{}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) env.tmc.expectVRQuery(200, insertPrefix, &sqltypes.Result{}) @@ -231,11 +216,7 @@ func TestMoveTablesStopFlags(t *testing.T) { var err error t.Run("StopStartedAndStopAfterCopyFlags", func(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(100, mzCheckJournal, &sqltypes.Result{}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) // insert expects flag stop_after_copy to be true @@ -261,12 +242,7 @@ func TestMigrateVSchema(t *testing.T) { SourceExpression: "select * from t1", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() - + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(100, mzCheckJournal, &sqltypes.Result{}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) env.tmc.expectVRQuery(200, insertPrefix, &sqltypes.Result{}) @@ -294,11 +270,8 @@ func TestCreateLookupVindexFull(t *testing.T) { SourceKeyspace: "sourceks", TargetKeyspace: "targetks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) specs := &vschemapb.Keyspace{ Vindexes: map[string]*vschemapb.Vindex{ @@ -420,11 +393,9 @@ func TestCreateLookupVindexCreateDDL(t *testing.T) { SourceKeyspace: "sourceks", TargetKeyspace: "targetks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) + vs := &vschemapb.Keyspace{ Sharded: true, Vindexes: map[string]*vschemapb.Vindex{ @@ -640,11 +611,8 @@ func TestCreateLookupVindexSourceVSchema(t *testing.T) { SourceKeyspace: "sourceks", TargetKeyspace: "targetks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) specs := &vschemapb.Keyspace{ Vindexes: map[string]*vschemapb.Vindex{ @@ -879,11 +847,9 @@ func TestCreateLookupVindexTargetVSchema(t *testing.T) { SourceKeyspace: "sourceks", TargetKeyspace: "targetks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) + sourcevs := &vschemapb.Keyspace{ Sharded: true, Vindexes: map[string]*vschemapb.Vindex{ @@ -1118,11 +1084,8 @@ func TestCreateLookupVindexSameKeyspace(t *testing.T) { SourceKeyspace: "ks", TargetKeyspace: "ks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) specs := &vschemapb.Keyspace{ Vindexes: map[string]*vschemapb.Vindex{ @@ -1230,11 +1193,8 @@ func TestCreateCustomizedVindex(t *testing.T) { SourceKeyspace: "ks", TargetKeyspace: "ks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) specs := &vschemapb.Keyspace{ Vindexes: map[string]*vschemapb.Vindex{ @@ -1343,11 +1303,8 @@ func TestCreateLookupVindexIgnoreNulls(t *testing.T) { SourceKeyspace: "ks", TargetKeyspace: "ks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) specs := &vschemapb.Keyspace{ Vindexes: map[string]*vschemapb.Vindex{ @@ -1464,11 +1421,9 @@ func TestStopAfterCopyFlag(t *testing.T) { SourceKeyspace: "ks", TargetKeyspace: "ks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) + specs := &vschemapb.Keyspace{ Vindexes: map[string]*vschemapb.Vindex{ "v": { @@ -1817,11 +1772,8 @@ func TestExternalizeVindex(t *testing.T) { SourceKeyspace: "sourceks", TargetKeyspace: "targetks", } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + env, _ := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) sourceVSchema := &vschemapb.Keyspace{ Sharded: true, @@ -1968,11 +1920,8 @@ func TestMaterializerOneToOne(t *testing.T) { topodatapb.TabletType_RDONLY, }), } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) env.tmc.expectVRQuery( @@ -2012,11 +1961,8 @@ func TestMaterializerManyToOne(t *testing.T) { CreateDdl: "t2ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"-80", "80-"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"-80", "80-"}, []string{"0"}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) env.tmc.expectVRQuery( @@ -2046,11 +1992,8 @@ func TestMaterializerOneToMany(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2106,11 +2049,8 @@ func TestMaterializerManyToMany(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"-40", "40-"}, []string{"-80", "80-"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"-40", "40-"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2167,11 +2107,8 @@ func TestMaterializerMulticolumnVindex(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2234,11 +2171,8 @@ func TestMaterializerDeploySchema(t *testing.T) { CreateDdl: "t2ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) delete(env.tmc.schema, "targetks.t2") @@ -2275,11 +2209,8 @@ func TestMaterializerCopySchema(t *testing.T) { CreateDdl: "t2ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) delete(env.tmc.schema, "targetks.t1") @@ -2313,11 +2244,8 @@ func TestMaterializerExplicitColumns(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2376,11 +2304,8 @@ func TestMaterializerRenamedColumns(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2444,11 +2369,8 @@ func TestMaterializerStopAfterCopy(t *testing.T) { CreateDdl: "t2ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) env.tmc.expectVRQuery(200, insertPrefix+`.*stop_after_copy:true`, &sqltypes.Result{}) @@ -2470,11 +2392,8 @@ func TestMaterializerNoTargetVSchema(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2500,11 +2419,8 @@ func TestMaterializerNoDDL(t *testing.T) { CreateDdl: "", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) delete(env.tmc.schema, "targetks.t1") @@ -2544,7 +2460,6 @@ func TestMaterializerNoSourcePrimary(t *testing.T) { tmc: newTestMaterializerTMClient(), } env.wr = New(vtenv.NewTestEnv(), logutil.NewConsoleLogger(), env.topoServ, env.tmc) - defer env.close() tabletID := 100 for _, shard := range sources { @@ -2577,11 +2492,8 @@ func TestMaterializerTableMismatchNonCopy(t *testing.T) { CreateDdl: "", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) delete(env.tmc.schema, "targetks.t1") @@ -2601,11 +2513,8 @@ func TestMaterializerTableMismatchCopy(t *testing.T) { CreateDdl: "copy", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) delete(env.tmc.schema, "targetks.t1") @@ -2625,11 +2534,8 @@ func TestMaterializerNoSourceTable(t *testing.T) { CreateDdl: "copy", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) delete(env.tmc.schema, "targetks.t1") delete(env.tmc.schema, "sourceks.t1") @@ -2650,11 +2556,8 @@ func TestMaterializerSyntaxError(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) err := env.wr.Materialize(ctx, ms) @@ -2672,11 +2575,8 @@ func TestMaterializerNotASelect(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) err := env.wr.Materialize(ctx, ms) @@ -2694,11 +2594,8 @@ func TestMaterializerNoGoodVindex(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2743,10 +2640,8 @@ func TestMaterializerComplexVindexExpression(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -2786,10 +2681,8 @@ func TestMaterializerNoVindexInExpression(t *testing.T) { CreateDdl: "t1ddl", }}, } - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"-80", "80-"}) - defer env.close() + + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"-80", "80-"}) vs := &vschemapb.Keyspace{ Sharded: true, @@ -3244,9 +3137,7 @@ func TestMaterializerSourceShardSelection(t *testing.T) { for _, tcase := range testcases { t.Run(tcase.name, func(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, tcase.sourceShards, tcase.targetShards) + env, ctx := newTestMaterializerEnv(t, ms, tcase.sourceShards, tcase.targetShards) if err := env.topoServ.SaveVSchema(ctx, "targetks", tcase.targetVSchema); err != nil { t.Fatal(err) } @@ -3255,7 +3146,7 @@ func TestMaterializerSourceShardSelection(t *testing.T) { t.Fatal(err) } } - defer env.close() + for i, targetShard := range tcase.targetShards { tabletID := 200 + i*10 env.tmc.expectVRQuery(tabletID, mzSelectFrozenQuery, &sqltypes.Result{}) @@ -3293,16 +3184,12 @@ func TestMoveTablesDDLFlag(t *testing.T) { SourceExpression: "select * from t1", }}, } - ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) - defer cancel() for onDDLAction := range binlogdatapb.OnDDLAction_value { t.Run(fmt.Sprintf("OnDDL Flag:%v", onDDLAction), func(t *testing.T) { - ctx, cancel := context.WithCancel(ctx) + env, ctx := newTestMaterializerEnv(t, ms, []string{"0"}, []string{"0"}) + ctx, cancel := context.WithTimeout(ctx, 60*time.Second) defer cancel() - env := newTestMaterializerEnv(t, ctx, ms, []string{"0"}, []string{"0"}) - defer env.close() - env.tmc.expectVRQuery(100, mzCheckJournal, &sqltypes.Result{}) env.tmc.expectVRQuery(200, mzSelectFrozenQuery, &sqltypes.Result{}) if onDDLAction == binlogdatapb.OnDDLAction_IGNORE.String() { @@ -3522,8 +3409,6 @@ func TestAddTablesToVSchema(t *testing.T) { // means that even if the target keyspace is sharded, the source // does not need to perform the in_keyrange filtering. func TestKeyRangesEqualOptimization(t *testing.T) { - ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) - defer cancel() workflow := "testwf" sourceKs := "sourceks" targetKs := "targetks" @@ -3698,9 +3583,9 @@ func TestKeyRangesEqualOptimization(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - env := newTestMaterializerEnv(t, ctx, tc.ms, tc.sourceShards, tc.targetShards) - defer env.close() - + env, ctx := newTestMaterializerEnv(t, tc.ms, tc.sourceShards, tc.targetShards) + ctx, cancel := context.WithTimeout(ctx, 30*time.Second) + defer cancel() // Target is always sharded. err := env.wr.ts.SaveVSchema(ctx, targetKs, targetVSchema) require.NoError(t, err, "SaveVSchema failed: %v", err) From d8f771c695b5b82ec8b104b66587018b6e18f2fa Mon Sep 17 00:00:00 2001 From: Matt Layher Date: Fri, 23 Feb 2024 15:48:15 -0500 Subject: [PATCH 55/79] go/vt/discovery: use protobuf getters for SrvVschema (#15343) Signed-off-by: Matt Layher --- go/vt/discovery/keyspace_events.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/go/vt/discovery/keyspace_events.go b/go/vt/discovery/keyspace_events.go index c2567da9a87..014284ed5ee 100644 --- a/go/vt/discovery/keyspace_events.go +++ b/go/vt/discovery/keyspace_events.go @@ -391,8 +391,7 @@ func (kss *keyspaceState) getMoveTablesStatus(vs *vschemapb.SrvVSchema) (*MoveTa } // if there are no routing rules defined, then movetables is not in progress, exit early - if (vs.RoutingRules != nil && len(vs.RoutingRules.Rules) == 0) && - (vs.ShardRoutingRules != nil && len(vs.ShardRoutingRules.Rules) == 0) { + if len(vs.GetRoutingRules().GetRules()) == 0 && len(vs.GetShardRoutingRules().GetRules()) == 0 { return mtState, nil } From 47e137539bf70eade637edcbcbe151205ffebcee Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Sun, 25 Feb 2024 18:08:29 +0200 Subject: [PATCH 56/79] VReplication/OnlineDDL: reordering enum values (#15103) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- .../vrepl_suite/testdata/enum-reorder/alter | 1 + .../testdata/enum-reorder/create.sql | 26 ++ go/vt/schemadiff/types.go | 4 +- go/vt/vttablet/onlineddl/executor.go | 1 - go/vt/vttablet/onlineddl/vrepl.go | 23 +- go/vt/vttablet/onlineddl/vrepl/columns.go | 2 +- .../vttablet/onlineddl/vrepl/columns_test.go | 245 ++++++++++++++++++ go/vt/vttablet/onlineddl/vrepl/foreign_key.go | 1 - .../vreplication/replicator_plan.go | 9 +- 9 files changed, 301 insertions(+), 11 deletions(-) create mode 100644 go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/alter create mode 100644 go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/create.sql diff --git a/go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/alter b/go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/alter new file mode 100644 index 00000000000..6e011c14192 --- /dev/null +++ b/go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/alter @@ -0,0 +1 @@ +change e e enum('blue', 'green', 'red') not null diff --git a/go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/create.sql b/go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/create.sql new file mode 100644 index 00000000000..84ebd4094c1 --- /dev/null +++ b/go/test/endtoend/onlineddl/vrepl_suite/testdata/enum-reorder/create.sql @@ -0,0 +1,26 @@ +drop table if exists onlineddl_test; +create table onlineddl_test ( + id int auto_increment, + i int not null, + e enum('red', 'green', 'blue') not null, + primary key(id) +) auto_increment=1; + +insert into onlineddl_test values (null, 11, 'red'); +insert into onlineddl_test values (null, 13, 'green'); +insert into onlineddl_test values (null, 17, 'blue'); + +drop event if exists onlineddl_test; +delimiter ;; +create event onlineddl_test + on schedule every 1 second + starts current_timestamp + ends current_timestamp + interval 60 second + on completion not preserve + enable + do +begin + insert into onlineddl_test values (null, 211, 'red'); + insert into onlineddl_test values (null, 213, 'green'); + insert into onlineddl_test values (null, 217, 'blue'); +end ;; diff --git a/go/vt/schemadiff/types.go b/go/vt/schemadiff/types.go index 30814dfc26c..a4edb09ec9b 100644 --- a/go/vt/schemadiff/types.go +++ b/go/vt/schemadiff/types.go @@ -120,8 +120,8 @@ const ( ) const ( - EnumReorderStrategyReject int = iota - EnumReorderStrategyAllow + EnumReorderStrategyAllow int = iota + EnumReorderStrategyReject ) // DiffHints is an assortment of rules for diffing entities diff --git a/go/vt/vttablet/onlineddl/executor.go b/go/vt/vttablet/onlineddl/executor.go index 30bb465a1f0..0fff5d920eb 100644 --- a/go/vt/vttablet/onlineddl/executor.go +++ b/go/vt/vttablet/onlineddl/executor.go @@ -2801,7 +2801,6 @@ func (e *Executor) evaluateDeclarativeDiff(ctx context.Context, onlineDDL *schem senv := schemadiff.NewEnv(e.env.Environment(), e.env.Environment().CollationEnv().DefaultConnectionCharset()) hints := &schemadiff.DiffHints{ AutoIncrementStrategy: schemadiff.AutoIncrementApplyHigher, - EnumReorderStrategy: schemadiff.EnumReorderStrategyAllow, } switch ddlStmt.(type) { case *sqlparser.CreateTable: diff --git a/go/vt/vttablet/onlineddl/vrepl.go b/go/vt/vttablet/onlineddl/vrepl.go index ef38fb7d012..847e40e3fbc 100644 --- a/go/vt/vttablet/onlineddl/vrepl.go +++ b/go/vt/vttablet/onlineddl/vrepl.go @@ -491,11 +491,26 @@ func (v *VRepl) analyzeTables(ctx context.Context, conn *dbconnpool.DBConnection for i := range v.sourceSharedColumns.Columns() { sourceColumn := v.sourceSharedColumns.Columns()[i] mappedColumn := v.targetSharedColumns.Columns()[i] - if sourceColumn.Type == vrepl.EnumColumnType && mappedColumn.Type != vrepl.EnumColumnType && mappedColumn.Charset != "" { - // A column is converted from ENUM type to textual type - v.targetSharedColumns.SetEnumToTextConversion(mappedColumn.Name, sourceColumn.EnumValues) - v.enumToTextMap[sourceColumn.Name] = sourceColumn.EnumValues + if sourceColumn.Type == vrepl.EnumColumnType { + switch { + // Either this is an ENUM column that stays an ENUM, or it is converted to a textual type. + // We take note of the enum values, and make it available in vreplication's Filter.Rule.ConvertEnumToText. + // This, in turn, will be used by vplayer (in TablePlan) like so: + // - In the binary log, enum values are integers. + // - Upon seeing this map, PlanBuilder will convert said int to the enum's logical string value. + // - And will apply the value as a string (`StringBindVariable`) in the query. + // What this allows is for enum values to have different ordering in the before/after table schema, + // so that for example you could modify an enum column: + // - from `('red', 'green', 'blue')` to `('red', 'blue')` + // - from `('red', 'green', 'blue')` to `('blue', 'red', 'green')` + case mappedColumn.Type == vrepl.EnumColumnType: + v.enumToTextMap[sourceColumn.Name] = sourceColumn.EnumValues + case mappedColumn.Charset != "": + v.enumToTextMap[sourceColumn.Name] = sourceColumn.EnumValues + v.targetSharedColumns.SetEnumToTextConversion(mappedColumn.Name, sourceColumn.EnumValues) + } } + if sourceColumn.IsIntegralType() && mappedColumn.Type == vrepl.EnumColumnType { v.intToEnumMap[sourceColumn.Name] = true } diff --git a/go/vt/vttablet/onlineddl/vrepl/columns.go b/go/vt/vttablet/onlineddl/vrepl/columns.go index 2937b1b2b2c..f2bb8f6d3f2 100644 --- a/go/vt/vttablet/onlineddl/vrepl/columns.go +++ b/go/vt/vttablet/onlineddl/vrepl/columns.go @@ -129,7 +129,7 @@ func isExpandedColumn(sourceColumn *Column, targetColumn *Column) (bool, string) return true, "source is unsigned, target is signed" } if sourceColumn.NumericPrecision <= targetColumn.NumericPrecision && !sourceColumn.IsUnsigned && targetColumn.IsUnsigned { - // e.g. INT SIGNED => INT UNSIGNED, INT SIGNED = BIGINT UNSIGNED + // e.g. INT SIGNED => INT UNSIGNED, INT SIGNED => BIGINT UNSIGNED return true, "target unsigned value exceeds source unsigned value" } if targetColumn.IsFloatingPoint() && !sourceColumn.IsFloatingPoint() { diff --git a/go/vt/vttablet/onlineddl/vrepl/columns_test.go b/go/vt/vttablet/onlineddl/vrepl/columns_test.go index b4d3ac9af58..201ffe55201 100644 --- a/go/vt/vttablet/onlineddl/vrepl/columns_test.go +++ b/go/vt/vttablet/onlineddl/vrepl/columns_test.go @@ -133,3 +133,248 @@ func TestGetSharedColumns(t *testing.T) { }) } } + +func TestGetExpandedColumnNames(t *testing.T) { + var ( + columnsA = &ColumnList{ + columns: []Column{ + { + Name: "c1", + IsNullable: true, + }, + { + Name: "c2", + IsNullable: true, + }, + { + Name: "c3", + IsNullable: false, + }, + }, + Ordinals: ColumnsMap{}, + } + columnsB = &ColumnList{ + columns: []Column{ + { + Name: "c1", + IsNullable: true, + }, + { + Name: "c2", + IsNullable: false, + }, + { + Name: "c3", + IsNullable: true, + }, + }, + Ordinals: ColumnsMap{}, + } + ) + tcases := []struct { + name string + sourceCol Column + targetCol Column + expanded bool + }{ + { + "both nullable", + Column{ + IsNullable: true, + }, + Column{ + IsNullable: true, + }, + false, + }, + { + "nullable to non nullable", + Column{ + IsNullable: true, + }, + Column{ + IsNullable: false, + }, + false, + }, + { + "non nullable to nullable", + Column{ + IsNullable: false, + }, + Column{ + IsNullable: true, + }, + true, + }, + { + "signed to unsigned", + Column{ + Type: IntegerColumnType, + NumericPrecision: 4, + IsUnsigned: false, + }, + Column{ + Type: IntegerColumnType, + NumericPrecision: 4, + IsUnsigned: true, + }, + true, + }, + { + "unsigned to signed", + Column{ + Type: IntegerColumnType, + NumericPrecision: 4, + IsUnsigned: true, + }, + Column{ + Type: IntegerColumnType, + NumericPrecision: 4, + IsUnsigned: false, + }, + true, + }, + { + "signed to smaller unsigned", + Column{ + Type: IntegerColumnType, + NumericPrecision: 8, + IsUnsigned: false, + }, + Column{ + Type: IntegerColumnType, + NumericPrecision: 4, + IsUnsigned: true, + }, + false, + }, + { + "same char length", + Column{ + CharacterMaximumLength: 20, + }, + Column{ + CharacterMaximumLength: 20, + }, + false, + }, + { + "reduced char length", + Column{ + CharacterMaximumLength: 20, + }, + Column{ + CharacterMaximumLength: 19, + }, + false, + }, + { + "increased char length", + Column{ + CharacterMaximumLength: 20, + }, + Column{ + CharacterMaximumLength: 21, + }, + true, + }, + { + "expand temporal", + Column{ + DataType: "time", + }, + Column{ + DataType: "timestamp", + }, + true, + }, + { + "expand temporal", + Column{ + DataType: "date", + }, + Column{ + DataType: "timestamp", + }, + true, + }, + { + "expand temporal", + Column{ + DataType: "date", + }, + Column{ + DataType: "datetime", + }, + true, + }, + { + "non expand temporal", + Column{ + DataType: "datetime", + }, + Column{ + DataType: "timestamp", + }, + false, + }, + { + "expand temporal", + Column{ + DataType: "timestamp", + }, + Column{ + DataType: "datetime", + }, + true, + }, + { + "expand enum", + Column{ + Type: EnumColumnType, + EnumValues: "'a', 'b'", + }, + Column{ + Type: EnumColumnType, + EnumValues: "'a', 'x'", + }, + true, + }, + { + "expand enum", + Column{ + Type: EnumColumnType, + EnumValues: "'a', 'b'", + }, + Column{ + Type: EnumColumnType, + EnumValues: "'a', 'b', 'c'", + }, + true, + }, + { + "reduce enum", + Column{ + Type: EnumColumnType, + EnumValues: "'a', 'b', 'c'", + }, + Column{ + Type: EnumColumnType, + EnumValues: "'a', 'b'", + }, + false, + }, + } + + expectedExpandedColumnNames := []string{"c3"} + expandedColumnNames, _ := GetExpandedColumnNames(columnsA, columnsB) + assert.Equal(t, expectedExpandedColumnNames, expandedColumnNames) + + for _, tcase := range tcases { + t.Run(tcase.name, func(t *testing.T) { + expanded, _ := isExpandedColumn(&tcase.sourceCol, &tcase.targetCol) + assert.Equal(t, tcase.expanded, expanded) + }) + } +} diff --git a/go/vt/vttablet/onlineddl/vrepl/foreign_key.go b/go/vt/vttablet/onlineddl/vrepl/foreign_key.go index 8671badadc0..79e2df614f4 100644 --- a/go/vt/vttablet/onlineddl/vrepl/foreign_key.go +++ b/go/vt/vttablet/onlineddl/vrepl/foreign_key.go @@ -38,7 +38,6 @@ func RemovedForeignKeyNames( env := schemadiff.NewEnv(venv, venv.CollationEnv().DefaultConnectionCharset()) diffHints := schemadiff.DiffHints{ ConstraintNamesStrategy: schemadiff.ConstraintNamesIgnoreAll, - EnumReorderStrategy: schemadiff.EnumReorderStrategyAllow, } diff, err := schemadiff.DiffCreateTablesQueries(env, originalCreateTable, vreplCreateTable, &diffHints) if err != nil { diff --git a/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go b/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go index a328249d0e0..424daad4871 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go +++ b/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go @@ -338,8 +338,13 @@ func (tp *TablePlan) bindFieldVal(field *querypb.Field, val *sqltypes.Value) (*q if enumValues, ok := tp.EnumValuesMap[field.Name]; ok && !val.IsNull() { // The fact that this field has a EnumValuesMap entry, means we must // use the enum's text value as opposed to the enum's numerical value. - // Once known use case is with Online DDL, when a column is converted from - // ENUM to a VARCHAR/TEXT. + // This may be needed in Online DDL, when the enum column could be modified: + // - Either from ENUM to a text type (VARCHAR/TEXT) + // - Or from ENUM to another ENUM with different value ordering, + // e.g. from `('red', 'green', 'blue')` to `('red', 'blue')`. + // By applying the textual value of an enum we eliminate the ordering concern. + // In non-Online DDL this shouldn't be a concern because the schema is static, + // and so passing the enum's numerical value is sufficient. enumValue, enumValueOK := enumValues[val.ToString()] if !enumValueOK { return nil, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "Invalid enum value: %v for field %s", val, field.Name) From 8de1c9180f3d6a6ed34f19029e21e6e1960eb4fc Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Mon, 26 Feb 2024 12:10:34 -0500 Subject: [PATCH 57/79] VReplication: use proper column collations in vstreamer (#15313) Signed-off-by: Matt Lord --- go/mysql/binlog_event.go | 9 ++ go/mysql/binlog_event_make_test.go | 15 +-- go/mysql/binlog_event_rbr.go | 87 +++++++++++++++-- .../vreplication/vcopier_test.go | 10 +- .../tabletserver/repltracker/reader.go | 3 +- .../vttablet/tabletserver/schema/historian.go | 4 +- go/vt/vttablet/tabletserver/schema/tracker.go | 10 +- .../vstreamer/helper_event_test.go | 38 +++++--- .../tabletserver/vstreamer/rowstreamer.go | 2 +- .../tabletserver/vstreamer/testenv/testenv.go | 42 ++++++++- .../tabletserver/vstreamer/vstreamer.go | 58 +++++++++--- .../tabletserver/vstreamer/vstreamer_test.go | 93 +++++++++++++------ 12 files changed, 287 insertions(+), 84 deletions(-) diff --git a/go/mysql/binlog_event.go b/go/mysql/binlog_event.go index e58cb9b254c..3acf99c2408 100644 --- a/go/mysql/binlog_event.go +++ b/go/mysql/binlog_event.go @@ -19,7 +19,9 @@ package mysql import ( "fmt" + "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/mysql/replication" + binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" ) @@ -216,6 +218,13 @@ type TableMap struct { // - If the metadata is one byte, only the lower 8 bits are used. // - If the metadata is two bytes, all 16 bits are used. Metadata []uint16 + + // ColumnCollationIDs contains information about the inherited + // or implied column default collation and any explicit per-column + // override for text based columns ONLY. This means that the + // array position needs to be mapped to the ordered list of + // text based columns in the table. + ColumnCollationIDs []collations.ID } // Rows contains data from a {WRITE,UPDATE,DELETE}_ROWS_EVENT. diff --git a/go/mysql/binlog_event_make_test.go b/go/mysql/binlog_event_make_test.go index 12d8a54ff97..32401bfa401 100644 --- a/go/mysql/binlog_event_make_test.go +++ b/go/mysql/binlog_event_make_test.go @@ -23,6 +23,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/mysql/binlog" @@ -222,6 +223,7 @@ func TestTableMapEvent(t *testing.T) { 0, 384, // Length of the varchar field. }, + ColumnCollationIDs: []collations.ID{}, } tm.CanBeNull.Set(1, true) tm.CanBeNull.Set(2, true) @@ -258,12 +260,13 @@ func TestLargeTableMapEvent(t *testing.T) { } tm := &TableMap{ - Flags: 0x8090, - Database: "my_database", - Name: "my_table", - Types: types, - CanBeNull: NewServerBitmap(colLen), - Metadata: metadata, + Flags: 0x8090, + Database: "my_database", + Name: "my_table", + Types: types, + CanBeNull: NewServerBitmap(colLen), + Metadata: metadata, + ColumnCollationIDs: []collations.ID{}, } tm.CanBeNull.Set(1, true) tm.CanBeNull.Set(2, true) diff --git a/go/mysql/binlog_event_rbr.go b/go/mysql/binlog_event_rbr.go index 58777d4cfba..64d17c2b306 100644 --- a/go/mysql/binlog_event_rbr.go +++ b/go/mysql/binlog_event_rbr.go @@ -20,12 +20,35 @@ import ( "encoding/binary" "vitess.io/vitess/go/mysql/binlog" - "vitess.io/vitess/go/vt/proto/vtrpc" + "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/vt/vterrors" querypb "vitess.io/vitess/go/vt/proto/query" + vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) +// These are the TABLE_MAP_EVENT's optional metadata field types from +// MySQL's libbinlogevents/include/rows_event.h. +// See also: https://dev.mysql.com/doc/dev/mysql-server/8.0.34/structbinary__log_1_1Table__map__event_1_1Optional__metadata__fields.html +const ( + tableMapSignedness uint8 = iota + 1 + tableMapDefaultCharset + tableMapColumnCharset + tableMapColumnName + tableMapSetStrValue + tableMapEnumStrValue + tableMapGeometryType + tableMapSimplePrimaryKey + tableMapPrimaryKeyWithPrefix + tableMapEnumAndSetDefaultCharset + tableMapEnumAndSetColumnCharset + tableMapColumnVisibility +) + +// This byte in the optional metadata indicates that we should +// read the next 2 bytes as a collation ID. +const readTwoByteCollationID = 252 + // TableMap implements BinlogEvent.TableMap(). // // Expected format (L = total length of event data): @@ -43,6 +66,7 @@ import ( // cc column-def, one byte per column // column-meta-def (var-len encoded string) // n NULL-bitmask, length: (cc + 7) / 8 +// n Optional Metadata func (ev binlogEvent) TableMap(f BinlogFormat) (*TableMap, error) { data := ev.Bytes()[f.HeaderLength:] @@ -64,7 +88,7 @@ func (ev binlogEvent) TableMap(f BinlogFormat) (*TableMap, error) { columnCount, read, ok := readLenEncInt(data, pos) if !ok { - return nil, vterrors.Errorf(vtrpc.Code_INTERNAL, "expected column count at position %v (data=%v)", pos, data) + return nil, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "expected column count at position %v (data=%v)", pos, data) } pos = read @@ -73,7 +97,7 @@ func (ev binlogEvent) TableMap(f BinlogFormat) (*TableMap, error) { metaLen, read, ok := readLenEncInt(data, pos) if !ok { - return nil, vterrors.Errorf(vtrpc.Code_INTERNAL, "expected metadata length at position %v (data=%v)", pos, data) + return nil, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "expected metadata length at position %v (data=%v)", pos, data) } pos = read @@ -88,11 +112,19 @@ func (ev binlogEvent) TableMap(f BinlogFormat) (*TableMap, error) { } } if pos != expectedEnd { - return nil, vterrors.Errorf(vtrpc.Code_INTERNAL, "unexpected metadata end: got %v was expecting %v (data=%v)", pos, expectedEnd, data) + return nil, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "unexpected metadata end: got %v was expecting %v (data=%v)", pos, expectedEnd, data) } // A bit array that says if each column can be NULL. - result.CanBeNull, _ = newBitmap(data, pos, int(columnCount)) + result.CanBeNull, read = newBitmap(data, pos, int(columnCount)) + pos = read + + // Read any text based column collation values provided in the optional metadata. + // The binlog_row_metadata only contains this info for text based columns. + var err error + if result.ColumnCollationIDs, err = readColumnCollationIDs(data, pos, int(columnCount)); err != nil { + return nil, err + } return result, nil } @@ -118,7 +150,7 @@ func metadataLength(typ byte) int { default: // Unknown type. This is used in tests only, so panic. - panic(vterrors.Errorf(vtrpc.Code_INTERNAL, "metadataLength: unhandled data type: %v", typ)) + panic(vterrors.Errorf(vtrpcpb.Code_INTERNAL, "metadataLength: unhandled data type: %v", typ)) } } @@ -154,7 +186,7 @@ func metadataRead(data []byte, pos int, typ byte) (uint16, int, error) { default: // Unknown types, we can't go on. - return 0, 0, vterrors.Errorf(vtrpc.Code_INTERNAL, "metadataRead: unhandled data type: %v", typ) + return 0, 0, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "metadataRead: unhandled data type: %v", typ) } } @@ -185,8 +217,45 @@ func metadataWrite(data []byte, pos int, typ byte, value uint16) int { default: // Unknown type. This is used in tests only, so panic. - panic(vterrors.Errorf(vtrpc.Code_INTERNAL, "metadataRead: unhandled data type: %v", typ)) + panic(vterrors.Errorf(vtrpcpb.Code_INTERNAL, "metadataRead: unhandled data type: %v", typ)) + } +} + +// readColumnCollationIDs reads from the optional metadata that exists. +// See: https://github.com/mysql/mysql-server/blob/8.0/libbinlogevents/include/rows_event.h +// What's included depends on the server configuration: +// https://dev.mysql.com/doc/refman/en/replication-options-binary-log.html#sysvar_binlog_row_metadata +// and the table definition. +// We only care about any collation IDs in the optional metadata and +// this info is provided in all binlog_row_metadata formats. Note that +// this info is only provided for text based columns. +func readColumnCollationIDs(data []byte, pos, count int) ([]collations.ID, error) { + collationIDs := make([]collations.ID, 0, count) + for pos < len(data) { + fieldType := uint8(data[pos]) + pos++ + + fieldLen, read, ok := readLenEncInt(data, pos) + if !ok { + return nil, vterrors.New(vtrpcpb.Code_INTERNAL, "error reading optional metadata field length") + } + pos = read + + fieldVal := data[pos : pos+int(fieldLen)] + pos += int(fieldLen) + + if fieldType == tableMapDefaultCharset || fieldType == tableMapColumnCharset { // It's one or the other + for i := uint64(0); i < fieldLen; i++ { + v := uint16(fieldVal[i]) + if v == readTwoByteCollationID { // The ID is the subsequent 2 bytes + v = binary.LittleEndian.Uint16(fieldVal[i+1 : i+3]) + i += 2 + } + collationIDs = append(collationIDs, collations.ID(v)) + } + } } + return collationIDs, nil } // Rows implements BinlogEvent.TableMap(). @@ -235,7 +304,7 @@ func (ev binlogEvent) Rows(f BinlogFormat, tm *TableMap) (Rows, error) { columnCount, read, ok := readLenEncInt(data, pos) if !ok { - return result, vterrors.Errorf(vtrpc.Code_INTERNAL, "expected column count at position %v (data=%v)", pos, data) + return result, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "expected column count at position %v (data=%v)", pos, data) } pos = read diff --git a/go/vt/vttablet/tabletmanager/vreplication/vcopier_test.go b/go/vt/vttablet/tabletmanager/vreplication/vcopier_test.go index c32482641b2..fb5648f49af 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vcopier_test.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vcopier_test.go @@ -108,7 +108,7 @@ func testPlayerCopyCharPK(t *testing.T) { defer func() { waitRetryTime = savedWaitRetryTime }() execStatements(t, []string{ - "create table src(idc binary(2) , val int, primary key(idc))", + "create table src(idc binary(2), val int, primary key(idc))", "insert into src values('a', 1), ('c', 2)", fmt.Sprintf("create table %s.dst(idc binary(2), val int, primary key(idc))", vrepldb), }) @@ -215,7 +215,7 @@ func testPlayerCopyVarcharPKCaseInsensitive(t *testing.T) { defer func() { waitRetryTime = savedWaitRetryTime }() execStatements(t, []string{ - "create table src(idc varchar(20), val int, primary key(idc))", + "create table src(idc varchar(20), val int, primary key(idc)) character set utf8mb3", // Use utf8mb3 to get a consistent default collation across MySQL versions "insert into src values('a', 1), ('c', 2)", fmt.Sprintf("create table %s.dst(idc varchar(20), val int, primary key(idc))", vrepldb), }) @@ -285,7 +285,7 @@ func testPlayerCopyVarcharPKCaseInsensitive(t *testing.T) { "/update _vt.vreplication set state='Copying'", // Copy mode. "insert into dst(idc,val) values ('a',1)", - `/insert into _vt.copy_state \(lastpk, vrepl_id, table_name\) values \('fields:{name:\\"idc\\" type:VARCHAR charset:45 flags:20483} rows:{lengths:1 values:\\"a\\"}'.*`, + `/insert into _vt.copy_state \(lastpk, vrepl_id, table_name\) values \('fields:{name:\\"idc\\" type:VARCHAR charset:33 flags:20483} rows:{lengths:1 values:\\"a\\"}'.*`, // Copy-catchup mode. `/insert into dst\(idc,val\) select 'B', 3 from dual where \( .* 'B' COLLATE .* \) <= \( .* 'a' COLLATE .* \)`, ).Then(func(expect qh.ExpectationSequencer) qh.ExpectationSequencer { @@ -295,11 +295,11 @@ func testPlayerCopyVarcharPKCaseInsensitive(t *testing.T) { //upd1 := expect. upd1 := expect.Then(qh.Eventually( "insert into dst(idc,val) values ('B',3)", - `/insert into _vt.copy_state \(lastpk, vrepl_id, table_name\) values \('fields:{name:\\"idc\\" type:VARCHAR charset:45 flags:20483} rows:{lengths:1 values:\\"B\\"}'.*`, + `/insert into _vt.copy_state \(lastpk, vrepl_id, table_name\) values \('fields:{name:\\"idc\\" type:VARCHAR charset:33 flags:20483} rows:{lengths:1 values:\\"B\\"}'.*`, )) upd2 := expect.Then(qh.Eventually( "insert into dst(idc,val) values ('c',2)", - `/insert into _vt.copy_state \(lastpk, vrepl_id, table_name\) values \('fields:{name:\\"idc\\" type:VARCHAR charset:45 flags:20483} rows:{lengths:1 values:\\"c\\"}'.*`, + `/insert into _vt.copy_state \(lastpk, vrepl_id, table_name\) values \('fields:{name:\\"idc\\" type:VARCHAR charset:33 flags:20483} rows:{lengths:1 values:\\"c\\"}'.*`, )) upd1.Then(upd2.Eventually()) return upd2 diff --git a/go/vt/vttablet/tabletserver/repltracker/reader.go b/go/vt/vttablet/tabletserver/repltracker/reader.go index 694778d1119..b50e5e4b2c7 100644 --- a/go/vt/vttablet/tabletserver/repltracker/reader.go +++ b/go/vt/vttablet/tabletserver/repltracker/reader.go @@ -23,13 +23,12 @@ import ( "time" "vitess.io/vitess/go/constants/sidecar" - "vitess.io/vitess/go/vt/vterrors" - "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/timer" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/logutil" "vitess.io/vitess/go/vt/sqlparser" + "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" "vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv" diff --git a/go/vt/vttablet/tabletserver/schema/historian.go b/go/vt/vttablet/tabletserver/schema/historian.go index b65ab514585..ca57f6d43e0 100644 --- a/go/vt/vttablet/tabletserver/schema/historian.go +++ b/go/vt/vttablet/tabletserver/schema/historian.go @@ -26,11 +26,11 @@ import ( "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/log" - binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" + "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" "vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv" - "vitess.io/vitess/go/vt/sqlparser" + binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" ) const getInitialSchemaVersions = "select id, pos, ddl, time_updated, schemax from %s.schema_version where time_updated > %d order by id asc" diff --git a/go/vt/vttablet/tabletserver/schema/tracker.go b/go/vt/vttablet/tabletserver/schema/tracker.go index bce5e4b33d6..8db202efa13 100644 --- a/go/vt/vttablet/tabletserver/schema/tracker.go +++ b/go/vt/vttablet/tabletserver/schema/tracker.go @@ -25,18 +25,18 @@ import ( "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/mysql/replication" + "vitess.io/vitess/go/sqltypes" + "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/schema" "vitess.io/vitess/go/vt/sqlparser" + "vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv" + "vitess.io/vitess/go/vt/vttablet/tabletserver/throttle/throttlerapp" - "vitess.io/vitess/go/sqltypes" - "vitess.io/vitess/go/vt/log" binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" - "vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv" - "vitess.io/vitess/go/vt/vttablet/tabletserver/throttle/throttlerapp" ) -// VStreamer defines the functions of VStreamer +// VStreamer defines the functions of VStreamer // that the replicationWatcher needs. type VStreamer interface { Stream(ctx context.Context, startPos string, tablePKs []*binlogdatapb.TableLastPK, filter *binlogdatapb.Filter, throttlerApp throttlerapp.Name, send func([]*binlogdatapb.VEvent) error) error diff --git a/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go b/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go index 0b479bd588c..6c54a27996e 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/helper_event_test.go @@ -45,6 +45,7 @@ import ( "github.com/stretchr/testify/require" "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/mysql/collations/colldata" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/proto/binlogdata" "vitess.io/vitess/go/vt/proto/query" @@ -60,10 +61,6 @@ const ( lengthSet = 56 ) -func getDefaultCollationID() int64 { - return 45 // utf8mb4_general_ci -} - var ( // noEvents is used to indicate that a query is expected to generate no events. noEvents = []TestRowEvent{} @@ -72,10 +69,10 @@ var ( // TestColumn has all the attributes of a column required for the test cases. type TestColumn struct { name, dataType, colType string - len, collationID int64 + collationID collations.ID + len int64 dataTypeLowered string skip bool - collationName string } // TestFieldEvent has all the attributes of a table required for creating a field event. @@ -187,6 +184,15 @@ func (ts *TestSpec) Init() error { if ts.options == nil { ts.options = &TestSpecOptions{} } + // Add the unicode character set to each table definition. + // The collation used will then be the default for that character set + // in the given MySQL version used in the test: + // - 5.7: utf8mb4_general_ci + // - 8.0: utf8mb4_0900_ai_ci + tableOptions := "ENGINE=InnoDB CHARSET=utf8mb4" + for i := range ts.ddls { + ts.ddls[i] = fmt.Sprintf("%s %s", ts.ddls[i], tableOptions) + } ts.schema, err = schemadiff.NewSchemaFromQueries(schemadiff.NewTestEnv(), ts.ddls) if err != nil { return err @@ -372,7 +378,15 @@ func (ts *TestSpec) getFieldEvent(table *schemadiff.CreateTableEntity) *TestFiel sqlType := col.Type.SQLType() tc.dataType = sqlType.String() tc.dataTypeLowered = strings.ToLower(tc.dataType) - tc.collationName = col.Type.Options.Collate + collationName := col.Type.Options.Collate + if collationName == "" { + // Use the default, which is derived from the mysqld server default set + // in the testenv. + tc.collationID = testenv.DefaultCollationID + } else { + tc.collationID = testenv.CollationEnv.LookupByName(collationName) + } + collation := colldata.Lookup(tc.collationID) switch tc.dataTypeLowered { case "int32": tc.len = lengthInt @@ -385,29 +399,25 @@ func (ts *TestSpec) getFieldEvent(table *schemadiff.CreateTableEntity) *TestFiel tc.len = int64(l) tc.collationID = collations.CollationBinaryID default: - tc.len = 4 * int64(l) - tc.collationID = getDefaultCollationID() - if tc.dataTypeLowered == "char" && strings.Contains(tc.collationName, "bin") { + tc.len = int64(collation.Charset().MaxWidth()) * int64(l) + if tc.dataTypeLowered == "char" && collation.IsBinary() { tc.dataType = "BINARY" } } tc.colType = fmt.Sprintf("%s(%d)", tc.dataTypeLowered, l) case "blob": tc.len = lengthBlob - tc.collationID = collations.CollationBinaryID tc.colType = "blob" + tc.collationID = collations.CollationBinaryID case "text": tc.len = lengthText - tc.collationID = getDefaultCollationID() tc.colType = "text" case "set": tc.len = lengthSet - tc.collationID = getDefaultCollationID() tc.colType = fmt.Sprintf("%s(%s)", tc.dataTypeLowered, strings.Join(col.Type.EnumValues, ",")) ts.metadata[getMetadataKey(table.Name(), tc.name)] = col.Type.EnumValues case "enum": tc.len = int64(len(col.Type.EnumValues) + 1) - tc.collationID = getDefaultCollationID() tc.colType = fmt.Sprintf("%s(%s)", tc.dataTypeLowered, strings.Join(col.Type.EnumValues, ",")) ts.metadata[getMetadataKey(table.Name(), tc.name)] = col.Type.EnumValues default: diff --git a/go/vt/vttablet/tabletserver/vstreamer/rowstreamer.go b/go/vt/vttablet/tabletserver/vstreamer/rowstreamer.go index c1685c61d13..44f25067dfe 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/rowstreamer.go +++ b/go/vt/vttablet/tabletserver/vstreamer/rowstreamer.go @@ -168,7 +168,7 @@ func (rs *rowStreamer) buildPlan() error { Name: st.Name, } - ti.Fields, err = getFields(rs.ctx, rs.cp, st.Name, rs.cp.DBName(), st.Fields) + ti.Fields, err = getFields(rs.ctx, rs.cp, rs.vse.se, st.Name, rs.cp.DBName(), st.Fields) if err != nil { return err } diff --git a/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go b/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go index c09f73c0354..125fa75416f 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go +++ b/go/vt/vttablet/tabletserver/vstreamer/testenv/testenv.go @@ -25,8 +25,10 @@ import ( "strings" "vitess.io/vitess/go/json2" + "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/dbconfigs" + "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/mysqlctl" "vitess.io/vitess/go/vt/srvtopo" "vitess.io/vitess/go/vt/topo" @@ -43,6 +45,32 @@ import ( const DBName = "vttest" +var ( + // These are exported to coordinate on version specific + // behavior between the testenv and its users. + CollationEnv *collations.Environment + DefaultCollationID collations.ID + MySQLVersion string +) + +func init() { + vs, err := mysqlctl.GetVersionString() + if err != nil { + panic("could not get MySQL version: " + err.Error()) + } + _, mv, err := mysqlctl.ParseVersionString(vs) + if err != nil { + panic("could not parse MySQL version: " + err.Error()) + } + MySQLVersion = fmt.Sprintf("%d.%d.%d", mv.Major, mv.Minor, mv.Patch) + log.Infof("MySQL version: %s", MySQLVersion) + CollationEnv = collations.NewEnvironment(MySQLVersion) + // utf8mb4_general_ci is the default for MySQL 5.7 and + // utf8mb4_0900_ai_ci is the default for MySQL 8.0. + DefaultCollationID = CollationEnv.DefaultConnectionCharset() + log.Infof("Default collation ID: %d", DefaultCollationID) +} + // Env contains all the env vars for a test against a mysql instance. type Env struct { cluster *vttest.LocalCluster @@ -97,7 +125,7 @@ func Init(ctx context.Context) (*Env, error) { }, }, OnlyMySQL: true, - Charset: "utf8mb4_general_ci", + Charset: CollationEnv.LookupName(DefaultCollationID), ExtraMyCnf: strings.Split(os.Getenv("EXTRA_MY_CNF"), ":"), } te.cluster = &vttest.LocalCluster{ @@ -110,7 +138,14 @@ func Init(ctx context.Context) (*Env, error) { te.Dbcfgs = dbconfigs.NewTestDBConfigs(te.cluster.MySQLConnParams(), te.cluster.MySQLAppDebugConnParams(), te.cluster.DbName()) conf := tabletenv.NewDefaultConfig() conf.DB = te.Dbcfgs - te.TabletEnv = tabletenv.NewEnv(vtenv.NewTestEnv(), conf, "VStreamerTest") + vtenvCfg := vtenv.Options{ + MySQLServerVersion: MySQLVersion, + } + vtenv, err := vtenv.New(vtenvCfg) + if err != nil { + return nil, fmt.Errorf("could not initialize new vtenv: %v", err) + } + te.TabletEnv = tabletenv.NewEnv(vtenv, conf, "VStreamerTest") te.Mysqld = mysqlctl.NewMysqld(te.Dbcfgs) pos, _ := te.Mysqld.PrimaryPosition() if strings.HasPrefix(strings.ToLower(pos.GTIDSet.Flavor()), string(mysqlctl.FlavorMariaDB)) { @@ -123,6 +158,9 @@ func Init(ctx context.Context) (*Env, error) { if err != nil { return nil, fmt.Errorf("could not get server version: %w", err) } + if !strings.Contains(dbVersionStr, MySQLVersion) { + return nil, fmt.Errorf("MySQL version mismatch between mysqlctl %s and mysqld %s", MySQLVersion, dbVersionStr) + } _, version, err := mysqlctl.ParseVersionString(dbVersionStr) if err != nil { return nil, fmt.Errorf("could not parse server version %q: %w", dbVersionStr, err) diff --git a/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go b/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go index 9c63f8a499c..da0d79a1bca 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go +++ b/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go @@ -733,7 +733,6 @@ func (vs *vstreamer) buildTablePlan(id uint64, tm *mysql.TableMap) (*binlogdatap if err != nil { return nil, err } - table := &Table{ Name: tm.Name, Fields: cols, @@ -763,12 +762,30 @@ func (vs *vstreamer) buildTablePlan(id uint64, tm *mysql.TableMap) (*binlogdatap func (vs *vstreamer) buildTableColumns(tm *mysql.TableMap) ([]*querypb.Field, error) { var fields []*querypb.Field + var txtFieldIdx int for i, typ := range tm.Types { t, err := sqltypes.MySQLToType(typ, 0) if err != nil { return nil, fmt.Errorf("unsupported type: %d, position: %d", typ, i) } - coll := collations.CollationForType(t, vs.se.Environment().CollationEnv().DefaultConnectionCharset()) + // Use the the collation inherited or the one specified explicitly for the + // column if one was provided in the event's optional metadata (MySQL only + // provides this for text based columns). + var coll collations.ID + switch { + case sqltypes.IsText(t) && len(tm.ColumnCollationIDs) > txtFieldIdx: + coll = tm.ColumnCollationIDs[txtFieldIdx] + txtFieldIdx++ + case t == sqltypes.TypeJSON: + // JSON is a blob at this (storage) layer -- vs the connection/query serving + // layer which CollationForType seems primarily concerned about and JSON at + // the response layer should be using utf-8 as that's the standard -- so we + // should NOT use utf8mb4 as the collation in MySQL for a JSON column is + // NULL, meaning there is not one (same as for int) and we should use binary. + coll = collations.CollationBinaryID + default: // Use the server defined default for the column's type + coll = collations.CollationForType(t, vs.se.Environment().CollationEnv().DefaultConnectionCharset()) + } fields = append(fields, &querypb.Field{ Name: fmt.Sprintf("@%d", i+1), Type: t, @@ -793,7 +810,7 @@ func (vs *vstreamer) buildTableColumns(tm *mysql.TableMap) ([]*querypb.Field, er return fields, nil } - // check if the schema returned by schema.Engine matches with row. + // Check if the schema returned by schema.Engine matches with row. for i := range tm.Types { if !sqltypes.AreTypesEquivalent(fields[i].Type, st.Fields[i].Type) { return fields, nil @@ -801,21 +818,31 @@ func (vs *vstreamer) buildTableColumns(tm *mysql.TableMap) ([]*querypb.Field, er } // Columns should be truncated to match those in tm. - fieldsCopy, err := getFields(vs.ctx, vs.cp, tm.Name, tm.Database, st.Fields[:len(tm.Types)]) + // This uses the historian which queries the columns in the table and uses the + // generated fields metadata. This means that the fields for text types are + // initially using collations for the column types based on the *connection + // collation* and not the actual *column collation*. + // But because we now get the correct collation for the actual column from + // mysqld in getExtColsInfo we know this is the correct one for the vstream + // target and we use that rather than any that were in the binlog events, + // which were for the source and which can be using a different collation + // than the target. + fieldsCopy, err := getFields(vs.ctx, vs.cp, vs.se, tm.Name, tm.Database, st.Fields[:len(tm.Types)]) if err != nil { return nil, err } + return fieldsCopy, nil } -func getExtColInfos(ctx context.Context, cp dbconfigs.Connector, table, database string) (map[string]*extColInfo, error) { +func getExtColInfos(ctx context.Context, cp dbconfigs.Connector, se *schema.Engine, table, database string) (map[string]*extColInfo, error) { extColInfos := make(map[string]*extColInfo) conn, err := cp.Connect(ctx) if err != nil { return nil, err } defer conn.Close() - queryTemplate := "select column_name, column_type from information_schema.columns where table_schema=%s and table_name=%s;" + queryTemplate := "select column_name, column_type, collation_name from information_schema.columns where table_schema=%s and table_name=%s;" query := fmt.Sprintf(queryTemplate, encodeString(database), encodeString(table)) qr, err := conn.ExecuteFetch(query, 10000, false) if err != nil { @@ -825,34 +852,43 @@ func getExtColInfos(ctx context.Context, cp dbconfigs.Connector, table, database extColInfo := &extColInfo{ columnType: row[1].ToString(), } + collationName := row[2].ToString() + var coll collations.ID + if row[2].IsNull() || collationName == "" { + coll = collations.CollationBinaryID + } else { + coll = se.Environment().CollationEnv().LookupByName(collationName) + } + extColInfo.collationID = coll extColInfos[row[0].ToString()] = extColInfo } return extColInfos, nil } -func getFields(ctx context.Context, cp dbconfigs.Connector, table, database string, fields []*querypb.Field) ([]*querypb.Field, error) { +func getFields(ctx context.Context, cp dbconfigs.Connector, se *schema.Engine, table, database string, fields []*querypb.Field) ([]*querypb.Field, error) { // Make a deep copy of the schema.Engine fields as they are pointers and // will be modified by adding ColumnType below fieldsCopy := make([]*querypb.Field, len(fields)) for i, field := range fields { fieldsCopy[i] = field.CloneVT() } - extColInfos, err := getExtColInfos(ctx, cp, table, database) + extColInfos, err := getExtColInfos(ctx, cp, se, table, database) if err != nil { return nil, err } for _, field := range fieldsCopy { if colInfo, ok := extColInfos[field.Name]; ok { field.ColumnType = colInfo.columnType + field.Charset = uint32(colInfo.collationID) } } return fieldsCopy, nil } -// additional column attributes from information_schema.columns. Currently only column_type is used, but -// we expect to add more in the future +// Additional column attributes to get from information_schema.columns. type extColInfo struct { - columnType string + columnType string + collationID collations.ID } func encodeString(in string) string { diff --git a/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go b/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go index 4d1983cd4d3..f64c6699217 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/vstreamer_test.go @@ -27,20 +27,18 @@ import ( "time" "github.com/prometheus/common/version" - - "vitess.io/vitess/go/mysql/replication" - "vitess.io/vitess/go/vt/vttablet/tabletserver/throttle/throttlerapp" - "vitess.io/vitess/go/vt/vttablet/tabletserver/vstreamer/testenv" - + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" + "vitess.io/vitess/go/mysql" + "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/sqlparser" + "vitess.io/vitess/go/vt/vttablet/tabletserver/throttle/throttlerapp" + "vitess.io/vitess/go/vt/vttablet/tabletserver/vstreamer/testenv" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - - "vitess.io/vitess/go/mysql" binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" ) @@ -78,8 +76,10 @@ func (tfe *TestFieldEvent) String() string { return s } -// TestPlayerNoBlob sets up a new environment with mysql running with binlog_row_image as noblob. It confirms that -// the VEvents created are correct: that they don't contain the missing columns and that the DataColumns bitmap is sent +// TestPlayerNoBlob sets up a new environment with mysql running with +// binlog_row_image as noblob. It confirms that the VEvents created are +// correct: that they don't contain the missing columns and that the +// DataColumns bitmap is sent. func TestNoBlob(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -159,7 +159,8 @@ func TestCellValuePadding(t *testing.T) { ddls: []string{ "create table t1(id int, val binary(4), primary key(val))", "create table t2(id int, val char(4), primary key(val))", - "create table t3(id int, val char(4) collate utf8mb4_bin, primary key(val))"}, + "create table t3(id int, val char(4) collate utf8mb4_bin, primary key(val))", + }, } defer ts.Close() require.NoError(t, ts.Init()) @@ -185,6 +186,34 @@ func TestCellValuePadding(t *testing.T) { ts.Run() } +// TestColumnCollationHandling confirms that we handle column collations +// properly in vstreams now that we parse any optional collation ID values +// in binlog_row_metadata AND we query mysqld for the collation when possible. +func TestColumnCollationHandling(t *testing.T) { + extraCollation := "utf8mb4_ja_0900_as_cs" // Test 2 byte collation ID handling + if strings.HasPrefix(testenv.MySQLVersion, "5.7") { // 5.7 does not support 2 byte collation IDs + extraCollation = "utf8mb4_croatian_ci" + } + ts := &TestSpec{ + t: t, + ddls: []string{ + fmt.Sprintf("create table t1(id int, txt text, val char(4) collate utf8mb4_bin, id2 int, val2 varchar(64) collate utf8mb4_general_ci, valvb varbinary(128), val3 varchar(255) collate %s, primary key(val))", extraCollation), + }, + } + defer ts.Close() + require.NoError(t, ts.Init()) + ts.tests = [][]*TestQuery{{ + {"begin", nil}, + {"insert into t1 values (1, 'aaa', 'aaa', 1, 'aaa', 'aaa', 'aaa')", nil}, + {"insert into t1 values (2, 'bb', 'bb', 1, 'bb', 'bb', 'bb')", nil}, + {"update t1 set id = 11 where val = 'aaa'", []TestRowEvent{ + {spec: &TestRowEventSpec{table: "t1", changes: []TestRowChange{{before: []string{"1", "aaa", "aaa", "1", "aaa", "aaa", "aaa"}, after: []string{"11", "aaa", "aaa", "1", "aaa", "aaa", "aaa"}}}}}, + }}, + {"commit", nil}, + }} + ts.Run() +} + func TestSetStatement(t *testing.T) { if !checkIfOptionIsSupported(t, "log_builtin_as_identified_by_password") { // the combination of setting this option and support for "set password" only works on a few flavors @@ -510,9 +539,9 @@ func TestVStreamCopyWithDifferentFilters(t *testing.T) { t.Skip() } execStatements(t, []string{ - "create table t1(id1 int, id2 int, id3 int, primary key(id1))", - "create table t2a(id1 int, id2 int, primary key(id1))", - "create table t2b(id1 varchar(20), id2 int, primary key(id1))", + "create table t1(id1 int, id2 int, id3 int, primary key(id1)) ENGINE=InnoDB CHARSET=utf8mb4", + "create table t2a(id1 int, id2 int, primary key(id1)) ENGINE=InnoDB CHARSET=utf8mb4", + "create table t2b(id1 varchar(20), id2 int, primary key(id1)) ENGINE=InnoDB CHARSET=utf8mb4", }) defer execStatements(t, []string{ "drop table t1", @@ -557,10 +586,10 @@ func TestVStreamCopyWithDifferentFilters(t *testing.T) { "type:LASTPK last_p_k_event:{table_last_p_k:{table_name:\"t2a\"} completed:true}", "type:COMMIT", "type:BEGIN", - "type:FIELD field_event:{table_name:\"t2b\" fields:{name:\"id1\" type:VARCHAR table:\"t2b\" org_table:\"t2b\" database:\"vttest\" org_name:\"id1\" column_length:80 charset:45 column_type:\"varchar(20)\"} fields:{name:\"id2\" type:INT32 table:\"t2b\" org_table:\"t2b\" database:\"vttest\" org_name:\"id2\" column_length:11 charset:63 column_type:\"int(11)\"}}", + fmt.Sprintf("type:FIELD field_event:{table_name:\"t2b\" fields:{name:\"id1\" type:VARCHAR table:\"t2b\" org_table:\"t2b\" database:\"vttest\" org_name:\"id1\" column_length:80 charset:%d column_type:\"varchar(20)\"} fields:{name:\"id2\" type:INT32 table:\"t2b\" org_table:\"t2b\" database:\"vttest\" org_name:\"id2\" column_length:11 charset:63 column_type:\"int(11)\"}}", testenv.DefaultCollationID), "type:ROW row_event:{table_name:\"t2b\" row_changes:{after:{lengths:1 lengths:1 values:\"a5\"}}}", "type:ROW row_event:{table_name:\"t2b\" row_changes:{after:{lengths:1 lengths:1 values:\"b6\"}}}", - "type:LASTPK last_p_k_event:{table_last_p_k:{table_name:\"t2b\" lastpk:{fields:{name:\"id1\" type:VARCHAR charset:45 flags:20483} rows:{lengths:1 values:\"b\"}}}}", + fmt.Sprintf("type:LASTPK last_p_k_event:{table_last_p_k:{table_name:\"t2b\" lastpk:{fields:{name:\"id1\" type:VARCHAR charset:%d flags:20483} rows:{lengths:1 values:\"b\"}}}}", testenv.DefaultCollationID), "type:COMMIT", "type:BEGIN", "type:LASTPK last_p_k_event:{table_last_p_k:{table_name:\"t2b\"} completed:true}", @@ -1290,6 +1319,7 @@ func TestDDLAddColumn(t *testing.T) { "commit", }) engine.se.Reload(context.Background()) + env.SchemaEngine.Reload(context.Background()) ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -1499,10 +1529,20 @@ func TestBuffering(t *testing.T) { runCases(t, nil, testcases, "", nil) } +// TestBestEffortNameInFieldEvent tests that we make a valid best effort +// attempt to deduce the type and collation in the event of table renames. +// In both cases the varbinary becomes a varchar. We get the correct +// collation information, however, in the binlog_row_metadata in 8.0 but +// not in 5.7. So in 5.7 our best effort uses varchar with its default +// collation for text fields. func TestBestEffortNameInFieldEvent(t *testing.T) { if testing.Short() { t.Skip() } + bestEffortCollation := collations.ID(collations.CollationBinaryID) + if strings.HasPrefix(testenv.MySQLVersion, "5.7") { + bestEffortCollation = testenv.DefaultCollationID + } filter := &binlogdatapb.Filter{ FieldEventMode: binlogdatapb.Filter_BEST_EFFORT, Rules: []*binlogdatapb.Rule{{ @@ -1511,7 +1551,7 @@ func TestBestEffortNameInFieldEvent(t *testing.T) { } // Modeled after vttablet endtoend compatibility tests. execStatements(t, []string{ - "create table vitess_test(id int, val varbinary(128), primary key(id))", + "create table vitess_test(id int, val varbinary(128), primary key(id)) ENGINE=InnoDB CHARSET=utf8mb4", }) position := primaryPosition(t) execStatements(t, []string{ @@ -1531,7 +1571,7 @@ func TestBestEffortNameInFieldEvent(t *testing.T) { // information returned by binlog for val column == varchar (rather than varbinary). output: [][]string{{ `begin`, - `type:FIELD field_event:{table_name:"vitess_test" fields:{name:"@1" type:INT32 charset:63} fields:{name:"@2" type:VARCHAR charset:255}}`, + fmt.Sprintf(`type:FIELD field_event:{table_name:"vitess_test" fields:{name:"@1" type:INT32 charset:63} fields:{name:"@2" type:VARCHAR charset:%d}}`, bestEffortCollation), `type:ROW row_event:{table_name:"vitess_test" row_changes:{after:{lengths:1 lengths:3 values:"1abc"}}}`, `gtid`, `commit`, @@ -1615,12 +1655,12 @@ func TestTypes(t *testing.T) { // Modeled after vttablet endtoend compatibility tests. execStatements(t, []string{ - "create table vitess_ints(tiny tinyint, tinyu tinyint unsigned, small smallint, smallu smallint unsigned, medium mediumint, mediumu mediumint unsigned, normal int, normalu int unsigned, big bigint, bigu bigint unsigned, y year, primary key(tiny))", - "create table vitess_fracts(id int, deci decimal(5,2), num numeric(5,2), f float, d double, primary key(id))", - "create table vitess_strings(vb varbinary(16), c char(16), vc varchar(16), b binary(4), tb tinyblob, bl blob, ttx tinytext, tx text, en enum('a','b'), s set('a','b'), primary key(vb))", - "create table vitess_misc(id int, b bit(8), d date, dt datetime, t time, g geometry, primary key(id))", - "create table vitess_null(id int, val varbinary(128), primary key(id))", - "create table vitess_decimal(id int, dec1 decimal(12,4), dec2 decimal(13,4), primary key(id))", + "create table vitess_ints(tiny tinyint, tinyu tinyint unsigned, small smallint, smallu smallint unsigned, medium mediumint, mediumu mediumint unsigned, normal int, normalu int unsigned, big bigint, bigu bigint unsigned, y year, primary key(tiny)) ENGINE=InnoDB CHARSET=utf8mb4", + "create table vitess_fracts(id int, deci decimal(5,2), num numeric(5,2), f float, d double, primary key(id)) ENGINE=InnoDB CHARSET=utf8mb4", + "create table vitess_strings(vb varbinary(16), c char(16), vc varchar(16), b binary(4), tb tinyblob, bl blob, ttx tinytext, tx text, en enum('a','b'), s set('a','b'), primary key(vb)) ENGINE=InnoDB CHARSET=utf8mb4", + "create table vitess_misc(id int, b bit(8), d date, dt datetime, t time, g geometry, primary key(id)) ENGINE=InnoDB CHARSET=utf8mb4", + "create table vitess_null(id int, val varbinary(128), primary key(id)) ENGINE=InnoDB CHARSET=utf8mb4", + "create table vitess_decimal(id int, dec1 decimal(12,4), dec2 decimal(13,4), primary key(id)) ENGINE=InnoDB CHARSET=utf8mb4", }) defer execStatements(t, []string{ "drop table vitess_ints", @@ -1673,7 +1713,7 @@ func TestTypes(t *testing.T) { }, output: [][]string{{ `begin`, - `type:FIELD field_event:{table_name:"vitess_strings" fields:{name:"vb" type:VARBINARY table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"vb" column_length:16 charset:63 column_type:"varbinary(16)"} fields:{name:"c" type:CHAR table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"c" column_length:64 charset:45 column_type:"char(16)"} fields:{name:"vc" type:VARCHAR table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"vc" column_length:64 charset:45 column_type:"varchar(16)"} fields:{name:"b" type:BINARY table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"b" column_length:4 charset:63 column_type:"binary(4)"} fields:{name:"tb" type:BLOB table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"tb" column_length:255 charset:63 column_type:"tinyblob"} fields:{name:"bl" type:BLOB table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"bl" column_length:65535 charset:63 column_type:"blob"} fields:{name:"ttx" type:TEXT table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"ttx" column_length:1020 charset:45 column_type:"tinytext"} fields:{name:"tx" type:TEXT table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"tx" column_length:262140 charset:45 column_type:"text"} fields:{name:"en" type:ENUM table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"en" column_length:4 charset:45 column_type:"enum('a','b')"} fields:{name:"s" type:SET table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"s" column_length:12 charset:45 column_type:"set('a','b')"}}`, + fmt.Sprintf(`type:FIELD field_event:{table_name:"vitess_strings" fields:{name:"vb" type:VARBINARY table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"vb" column_length:16 charset:63 column_type:"varbinary(16)"} fields:{name:"c" type:CHAR table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"c" column_length:64 charset:%d column_type:"char(16)"} fields:{name:"vc" type:VARCHAR table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"vc" column_length:64 charset:%d column_type:"varchar(16)"} fields:{name:"b" type:BINARY table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"b" column_length:4 charset:63 column_type:"binary(4)"} fields:{name:"tb" type:BLOB table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"tb" column_length:255 charset:63 column_type:"tinyblob"} fields:{name:"bl" type:BLOB table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"bl" column_length:65535 charset:63 column_type:"blob"} fields:{name:"ttx" type:TEXT table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"ttx" column_length:1020 charset:%d column_type:"tinytext"} fields:{name:"tx" type:TEXT table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"tx" column_length:262140 charset:%d column_type:"text"} fields:{name:"en" type:ENUM table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"en" column_length:4 charset:%d column_type:"enum('a','b')"} fields:{name:"s" type:SET table:"vitess_strings" org_table:"vitess_strings" database:"vttest" org_name:"s" column_length:12 charset:%d column_type:"set('a','b')"}}`, testenv.DefaultCollationID, testenv.DefaultCollationID, testenv.DefaultCollationID, testenv.DefaultCollationID, testenv.DefaultCollationID, testenv.DefaultCollationID), `type:ROW row_event:{table_name:"vitess_strings" row_changes:{after:{lengths:1 lengths:1 lengths:1 lengths:4 lengths:1 lengths:1 lengths:1 lengths:1 lengths:1 lengths:1 ` + `values:"abcd\x00\x00\x00efgh13"}}}`, `gtid`, @@ -2100,7 +2140,6 @@ func TestGeneratedInvisiblePrimaryKey(t *testing.T) { } func runCases(t *testing.T, filter *binlogdatapb.Filter, testcases []testcase, position string, tablePK []*binlogdatapb.TableLastPK) { - ctx, cancel := context.WithCancel(context.Background()) defer cancel() wg, ch := startStream(ctx, t, filter, position, tablePK) From 24b0579d22482cef549439fb7ca56ab9c49fadb2 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Mon, 26 Feb 2024 13:24:14 -0500 Subject: [PATCH 58/79] SHOW VITESS_REPLICATION_STATUS: Only use replication tracker when it's enabled (#15348) Signed-off-by: Matt Lord --- go/test/endtoend/tabletgateway/vtgate_test.go | 46 +++++++++++++++++-- go/vt/vtgate/executor.go | 32 ++++++++++--- go/vt/vtgate/executor_test.go | 11 +++-- .../tabletserver/repltracker/poller.go | 4 +- .../tabletserver/repltracker/repltracker.go | 5 +- 5 files changed, 78 insertions(+), 20 deletions(-) diff --git a/go/test/endtoend/tabletgateway/vtgate_test.go b/go/test/endtoend/tabletgateway/vtgate_test.go index be227927981..c48aa6c2131 100644 --- a/go/test/endtoend/tabletgateway/vtgate_test.go +++ b/go/test/endtoend/tabletgateway/vtgate_test.go @@ -28,15 +28,14 @@ import ( "testing" "time" - "vitess.io/vitess/go/test/endtoend/utils" - "vitess.io/vitess/go/vt/proto/topodata" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "vitess.io/vitess/go/mysql" - "vitess.io/vitess/go/test/endtoend/cluster" + "vitess.io/vitess/go/test/endtoend/utils" + vtorcutils "vitess.io/vitess/go/test/endtoend/vtorc/utils" + "vitess.io/vitess/go/vt/proto/topodata" ) func TestVtgateHealthCheck(t *testing.T) { @@ -59,7 +58,7 @@ func TestVtgateReplicationStatusCheck(t *testing.T) { time.Sleep(2 * time.Second) verifyVtgateVariables(t, clusterInstance.VtgateProcess.VerifyURL) ctx := context.Background() - conn, err := mysql.Connect(ctx, &vtParams) + conn, err := mysql.Connect(ctx, &vtParams) // VTGate require.NoError(t, err) defer conn.Close() @@ -68,6 +67,38 @@ func TestVtgateReplicationStatusCheck(t *testing.T) { expectNumRows := 2 numRows := len(qr.Rows) assert.Equal(t, expectNumRows, numRows, fmt.Sprintf("wrong number of results from show vitess_replication_status. Expected %d, got %d", expectNumRows, numRows)) + + // Disable VTOrc(s) recoveries so that it doesn't immediately repair/restart replication. + for _, vtorcProcess := range clusterInstance.VTOrcProcesses { + vtorcutils.DisableGlobalRecoveries(t, vtorcProcess) + } + // Re-enable recoveries afterward as the cluster is re-used. + defer func() { + for _, vtorcProcess := range clusterInstance.VTOrcProcesses { + vtorcutils.EnableGlobalRecoveries(t, vtorcProcess) + } + }() + // Stop replication on the non-PRIMARY tablets. + _, err = clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ExecuteFetchAsDBA", clusterInstance.Keyspaces[0].Shards[0].Replica().Alias, "stop slave") + require.NoError(t, err) + _, err = clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ExecuteFetchAsDBA", clusterInstance.Keyspaces[0].Shards[0].Rdonly().Alias, "stop slave") + require.NoError(t, err) + // Restart replication afterward as the cluster is re-used. + defer func() { + _, err = clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ExecuteFetchAsDBA", clusterInstance.Keyspaces[0].Shards[0].Replica().Alias, "start slave") + require.NoError(t, err) + _, err = clusterInstance.VtctldClientProcess.ExecuteCommandWithOutput("ExecuteFetchAsDBA", clusterInstance.Keyspaces[0].Shards[0].Rdonly().Alias, "start slave") + require.NoError(t, err) + }() + time.Sleep(2 * time.Second) // Build up some replication lag + res, err := conn.ExecuteFetch("show vitess_replication_status", 2, false) + require.NoError(t, err) + expectNumRows = 2 + numRows = len(qr.Rows) + assert.Equal(t, expectNumRows, numRows, fmt.Sprintf("wrong number of results from show vitess_replication_status, expected %d, got %d", expectNumRows, numRows)) + rawLag := res.Named().Rows[0]["ReplicationLag"] // Let's just look at the first row + lagInt, _ := rawLag.ToInt64() // Don't check the error as the value could be "NULL" + assert.True(t, rawLag.IsNull() || lagInt > 0, "replication lag should be NULL or greater than 0 but was: %s", rawLag.ToString()) } func TestVtgateReplicationStatusCheckWithTabletTypeChange(t *testing.T) { @@ -90,6 +121,11 @@ func TestVtgateReplicationStatusCheckWithTabletTypeChange(t *testing.T) { rdOnlyTablet := clusterInstance.Keyspaces[0].Shards[0].Rdonly() err = clusterInstance.VtctlclientChangeTabletType(rdOnlyTablet, topodata.TabletType_SPARE) require.NoError(t, err) + // Change it back to RDONLY afterward as the cluster is re-used. + defer func() { + err = clusterInstance.VtctlclientChangeTabletType(rdOnlyTablet, topodata.TabletType_RDONLY) + require.NoError(t, err) + }() // Only returns rows for REPLICA and RDONLY tablets -- so should be 1 of them since we updated 1 to spare qr = utils.Exec(t, conn, "show vitess_replication_status like '%'") diff --git a/go/vt/vtgate/executor.go b/go/vt/vtgate/executor.go index 520214d65fd..9f14888c846 100644 --- a/go/vt/vtgate/executor.go +++ b/go/vt/vtgate/executor.go @@ -929,7 +929,7 @@ func (e *Executor) showVitessReplicationStatus(ctx context.Context, filter *sqlp tabletHostPort := ts.GetTabletHostPort() throttlerStatus, err := getTabletThrottlerStatus(tabletHostPort) if err != nil { - log.Warningf("Could not get throttler status from %s: %v", tabletHostPort, err) + log.Warningf("Could not get throttler status from %s: %v", topoproto.TabletAliasString(ts.Tablet.Alias), err) } replSourceHost := "" @@ -937,7 +937,7 @@ func (e *Executor) showVitessReplicationStatus(ctx context.Context, filter *sqlp replIOThreadHealth := "" replSQLThreadHealth := "" replLastError := "" - replLag := int64(-1) + replLag := "-1" // A string to support NULL as a value sql := "show slave status" results, err := e.txConn.tabletGateway.Execute(ctx, ts.Target, sql, nil, 0, 0, nil) if err != nil || results == nil { @@ -948,8 +948,25 @@ func (e *Executor) showVitessReplicationStatus(ctx context.Context, filter *sqlp replIOThreadHealth = row["Slave_IO_Running"].ToString() replSQLThreadHealth = row["Slave_SQL_Running"].ToString() replLastError = row["Last_Error"].ToString() - if ts.Stats != nil { - replLag = int64(ts.Stats.ReplicationLagSeconds) + // We cannot check the tablet's tabletenv config from here so + // we only use the tablet's stat -- which is managed by the + // ReplicationTracker -- if we can tell that it's enabled, + // meaning that it has a non-zero value. If it's actually + // enabled AND zero (rather than the zeroval), then mysqld + // should also return 0 so in this case the value is correct + // and equivalent either way. The only reason that we would + // want to use the ReplicationTracker based value, when we + // can, is because the polling method allows us to get the + // estimated lag value when replication is not running (based + // on how long we've seen that it's not been running). + if ts.Stats != nil && ts.Stats.ReplicationLagSeconds > 0 { // Use the value we get from the ReplicationTracker + replLag = fmt.Sprintf("%d", ts.Stats.ReplicationLagSeconds) + } else { // Use the value from mysqld + if row["Seconds_Behind_Master"].IsNull() { + replLag = strings.ToUpper(sqltypes.NullStr) // Uppercase to match mysqld's output in SHOW REPLICA STATUS + } else { + replLag = row["Seconds_Behind_Master"].ToString() + } } } replicationHealth := fmt.Sprintf("{\"EventStreamRunning\":\"%s\",\"EventApplierRunning\":\"%s\",\"LastError\":\"%s\"}", replIOThreadHealth, replSQLThreadHealth, replLastError) @@ -962,7 +979,7 @@ func (e *Executor) showVitessReplicationStatus(ctx context.Context, filter *sqlp ts.Tablet.Hostname, fmt.Sprintf("%s:%d", replSourceHost, replSourcePort), replicationHealth, - fmt.Sprintf("%d", replLag), + replLag, throttlerStatus, )) } @@ -1477,11 +1494,14 @@ func (e *Executor) checkThatPlanIsValid(stmt sqlparser.Statement, plan *engine.P return vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "plan includes scatter, which is disallowed using the `no_scatter` command line argument") } +// getTabletThrottlerStatus uses HTTP to get the throttler status +// on a tablet. It uses HTTP because the CheckThrottler RPC is a +// tmclient RPC and you cannot use tmclient outside of a tablet. func getTabletThrottlerStatus(tabletHostPort string) (string, error) { client := http.Client{ Timeout: 100 * time.Millisecond, } - resp, err := client.Get(fmt.Sprintf("http://%s/throttler/check?app=vtgate", tabletHostPort)) + resp, err := client.Get(fmt.Sprintf("http://%s/throttler/check-self", tabletHostPort)) if err != nil { return "", err } diff --git a/go/vt/vtgate/executor_test.go b/go/vt/vtgate/executor_test.go index 5df4c7887f6..cc4092c7a00 100644 --- a/go/vt/vtgate/executor_test.go +++ b/go/vt/vtgate/executor_test.go @@ -42,11 +42,6 @@ import ( "vitess.io/vitess/go/test/utils" "vitess.io/vitess/go/vt/callerid" "vitess.io/vitess/go/vt/discovery" - querypb "vitess.io/vitess/go/vt/proto/query" - topodatapb "vitess.io/vitess/go/vt/proto/topodata" - vschemapb "vitess.io/vitess/go/vt/proto/vschema" - vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" - vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/vtgate/buffer" @@ -55,6 +50,12 @@ import ( "vitess.io/vitess/go/vt/vtgate/vindexes" "vitess.io/vitess/go/vt/vtgate/vschemaacl" "vitess.io/vitess/go/vt/vtgate/vtgateservice" + + querypb "vitess.io/vitess/go/vt/proto/query" + topodatapb "vitess.io/vitess/go/vt/proto/topodata" + vschemapb "vitess.io/vitess/go/vt/proto/vschema" + vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" + vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) func TestExecutorResultsExceeded(t *testing.T) { diff --git a/go/vt/vttablet/tabletserver/repltracker/poller.go b/go/vt/vttablet/tabletserver/repltracker/poller.go index ace01dffb2d..6fc964bef57 100644 --- a/go/vt/vttablet/tabletserver/repltracker/poller.go +++ b/go/vt/vttablet/tabletserver/repltracker/poller.go @@ -21,10 +21,10 @@ import ( "time" "vitess.io/vitess/go/stats" - "vitess.io/vitess/go/vt/mysqlctl" - vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/vterrors" + + vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) var replicationLagSeconds = stats.NewGauge("replicationLagSec", "replication lag in seconds") diff --git a/go/vt/vttablet/tabletserver/repltracker/repltracker.go b/go/vt/vttablet/tabletserver/repltracker/repltracker.go index 6f504b2a445..c98005851d1 100644 --- a/go/vt/vttablet/tabletserver/repltracker/repltracker.go +++ b/go/vt/vttablet/tabletserver/repltracker/repltracker.go @@ -23,10 +23,11 @@ import ( "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/mysqlctl" - querypb "vitess.io/vitess/go/vt/proto/query" - topodatapb "vitess.io/vitess/go/vt/proto/topodata" "vitess.io/vitess/go/vt/vttablet/tabletserver/heartbeat" "vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv" + + querypb "vitess.io/vitess/go/vt/proto/query" + topodatapb "vitess.io/vitess/go/vt/proto/topodata" ) var ( From 491e416cbf8c9a149cf9df9633cf30fe6c2a1900 Mon Sep 17 00:00:00 2001 From: Rohit Nayak <57520317+rohit-nayak-ps@users.noreply.github.com> Date: Mon, 26 Feb 2024 19:53:44 +0100 Subject: [PATCH 59/79] VtctldClient Reshard: add e2e tests to confirm CLI options and fix discovered issues. (#15353) Signed-off-by: Rohit Nayak --- .../command/vreplication/reshard/create.go | 12 +- .../vreplication_vtctldclient_cli_test.go | 191 +++++++++++++++--- .../endtoend/vreplication/wrappers_test.go | 31 ++- go/vt/vtctl/workflow/server.go | 11 +- 4 files changed, 201 insertions(+), 44 deletions(-) diff --git a/go/cmd/vtctldclient/command/vreplication/reshard/create.go b/go/cmd/vtctldclient/command/vreplication/reshard/create.go index b8506ae61d0..05700dbb9fe 100644 --- a/go/cmd/vtctldclient/command/vreplication/reshard/create.go +++ b/go/cmd/vtctldclient/command/vreplication/reshard/create.go @@ -60,9 +60,8 @@ func commandReshardCreate(cmd *cobra.Command, args []string) error { cli.FinishedParsing(cmd) req := &vtctldatapb.ReshardCreateRequest{ - Workflow: common.BaseOptions.Workflow, - Keyspace: common.BaseOptions.TargetKeyspace, - + Workflow: common.BaseOptions.Workflow, + Keyspace: common.BaseOptions.TargetKeyspace, TabletTypes: common.CreateOptions.TabletTypes, TabletSelectionPreference: tsp, Cells: common.CreateOptions.Cells, @@ -70,10 +69,9 @@ func commandReshardCreate(cmd *cobra.Command, args []string) error { DeferSecondaryKeys: common.CreateOptions.DeferSecondaryKeys, AutoStart: common.CreateOptions.AutoStart, StopAfterCopy: common.CreateOptions.StopAfterCopy, - - SourceShards: reshardCreateOptions.sourceShards, - TargetShards: reshardCreateOptions.targetShards, - SkipSchemaCopy: reshardCreateOptions.skipSchemaCopy, + SourceShards: reshardCreateOptions.sourceShards, + TargetShards: reshardCreateOptions.targetShards, + SkipSchemaCopy: reshardCreateOptions.skipSchemaCopy, } resp, err := common.GetClient().ReshardCreate(common.GetCommandCtx(), req) if err != nil { diff --git a/go/test/endtoend/vreplication/vreplication_vtctldclient_cli_test.go b/go/test/endtoend/vreplication/vreplication_vtctldclient_cli_test.go index bfe0c81ebce..30d9e2b2eb5 100644 --- a/go/test/endtoend/vreplication/vreplication_vtctldclient_cli_test.go +++ b/go/test/endtoend/vreplication/vreplication_vtctldclient_cli_test.go @@ -27,7 +27,6 @@ import ( "google.golang.org/protobuf/encoding/protojson" "vitess.io/vitess/go/test/endtoend/cluster" - binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata" topodatapb "vitess.io/vitess/go/vt/proto/topodata" @@ -54,20 +53,33 @@ func TestVtctldclientCLI(t *testing.T) { require.NotNil(t, zone2) defer vc.TearDown() - sourceKeyspace := "product" - targetKeyspace := "customer" + sourceKeyspaceName := "product" + targetKeyspaceName := "customer" var mt iMoveTables workflowName := "wf1" targetTabs := setupMinimalCustomerKeyspace(t) t.Run("MoveTablesCreateFlags1", func(t *testing.T) { - testMoveTablesFlags1(t, &mt, sourceKeyspace, targetKeyspace, workflowName, targetTabs) + testMoveTablesFlags1(t, &mt, sourceKeyspaceName, targetKeyspaceName, workflowName, targetTabs) }) t.Run("MoveTablesCreateFlags2", func(t *testing.T) { - testMoveTablesFlags2(t, &mt, sourceKeyspace, targetKeyspace, workflowName, targetTabs) + testMoveTablesFlags2(t, &mt, sourceKeyspaceName, targetKeyspaceName, workflowName, targetTabs) + }) + t.Run("MoveTablesCompleteFlags3", func(t *testing.T) { + testMoveTablesFlags3(t, sourceKeyspaceName, targetKeyspaceName, targetTabs) }) - t.Run("MoveTablesCompleteFlags", func(t *testing.T) { - testMoveTablesFlags3(t, sourceKeyspace, targetKeyspace, targetTabs) + t.Run("Reshard", func(t *testing.T) { + cell := vc.Cells["zone1"] + targetKeyspace := cell.Keyspaces[targetKeyspaceName] + sourceShard := "-80" + newShards := "-40,40-80" + require.NoError(t, vc.AddShards(t, []*Cell{cell}, targetKeyspace, newShards, 1, 0, 400, nil)) + reshardWorkflowName := "reshard" + tablets := map[string]*cluster.VttabletProcess{ + "-40": targetKeyspace.Shards["-40"].Tablets["zone1-400"].Vttablet, + "40-80": targetKeyspace.Shards["40-80"].Tablets["zone1-500"].Vttablet, + } + splitShard(t, targetKeyspaceName, reshardWorkflowName, sourceShard, newShards, tablets) }) } @@ -81,34 +93,31 @@ func testMoveTablesFlags1(t *testing.T, mt *iMoveTables, sourceKeyspace, targetK } completeFlags := []string{"--keep-routing-rules", "--keep-data"} switchFlags := []string{} + // Test one set of MoveTable flags. *mt = createMoveTables(t, sourceKeyspace, targetKeyspace, workflowName, tables, createFlags, completeFlags, switchFlags) (*mt).Show() - moveTablesOutput := (*mt).GetLastOutput() - // Test one set of MoveTable flags. + moveTablesResponse := getMoveTablesShowResponse(mt) + workflowResponse := getWorkflow(targetKeyspace, workflowName) - workflowOutput, err := vc.VtctldClient.ExecuteCommandWithOutput("Workflow", "--keyspace", "customer", "show", "--workflow", "wf1") - require.NoError(t, err) - var moveTablesResponse vtctldatapb.GetWorkflowsResponse - err = protojson.Unmarshal([]byte(moveTablesOutput), &moveTablesResponse) - require.NoError(t, err) - - var workflowResponse vtctldatapb.GetWorkflowsResponse - err = protojson.Unmarshal([]byte(workflowOutput), &workflowResponse) - require.NoError(t, err) - - moveTablesResponse.Workflows[0].MaxVReplicationTransactionLag = 0 - moveTablesResponse.Workflows[0].MaxVReplicationLag = 0 - workflowResponse.Workflows[0].MaxVReplicationTransactionLag = 0 - workflowResponse.Workflows[0].MaxVReplicationLag = 0 // also validates that MoveTables Show and Workflow Show return the same output. - require.EqualValues(t, moveTablesResponse.CloneVT(), workflowResponse.CloneVT()) + require.EqualValues(t, moveTablesResponse.CloneVT(), workflowResponse) // Validate that the flags are set correctly in the database. - validateWorkflow1(t, workflowResponse.Workflows) + validateMoveTablesWorkflow(t, workflowResponse.Workflows) // Since we used --no-routing-rules, there should be no routing rules. confirmNoRoutingRules(t) } +func getMoveTablesShowResponse(mt *iMoveTables) *vtctldatapb.GetWorkflowsResponse { + moveTablesOutput := (*mt).GetLastOutput() + var moveTablesResponse vtctldatapb.GetWorkflowsResponse + err := protojson.Unmarshal([]byte(moveTablesOutput), &moveTablesResponse) + require.NoError(vc.t, err) + moveTablesResponse.Workflows[0].MaxVReplicationTransactionLag = 0 + moveTablesResponse.Workflows[0].MaxVReplicationLag = 0 + return moveTablesResponse.CloneVT() +} + // Validates some of the flags created from the previous test. func testMoveTablesFlags2(t *testing.T, mt *iMoveTables, sourceKeyspace, targetKeyspace, workflowName string, targetTabs map[string]*cluster.VttabletProcess) { ksWorkflow := fmt.Sprintf("%s.%s", targetKeyspace, workflowName) @@ -184,6 +193,135 @@ func createMoveTables(t *testing.T, sourceKeyspace, targetKeyspace, workflowName return mt } +// reshard helpers + +func splitShard(t *testing.T, keyspace, workflowName, sourceShards, targetShards string, targetTabs map[string]*cluster.VttabletProcess) { + createFlags := []string{"--auto-start=false", "--defer-secondary-keys=false", "--stop-after-copy", + "--on-ddl", "STOP", "--tablet-types", "primary,rdonly", "--tablet-types-in-preference-order=true", + "--all-cells", "--format=json", + } + rs := newReshard(vc, &reshardWorkflow{ + workflowInfo: &workflowInfo{ + vc: vc, + workflowName: workflowName, + targetKeyspace: keyspace, + }, + sourceShards: sourceShards, + targetShards: targetShards, + createFlags: createFlags, + }, workflowFlavorVtctld) + + ksWorkflow := fmt.Sprintf("%s.%s", keyspace, workflowName) + rs.Create() + validateReshardResponse(rs) + workflowResponse := getWorkflow(keyspace, workflowName) + reshardShowResponse := getReshardShowResponse(&rs) + require.EqualValues(t, reshardShowResponse, workflowResponse) + validateReshardWorkflow(t, workflowResponse.Workflows) + waitForWorkflowState(t, vc, fmt.Sprintf("%s.%s", keyspace, workflowName), binlogdatapb.VReplicationWorkflowState_Stopped.String()) + rs.Start() + waitForWorkflowState(t, vc, ksWorkflow, binlogdatapb.VReplicationWorkflowState_Stopped.String()) + for _, tab := range targetTabs { + alias := fmt.Sprintf("zone1-%d", tab.TabletUID) + query := "update _vt.vreplication set source := replace(source, 'stop_after_copy:true', 'stop_after_copy:false') where db_name = 'vt_customer' and workflow = '" + workflowName + "'" + output, err := vc.VtctlClient.ExecuteCommandWithOutput("ExecuteFetchAsDba", alias, query) + require.NoError(t, err, output) + } + rs.Start() + waitForWorkflowState(t, vc, fmt.Sprintf("%s.%s", keyspace, workflowName), binlogdatapb.VReplicationWorkflowState_Running.String()) + rs.Stop() + waitForWorkflowState(t, vc, ksWorkflow, binlogdatapb.VReplicationWorkflowState_Stopped.String()) + rs.Start() + waitForWorkflowState(t, vc, fmt.Sprintf("%s.%s", keyspace, workflowName), binlogdatapb.VReplicationWorkflowState_Running.String()) + for _, targetTab := range targetTabs { + catchup(t, targetTab, workflowName, "Reshard") + } + vdiff(t, keyspace, workflowName, "zone1", false, true, nil) + + rs.SwitchReadsAndWrites() + waitForLowLag(t, keyspace, workflowName+"_reverse") + vdiff(t, keyspace, workflowName+"_reverse", "zone1", true, false, nil) + + rs.ReverseReadsAndWrites() + waitForLowLag(t, keyspace, workflowName) + vdiff(t, keyspace, workflowName, "zone1", false, true, nil) + rs.SwitchReadsAndWrites() + rs.Complete() +} + +func getReshardShowResponse(rs *iReshard) *vtctldatapb.GetWorkflowsResponse { + (*rs).Show() + reshardOutput := (*rs).GetLastOutput() + var reshardResponse vtctldatapb.GetWorkflowsResponse + err := protojson.Unmarshal([]byte(reshardOutput), &reshardResponse) + require.NoError(vc.t, err) + reshardResponse.Workflows[0].MaxVReplicationTransactionLag = 0 + reshardResponse.Workflows[0].MaxVReplicationLag = 0 + return reshardResponse.CloneVT() +} + +func validateReshardResponse(rs iReshard) { + resp := getReshardResponse(rs) + require.NotNil(vc.t, resp) + require.NotNil(vc.t, resp.ShardStreams) + require.Equal(vc.t, len(resp.ShardStreams), 2) + keyspace := "customer" + for _, shard := range []string{"-40", "40-80"} { + streams := resp.ShardStreams[fmt.Sprintf("%s/%s", keyspace, shard)] + require.Equal(vc.t, 1, len(streams.Streams)) + require.Equal(vc.t, binlogdatapb.VReplicationWorkflowState_Stopped.String(), streams.Streams[0].Status) + } +} + +func validateReshardWorkflow(t *testing.T, workflows []*vtctldatapb.Workflow) { + require.Equal(t, 1, len(workflows)) + wf := workflows[0] + require.Equal(t, "reshard", wf.Name) + require.Equal(t, binlogdatapb.VReplicationWorkflowType_Reshard.String(), wf.WorkflowType) + require.Equal(t, "None", wf.WorkflowSubType) + require.Equal(t, "customer", wf.Target.Keyspace) + require.Equal(t, 2, len(wf.Target.Shards)) + require.Equal(t, "customer", wf.Source.Keyspace) + require.Equal(t, 1, len(wf.Source.Shards)) + require.False(t, wf.DeferSecondaryKeys) + + require.GreaterOrEqual(t, len(wf.ShardStreams), int(1)) + oneStream := maps.Values(wf.ShardStreams)[0] + require.NotNil(t, oneStream) + + stream := oneStream.Streams[0] + require.Equal(t, binlogdatapb.VReplicationWorkflowState_Stopped.String(), stream.State) + require.Equal(t, stream.TabletSelectionPreference, tabletmanagerdatapb.TabletSelectionPreference_INORDER) + require.True(t, slices.Equal([]topodatapb.TabletType{topodatapb.TabletType_PRIMARY, topodatapb.TabletType_RDONLY}, stream.TabletTypes)) + require.True(t, slices.Equal([]string{"zone1", "zone2"}, stream.Cells)) + + bls := stream.BinlogSource + require.Equal(t, binlogdatapb.OnDDLAction_STOP, bls.OnDdl) + require.True(t, bls.StopAfterCopy) + +} + +func getReshardResponse(rs iReshard) *vtctldatapb.WorkflowStatusResponse { + reshardOutput := rs.GetLastOutput() + var reshardResponse vtctldatapb.WorkflowStatusResponse + err := protojson.Unmarshal([]byte(reshardOutput), &reshardResponse) + require.NoError(vc.t, err) + return reshardResponse.CloneVT() +} + +// helper functions + +func getWorkflow(targetKeyspace, workflow string) *vtctldatapb.GetWorkflowsResponse { + workflowOutput, err := vc.VtctldClient.ExecuteCommandWithOutput("Workflow", "--keyspace", targetKeyspace, "show", "--workflow", workflow) + require.NoError(vc.t, err) + var workflowResponse vtctldatapb.GetWorkflowsResponse + err = protojson.Unmarshal([]byte(workflowOutput), &workflowResponse) + require.NoError(vc.t, err) + workflowResponse.Workflows[0].MaxVReplicationTransactionLag = 0 + workflowResponse.Workflows[0].MaxVReplicationLag = 0 + return workflowResponse.CloneVT() +} + func checkTablesExist(t *testing.T, tabletAlias string, tables []string) bool { tablesResponse, err := vc.VtctldClient.ExecuteCommandWithOutput("GetSchema", tabletAlias, "--tables", strings.Join(tables, ","), "--table-names-only") require.NoError(t, err) @@ -211,6 +349,7 @@ func getRoutingRules(t *testing.T) *vschemapb.RoutingRules { require.NoError(t, err) return &routingRulesResponse } + func confirmNoRoutingRules(t *testing.T) { routingRulesResponse := getRoutingRules(t) require.Zero(t, len(routingRulesResponse.Rules)) @@ -223,7 +362,7 @@ func confirmRoutingRulesExist(t *testing.T) { // We only want to validate non-standard attributes that are set by the CLI. The other end-to-end tests validate the rest. // We also check some of the standard attributes to make sure they are set correctly. -func validateWorkflow1(t *testing.T, workflows []*vtctldatapb.Workflow) { +func validateMoveTablesWorkflow(t *testing.T, workflows []*vtctldatapb.Workflow) { require.Equal(t, 1, len(workflows)) wf := workflows[0] require.Equal(t, "wf1", wf.Name) diff --git a/go/test/endtoend/vreplication/wrappers_test.go b/go/test/endtoend/vreplication/wrappers_test.go index 5470aeb2bd5..2d4949b60dc 100644 --- a/go/test/endtoend/vreplication/wrappers_test.go +++ b/go/test/endtoend/vreplication/wrappers_test.go @@ -74,9 +74,10 @@ type moveTablesWorkflow struct { tables string atomicCopy bool sourceShards string - createFlags []string // currently only used by vtctld + // currently only used by vtctld lastOutput string + createFlags []string completeFlags []string switchFlags []string } @@ -270,7 +271,12 @@ type reshardWorkflow struct { targetShards string skipSchemaCopy bool - lastOutput string + // currently only used by vtctld + lastOutput string + createFlags []string + completeFlags []string + cancelFlags []string + switchFlags []string } type iReshard interface { @@ -379,8 +385,9 @@ func (v VtctldReshard) Flavor() string { func (v VtctldReshard) exec(args ...string) { args2 := []string{"Reshard", "--workflow=" + v.workflowName, "--target-keyspace=" + v.targetKeyspace} args2 = append(args2, args...) - if err := vc.VtctldClient.ExecuteCommand(args2...); err != nil { - v.vc.t.Fatalf("failed to create Reshard workflow: %v", err) + var err error + if v.lastOutput, err = vc.VtctldClient.ExecuteCommandWithOutput(args2...); err != nil { + v.vc.t.Fatalf("failed to create Reshard workflow: %v: %s", err, v.lastOutput) } } @@ -395,11 +402,14 @@ func (v VtctldReshard) Create() { if v.skipSchemaCopy { args = append(args, "--skip-schema-copy="+strconv.FormatBool(v.skipSchemaCopy)) } + args = append(args, v.createFlags...) v.exec(args...) } func (v VtctldReshard) SwitchReadsAndWrites() { - v.exec("SwitchTraffic") + args := []string{"SwitchTraffic"} + args = append(args, v.switchFlags...) + v.exec(args...) } func (v VtctldReshard) ReverseReadsAndWrites() { @@ -407,8 +417,7 @@ func (v VtctldReshard) ReverseReadsAndWrites() { } func (v VtctldReshard) Show() { - //TODO implement me - panic("implement me") + v.exec("Show") } func (v VtctldReshard) SwitchReads() { @@ -422,11 +431,15 @@ func (v VtctldReshard) SwitchWrites() { } func (v VtctldReshard) Cancel() { - v.exec("Cancel") + args := []string{"Cancel"} + args = append(args, v.cancelFlags...) + v.exec(args...) } func (v VtctldReshard) Complete() { - v.exec("Complete") + args := []string{"Complete"} + args = append(args, v.completeFlags...) + v.exec(args...) } func (v VtctldReshard) GetLastOutput() string { diff --git a/go/vt/vtctl/workflow/server.go b/go/vt/vtctl/workflow/server.go index 5e9f3fc9300..fc215b84c22 100644 --- a/go/vt/vtctl/workflow/server.go +++ b/go/vt/vtctl/workflow/server.go @@ -1672,7 +1672,11 @@ func (s *Server) ReshardCreate(ctx context.Context, req *vtctldatapb.ReshardCrea log.Errorf("%w", err2) return nil, err } - rs, err := s.buildResharder(ctx, keyspace, req.Workflow, req.SourceShards, req.TargetShards, strings.Join(cells, ","), "") + tabletTypesStr := topoproto.MakeStringTypeCSV(req.TabletTypes) + if req.TabletSelectionPreference == tabletmanagerdatapb.TabletSelectionPreference_INORDER { + tabletTypesStr = discovery.InOrderHint + tabletTypesStr + } + rs, err := s.buildResharder(ctx, keyspace, req.Workflow, req.SourceShards, req.TargetShards, strings.Join(cells, ","), tabletTypesStr) if err != nil { return nil, vterrors.Wrap(err, "buildResharder") } @@ -1695,7 +1699,10 @@ func (s *Server) ReshardCreate(ctx context.Context, req *vtctldatapb.ReshardCrea } else { log.Warningf("Streams will not be started since --auto-start is set to false") } - return nil, nil + return s.WorkflowStatus(ctx, &vtctldatapb.WorkflowStatusRequest{ + Keyspace: keyspace, + Workflow: req.Workflow, + }) } // VDiffCreate is part of the vtctlservicepb.VtctldServer interface. From 661c664b0a192a1e66522bcf4bdc831bb102e4cf Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Tue, 27 Feb 2024 10:30:19 +0530 Subject: [PATCH 60/79] VTOrc optimize TMC usage (#15356) Signed-off-by: Manan Gupta --- go/flags/endtoend/vtbackup.txt | 2 +- go/flags/endtoend/vtcombo.txt | 2 +- go/flags/endtoend/vtctld.txt | 2 +- go/flags/endtoend/vtorc.txt | 2 +- go/flags/endtoend/vttablet.txt | 2 +- go/flags/endtoend/vttestserver.txt | 2 +- go/vt/vtorc/inst/instance_dao.go | 88 +++++++++++++------------- go/vt/vtorc/inst/tablet_dao.go | 23 ++----- go/vt/vtorc/logic/tablet_discovery.go | 7 +- go/vt/vtorc/logic/topology_recovery.go | 16 +++-- go/vt/vttablet/grpctmclient/client.go | 32 +++++++--- 11 files changed, 96 insertions(+), 82 deletions(-) diff --git a/go/flags/endtoend/vtbackup.txt b/go/flags/endtoend/vtbackup.txt index d0c5a328052..1b9f5aca61f 100644 --- a/go/flags/endtoend/vtbackup.txt +++ b/go/flags/endtoend/vtbackup.txt @@ -206,7 +206,7 @@ Flags: --stderrthreshold severityFlag logs at or above this threshold go to stderr (default 1) --tablet_manager_grpc_ca string the server ca to use to validate servers when connecting --tablet_manager_grpc_cert string the cert to use to connect - --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App} and CheckThrottler) (default 8) + --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App}, CheckThrottler and FullStatus) (default 8) --tablet_manager_grpc_connpool_size int number of tablets to keep tmclient connections open to (default 100) --tablet_manager_grpc_crl string the server crl to use to validate server certificates when connecting --tablet_manager_grpc_key string the key to use to connect diff --git a/go/flags/endtoend/vtcombo.txt b/go/flags/endtoend/vtcombo.txt index 0843ee46563..04a46d9e754 100644 --- a/go/flags/endtoend/vtcombo.txt +++ b/go/flags/endtoend/vtcombo.txt @@ -342,7 +342,7 @@ Flags: --tablet_hostname string if not empty, this hostname will be assumed instead of trying to resolve it --tablet_manager_grpc_ca string the server ca to use to validate servers when connecting --tablet_manager_grpc_cert string the cert to use to connect - --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App} and CheckThrottler) (default 8) + --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App}, CheckThrottler and FullStatus) (default 8) --tablet_manager_grpc_connpool_size int number of tablets to keep tmclient connections open to (default 100) --tablet_manager_grpc_crl string the server crl to use to validate server certificates when connecting --tablet_manager_grpc_key string the key to use to connect diff --git a/go/flags/endtoend/vtctld.txt b/go/flags/endtoend/vtctld.txt index 62d819fb759..da60dfeb3b1 100644 --- a/go/flags/endtoend/vtctld.txt +++ b/go/flags/endtoend/vtctld.txt @@ -141,7 +141,7 @@ Flags: --tablet_health_keep_alive duration close streaming tablet health connection if there are no requests for this long (default 5m0s) --tablet_manager_grpc_ca string the server ca to use to validate servers when connecting --tablet_manager_grpc_cert string the cert to use to connect - --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App} and CheckThrottler) (default 8) + --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App}, CheckThrottler and FullStatus) (default 8) --tablet_manager_grpc_connpool_size int number of tablets to keep tmclient connections open to (default 100) --tablet_manager_grpc_crl string the server crl to use to validate server certificates when connecting --tablet_manager_grpc_key string the key to use to connect diff --git a/go/flags/endtoend/vtorc.txt b/go/flags/endtoend/vtorc.txt index 8073323ec1c..1e14056460e 100644 --- a/go/flags/endtoend/vtorc.txt +++ b/go/flags/endtoend/vtorc.txt @@ -81,7 +81,7 @@ Flags: --table-refresh-interval int interval in milliseconds to refresh tables in status page with refreshRequired class --tablet_manager_grpc_ca string the server ca to use to validate servers when connecting --tablet_manager_grpc_cert string the cert to use to connect - --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App} and CheckThrottler) (default 8) + --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App}, CheckThrottler and FullStatus) (default 8) --tablet_manager_grpc_connpool_size int number of tablets to keep tmclient connections open to (default 100) --tablet_manager_grpc_crl string the server crl to use to validate server certificates when connecting --tablet_manager_grpc_key string the key to use to connect diff --git a/go/flags/endtoend/vttablet.txt b/go/flags/endtoend/vttablet.txt index bb7403ef1cb..6ff475badfa 100644 --- a/go/flags/endtoend/vttablet.txt +++ b/go/flags/endtoend/vttablet.txt @@ -349,7 +349,7 @@ Flags: --tablet_hostname string if not empty, this hostname will be assumed instead of trying to resolve it --tablet_manager_grpc_ca string the server ca to use to validate servers when connecting --tablet_manager_grpc_cert string the cert to use to connect - --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App} and CheckThrottler) (default 8) + --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App}, CheckThrottler and FullStatus) (default 8) --tablet_manager_grpc_connpool_size int number of tablets to keep tmclient connections open to (default 100) --tablet_manager_grpc_crl string the server crl to use to validate server certificates when connecting --tablet_manager_grpc_key string the key to use to connect diff --git a/go/flags/endtoend/vttestserver.txt b/go/flags/endtoend/vttestserver.txt index d3af635e353..3ca21d3d60e 100644 --- a/go/flags/endtoend/vttestserver.txt +++ b/go/flags/endtoend/vttestserver.txt @@ -121,7 +121,7 @@ Flags: --tablet_hostname string The hostname to use for the tablet otherwise it will be derived from OS' hostname (default "localhost") --tablet_manager_grpc_ca string the server ca to use to validate servers when connecting --tablet_manager_grpc_cert string the cert to use to connect - --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App} and CheckThrottler) (default 8) + --tablet_manager_grpc_concurrency int concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App}, CheckThrottler and FullStatus) (default 8) --tablet_manager_grpc_connpool_size int number of tablets to keep tmclient connections open to (default 100) --tablet_manager_grpc_crl string the server crl to use to validate server certificates when connecting --tablet_manager_grpc_key string the key to use to connect diff --git a/go/vt/vtorc/inst/instance_dao.go b/go/vt/vtorc/inst/instance_dao.go index c396a89ef21..250d2bd6ba6 100644 --- a/go/vt/vtorc/inst/instance_dao.go +++ b/go/vt/vtorc/inst/instance_dao.go @@ -178,7 +178,7 @@ func ReadTopologyInstanceBufferable(tabletAlias string, latency *stopwatch.Named var waitGroup sync.WaitGroup var tablet *topodatapb.Tablet - var fullStatus *replicationdatapb.FullStatus + var fs *replicationdatapb.FullStatus readingStartTime := time.Now() instance := NewInstance() instanceFound := false @@ -208,7 +208,7 @@ func ReadTopologyInstanceBufferable(tabletAlias string, latency *stopwatch.Named goto Cleanup } - fullStatus, err = FullStatus(tabletAlias) + fs, err = fullStatus(tabletAlias) if err != nil { goto Cleanup } @@ -218,48 +218,48 @@ func ReadTopologyInstanceBufferable(tabletAlias string, latency *stopwatch.Named instance.Port = int(tablet.MysqlPort) { // We begin with a few operations we can run concurrently, and which do not depend on anything - instance.ServerID = uint(fullStatus.ServerId) - instance.Version = fullStatus.Version - instance.ReadOnly = fullStatus.ReadOnly - instance.LogBinEnabled = fullStatus.LogBinEnabled - instance.BinlogFormat = fullStatus.BinlogFormat - instance.LogReplicationUpdatesEnabled = fullStatus.LogReplicaUpdates - instance.VersionComment = fullStatus.VersionComment - - if instance.LogBinEnabled && fullStatus.PrimaryStatus != nil { - binlogPos, err := getBinlogCoordinatesFromPositionString(fullStatus.PrimaryStatus.FilePosition) + instance.ServerID = uint(fs.ServerId) + instance.Version = fs.Version + instance.ReadOnly = fs.ReadOnly + instance.LogBinEnabled = fs.LogBinEnabled + instance.BinlogFormat = fs.BinlogFormat + instance.LogReplicationUpdatesEnabled = fs.LogReplicaUpdates + instance.VersionComment = fs.VersionComment + + if instance.LogBinEnabled && fs.PrimaryStatus != nil { + binlogPos, err := getBinlogCoordinatesFromPositionString(fs.PrimaryStatus.FilePosition) instance.SelfBinlogCoordinates = binlogPos errorChan <- err } - instance.SemiSyncPrimaryEnabled = fullStatus.SemiSyncPrimaryEnabled - instance.SemiSyncReplicaEnabled = fullStatus.SemiSyncReplicaEnabled - instance.SemiSyncPrimaryWaitForReplicaCount = uint(fullStatus.SemiSyncWaitForReplicaCount) - instance.SemiSyncPrimaryTimeout = fullStatus.SemiSyncPrimaryTimeout + instance.SemiSyncPrimaryEnabled = fs.SemiSyncPrimaryEnabled + instance.SemiSyncReplicaEnabled = fs.SemiSyncReplicaEnabled + instance.SemiSyncPrimaryWaitForReplicaCount = uint(fs.SemiSyncWaitForReplicaCount) + instance.SemiSyncPrimaryTimeout = fs.SemiSyncPrimaryTimeout - instance.SemiSyncPrimaryClients = uint(fullStatus.SemiSyncPrimaryClients) - instance.SemiSyncPrimaryStatus = fullStatus.SemiSyncPrimaryStatus - instance.SemiSyncReplicaStatus = fullStatus.SemiSyncReplicaStatus + instance.SemiSyncPrimaryClients = uint(fs.SemiSyncPrimaryClients) + instance.SemiSyncPrimaryStatus = fs.SemiSyncPrimaryStatus + instance.SemiSyncReplicaStatus = fs.SemiSyncReplicaStatus if instance.IsOracleMySQL() || instance.IsPercona() { // Stuff only supported on Oracle / Percona MySQL // ... // @@gtid_mode only available in Oracle / Percona MySQL >= 5.6 - instance.GTIDMode = fullStatus.GtidMode - instance.ServerUUID = fullStatus.ServerUuid - if fullStatus.PrimaryStatus != nil { - GtidExecutedPos, err := replication.DecodePosition(fullStatus.PrimaryStatus.Position) + instance.GTIDMode = fs.GtidMode + instance.ServerUUID = fs.ServerUuid + if fs.PrimaryStatus != nil { + GtidExecutedPos, err := replication.DecodePosition(fs.PrimaryStatus.Position) errorChan <- err if err == nil && GtidExecutedPos.GTIDSet != nil { instance.ExecutedGtidSet = GtidExecutedPos.GTIDSet.String() } } - GtidPurgedPos, err := replication.DecodePosition(fullStatus.GtidPurged) + GtidPurgedPos, err := replication.DecodePosition(fs.GtidPurged) errorChan <- err if err == nil && GtidPurgedPos.GTIDSet != nil { instance.GtidPurged = GtidPurgedPos.GTIDSet.String() } - instance.BinlogRowImage = fullStatus.BinlogRowImage + instance.BinlogRowImage = fs.BinlogRowImage if instance.GTIDMode != "" && instance.GTIDMode != "OFF" { instance.SupportsOracleGTID = true @@ -269,45 +269,45 @@ func ReadTopologyInstanceBufferable(tabletAlias string, latency *stopwatch.Named instance.ReplicationIOThreadState = ReplicationThreadStateNoThread instance.ReplicationSQLThreadState = ReplicationThreadStateNoThread - if fullStatus.ReplicationStatus != nil { - instance.HasReplicationCredentials = fullStatus.ReplicationStatus.SourceUser != "" + if fs.ReplicationStatus != nil { + instance.HasReplicationCredentials = fs.ReplicationStatus.SourceUser != "" - instance.ReplicationIOThreadState = ReplicationThreadStateFromReplicationState(replication.ReplicationState(fullStatus.ReplicationStatus.IoState)) - instance.ReplicationSQLThreadState = ReplicationThreadStateFromReplicationState(replication.ReplicationState(fullStatus.ReplicationStatus.SqlState)) + instance.ReplicationIOThreadState = ReplicationThreadStateFromReplicationState(replication.ReplicationState(fs.ReplicationStatus.IoState)) + instance.ReplicationSQLThreadState = ReplicationThreadStateFromReplicationState(replication.ReplicationState(fs.ReplicationStatus.SqlState)) instance.ReplicationIOThreadRuning = instance.ReplicationIOThreadState.IsRunning() instance.ReplicationSQLThreadRuning = instance.ReplicationSQLThreadState.IsRunning() - binlogPos, err := getBinlogCoordinatesFromPositionString(fullStatus.ReplicationStatus.RelayLogSourceBinlogEquivalentPosition) + binlogPos, err := getBinlogCoordinatesFromPositionString(fs.ReplicationStatus.RelayLogSourceBinlogEquivalentPosition) instance.ReadBinlogCoordinates = binlogPos errorChan <- err - binlogPos, err = getBinlogCoordinatesFromPositionString(fullStatus.ReplicationStatus.FilePosition) + binlogPos, err = getBinlogCoordinatesFromPositionString(fs.ReplicationStatus.FilePosition) instance.ExecBinlogCoordinates = binlogPos errorChan <- err instance.IsDetached, _ = instance.ExecBinlogCoordinates.ExtractDetachedCoordinates() - binlogPos, err = getBinlogCoordinatesFromPositionString(fullStatus.ReplicationStatus.RelayLogFilePosition) + binlogPos, err = getBinlogCoordinatesFromPositionString(fs.ReplicationStatus.RelayLogFilePosition) instance.RelaylogCoordinates = binlogPos instance.RelaylogCoordinates.Type = RelayLog errorChan <- err - instance.LastSQLError = emptyQuotesRegexp.ReplaceAllString(strconv.QuoteToASCII(fullStatus.ReplicationStatus.LastSqlError), "") - instance.LastIOError = emptyQuotesRegexp.ReplaceAllString(strconv.QuoteToASCII(fullStatus.ReplicationStatus.LastIoError), "") + instance.LastSQLError = emptyQuotesRegexp.ReplaceAllString(strconv.QuoteToASCII(fs.ReplicationStatus.LastSqlError), "") + instance.LastIOError = emptyQuotesRegexp.ReplaceAllString(strconv.QuoteToASCII(fs.ReplicationStatus.LastIoError), "") - instance.SQLDelay = fullStatus.ReplicationStatus.SqlDelay - instance.UsingOracleGTID = fullStatus.ReplicationStatus.AutoPosition - instance.UsingMariaDBGTID = fullStatus.ReplicationStatus.UsingGtid - instance.SourceUUID = fullStatus.ReplicationStatus.SourceUuid - instance.HasReplicationFilters = fullStatus.ReplicationStatus.HasReplicationFilters + instance.SQLDelay = fs.ReplicationStatus.SqlDelay + instance.UsingOracleGTID = fs.ReplicationStatus.AutoPosition + instance.UsingMariaDBGTID = fs.ReplicationStatus.UsingGtid + instance.SourceUUID = fs.ReplicationStatus.SourceUuid + instance.HasReplicationFilters = fs.ReplicationStatus.HasReplicationFilters - instance.SourceHost = fullStatus.ReplicationStatus.SourceHost - instance.SourcePort = int(fullStatus.ReplicationStatus.SourcePort) + instance.SourceHost = fs.ReplicationStatus.SourceHost + instance.SourcePort = int(fs.ReplicationStatus.SourcePort) - if fullStatus.ReplicationStatus.ReplicationLagUnknown { + if fs.ReplicationStatus.ReplicationLagUnknown { instance.SecondsBehindPrimary.Valid = false } else { instance.SecondsBehindPrimary.Valid = true - instance.SecondsBehindPrimary.Int64 = int64(fullStatus.ReplicationStatus.ReplicationLagSeconds) + instance.SecondsBehindPrimary.Int64 = int64(fs.ReplicationStatus.ReplicationLagSeconds) } if instance.SecondsBehindPrimary.Valid && instance.SecondsBehindPrimary.Int64 < 0 { log.Warningf("Alias: %+v, instance.SecondsBehindPrimary < 0 [%+v], correcting to 0", tabletAlias, instance.SecondsBehindPrimary.Int64) @@ -316,7 +316,7 @@ func ReadTopologyInstanceBufferable(tabletAlias string, latency *stopwatch.Named // And until told otherwise: instance.ReplicationLagSeconds = instance.SecondsBehindPrimary - instance.AllowTLS = fullStatus.ReplicationStatus.SslAllowed + instance.AllowTLS = fs.ReplicationStatus.SslAllowed } instanceFound = true diff --git a/go/vt/vtorc/inst/tablet_dao.go b/go/vt/vtorc/inst/tablet_dao.go index 3ee49a75781..af304292a70 100644 --- a/go/vt/vtorc/inst/tablet_dao.go +++ b/go/vt/vtorc/inst/tablet_dao.go @@ -35,29 +35,20 @@ import ( // ErrTabletAliasNil is a fixed error message. var ErrTabletAliasNil = errors.New("tablet alias is nil") +var tmc tmclient.TabletManagerClient -// ResetReplicationParameters resets the replication parameters on the given tablet. -func ResetReplicationParameters(tabletAlias string) error { - tablet, err := ReadTablet(tabletAlias) - if err != nil { - return err - } - tmc := tmclient.NewTabletManagerClient() - tmcCtx, tmcCancel := context.WithTimeout(context.Background(), topo.RemoteOperationTimeout) - defer tmcCancel() - if err := tmc.ResetReplicationParameters(tmcCtx, tablet); err != nil { - return err - } - return nil +// InitializeTMC initializes the tablet manager client to use for all VTOrc RPC calls. +func InitializeTMC() tmclient.TabletManagerClient { + tmc = tmclient.NewTabletManagerClient() + return tmc } -// FullStatus gets the full status of the MySQL running in vttablet. -func FullStatus(tabletAlias string) (*replicationdatapb.FullStatus, error) { +// fullStatus gets the full status of the MySQL running in vttablet. +func fullStatus(tabletAlias string) (*replicationdatapb.FullStatus, error) { tablet, err := ReadTablet(tabletAlias) if err != nil { return nil, err } - tmc := tmclient.NewTabletManagerClient() tmcCtx, tmcCancel := context.WithTimeout(context.Background(), topo.RemoteOperationTimeout) defer tmcCancel() return tmc.FullStatus(tmcCtx, tablet) diff --git a/go/vt/vtorc/logic/tablet_discovery.go b/go/vt/vtorc/logic/tablet_discovery.go index f08ab2c9c15..cda35b8091c 100644 --- a/go/vt/vtorc/logic/tablet_discovery.go +++ b/go/vt/vtorc/logic/tablet_discovery.go @@ -66,7 +66,7 @@ func RegisterFlags(fs *pflag.FlagSet) { // channel for polling. func OpenTabletDiscovery() <-chan time.Time { ts = topo.Open() - tmc = tmclient.NewTabletManagerClient() + tmc = inst.InitializeTMC() // Clear existing cache and perform a new refresh. if _, err := db.ExecVTOrc("delete from vitess_tablet"); err != nil { log.Error(err) @@ -302,6 +302,11 @@ func changeTabletType(ctx context.Context, tablet *topodatapb.Tablet, tabletType return tmc.ChangeType(ctx, tablet, tabletType, semiSync) } +// resetReplicationParameters resets the replication parameters on the given tablet. +func resetReplicationParameters(ctx context.Context, tablet *topodatapb.Tablet) error { + return tmc.ResetReplicationParameters(ctx, tablet) +} + // setReplicationSource calls the said RPC with the parameters provided func setReplicationSource(ctx context.Context, replica *topodatapb.Tablet, primary *topodatapb.Tablet, semiSync bool) error { return tmc.SetReplicationSource(ctx, replica, primary.Alias, 0, "", true, semiSync) diff --git a/go/vt/vtorc/logic/topology_recovery.go b/go/vt/vtorc/logic/topology_recovery.go index e5168fea541..c1fc2c8f9fb 100644 --- a/go/vt/vtorc/logic/topology_recovery.go +++ b/go/vt/vtorc/logic/topology_recovery.go @@ -35,7 +35,6 @@ import ( "vitess.io/vitess/go/vt/vtorc/config" "vitess.io/vitess/go/vt/vtorc/inst" "vitess.io/vitess/go/vt/vtorc/util" - "vitess.io/vitess/go/vt/vttablet/tmclient" ) type RecoveryType string @@ -210,12 +209,15 @@ func recoverPrimaryHasPrimary(ctx context.Context, analysisEntry *inst.Replicati _ = resolveRecovery(topologyRecovery, nil) }() - // Reset replication on current primary. - err = inst.ResetReplicationParameters(analysisEntry.AnalyzedInstanceAlias) + // Read the tablet information from the database to find the shard and keyspace of the tablet + analyzedTablet, err := inst.ReadTablet(analysisEntry.AnalyzedInstanceAlias) if err != nil { - return false, topologyRecovery, err + return false, nil, err } - return true, topologyRecovery, nil + + // Reset replication on current primary. + err = resetReplicationParameters(ctx, analyzedTablet) + return true, topologyRecovery, err } // runEmergencyReparentOp runs a recovery for which we have to run ERS. Here waitForAllTablets is a boolean telling ERS whether it should wait for all the tablets @@ -244,7 +246,7 @@ func runEmergencyReparentOp(ctx context.Context, analysisEntry *inst.Replication _ = resolveRecovery(topologyRecovery, promotedReplica) }() - ev, err := reparentutil.NewEmergencyReparenter(ts, tmclient.NewTabletManagerClient(), logutil.NewCallbackLogger(func(event *logutilpb.Event) { + ev, err := reparentutil.NewEmergencyReparenter(ts, tmc, logutil.NewCallbackLogger(func(event *logutilpb.Event) { level := event.GetLevel() value := event.GetValue() // we only log the warnings and errors explicitly, everything gets logged as an information message anyways in auditing topology recovery @@ -836,7 +838,7 @@ func electNewPrimary(ctx context.Context, analysisEntry *inst.ReplicationAnalysi } _ = AuditTopologyRecovery(topologyRecovery, "starting PlannedReparentShard for electing new primary.") - ev, err := reparentutil.NewPlannedReparenter(ts, tmclient.NewTabletManagerClient(), logutil.NewCallbackLogger(func(event *logutilpb.Event) { + ev, err := reparentutil.NewPlannedReparenter(ts, tmc, logutil.NewCallbackLogger(func(event *logutilpb.Event) { level := event.GetLevel() value := event.GetValue() // we only log the warnings and errors explicitly, everything gets logged as an information message anyways in auditing topology recovery diff --git a/go/vt/vttablet/grpctmclient/client.go b/go/vt/vttablet/grpctmclient/client.go index 089b7c014dd..69c80932657 100644 --- a/go/vt/vttablet/grpctmclient/client.go +++ b/go/vt/vttablet/grpctmclient/client.go @@ -55,7 +55,7 @@ var ( ) func registerFlags(fs *pflag.FlagSet) { - fs.IntVar(&concurrency, "tablet_manager_grpc_concurrency", concurrency, "concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App} and CheckThrottler)") + fs.IntVar(&concurrency, "tablet_manager_grpc_concurrency", concurrency, "concurrency to use to talk to a vttablet server for performance-sensitive RPCs (like ExecuteFetchAs{Dba,App}, CheckThrottler and FullStatus)") fs.StringVar(&cert, "tablet_manager_grpc_cert", cert, "the cert to use to connect") fs.StringVar(&key, "tablet_manager_grpc_key", key, "the key to use to connect") fs.StringVar(&ca, "tablet_manager_grpc_ca", ca, "the server ca to use to validate servers when connecting") @@ -94,8 +94,8 @@ type tmc struct { // grpcClient implements both dialer and poolDialer. type grpcClient struct { - // This cache of connections is to maximize QPS for ExecuteFetchAs{Dba,App} and - // CheckThrottler. Note we'll keep the clients open and close them upon Close() only. + // This cache of connections is to maximize QPS for ExecuteFetchAs{Dba,App}, + // CheckThrottler and FullStatus. Note we'll keep the clients open and close them upon Close() only. // But that's OK because usually the tasks that use them are one-purpose only. // The map is protected by the mutex. mu sync.Mutex @@ -115,7 +115,7 @@ type poolDialer interface { // // Connections are produced by the dialer implementation, which is either the // grpcClient implementation, which reuses connections only for ExecuteFetchAs{Dba,App} -// and CheckThrottler, otherwise making single-purpose connections that are closed +// CheckThrottler, and FullStatus, otherwise making single-purpose connections that are closed // after use. // // In order to more efficiently use the underlying tcp connections, you can @@ -569,12 +569,28 @@ func (client *Client) ReplicationStatus(ctx context.Context, tablet *topodatapb. } // FullStatus is part of the tmclient.TabletManagerClient interface. +// It always tries to use a cached client via the dialer pool as this is +// called very frequently from VTOrc, and the overhead of creating a new gRPC connection/channel +// and dialing the other tablet every time is not practical. func (client *Client) FullStatus(ctx context.Context, tablet *topodatapb.Tablet) (*replicationdatapb.FullStatus, error) { - c, closer, err := client.dialer.dial(ctx, tablet) - if err != nil { - return nil, err + var c tabletmanagerservicepb.TabletManagerClient + var err error + if poolDialer, ok := client.dialer.(poolDialer); ok { + c, err = poolDialer.dialPool(ctx, tablet) + if err != nil { + return nil, err + } } - defer closer.Close() + + if c == nil { + var closer io.Closer + c, closer, err = client.dialer.dial(ctx, tablet) + if err != nil { + return nil, err + } + defer closer.Close() + } + response, err := c.FullStatus(ctx, &tabletmanagerdatapb.FullStatusRequest{}) if err != nil { return nil, err From dab2af265a642cd42fe209d76183712b7abfd64e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20Taylor?= Date: Tue, 27 Feb 2024 12:14:55 +0100 Subject: [PATCH 61/79] refactor: change FuncExpr to use Exprs instead of SelectExprs (#15368) --- go/vt/sqlparser/ast.go | 2 +- go/vt/sqlparser/ast_clone.go | 2 +- go/vt/sqlparser/ast_copy_on_rewrite.go | 4 +- go/vt/sqlparser/ast_equals.go | 2 +- go/vt/sqlparser/ast_rewrite.go | 4 +- go/vt/sqlparser/ast_visit.go | 2 +- go/vt/sqlparser/cached_size.go | 2 +- go/vt/sqlparser/sql.go | 14811 ++++++++-------- go/vt/sqlparser/sql.y | 29 +- go/vt/sqlparser/testdata/select_cases.txt | 2 +- go/vt/vtctl/workflow/materializer.go | 16 +- go/vt/vtctl/workflow/stream_migrator.go | 17 +- go/vt/vtgate/evalengine/translate_builtin.go | 6 +- .../operators/aggregation_pushing.go | 6 +- .../simplifier/expression_simplifier.go | 8 +- .../tabletmanager/vdiff/table_differ.go | 8 +- .../tabletserver/vstreamer/planbuilder.go | 20 +- .../vstreamer/planbuilder_test.go | 9 - go/vt/wrangler/materializer.go | 16 +- go/vt/wrangler/vdiff.go | 8 +- 20 files changed, 7430 insertions(+), 7544 deletions(-) diff --git a/go/vt/sqlparser/ast.go b/go/vt/sqlparser/ast.go index 569148a224a..f3dd8644ed3 100644 --- a/go/vt/sqlparser/ast.go +++ b/go/vt/sqlparser/ast.go @@ -2406,7 +2406,7 @@ type ( FuncExpr struct { Qualifier IdentifierCS Name IdentifierCI - Exprs SelectExprs + Exprs Exprs } // ValuesFuncExpr represents a function call. diff --git a/go/vt/sqlparser/ast_clone.go b/go/vt/sqlparser/ast_clone.go index 9b1128c3cbf..5156eb6df6b 100644 --- a/go/vt/sqlparser/ast_clone.go +++ b/go/vt/sqlparser/ast_clone.go @@ -1405,7 +1405,7 @@ func CloneRefOfFuncExpr(n *FuncExpr) *FuncExpr { out := *n out.Qualifier = CloneIdentifierCS(n.Qualifier) out.Name = CloneIdentifierCI(n.Name) - out.Exprs = CloneSelectExprs(n.Exprs) + out.Exprs = CloneExprs(n.Exprs) return &out } diff --git a/go/vt/sqlparser/ast_copy_on_rewrite.go b/go/vt/sqlparser/ast_copy_on_rewrite.go index 1ce13a61b0a..d44f525b7a0 100644 --- a/go/vt/sqlparser/ast_copy_on_rewrite.go +++ b/go/vt/sqlparser/ast_copy_on_rewrite.go @@ -2323,12 +2323,12 @@ func (c *cow) copyOnRewriteRefOfFuncExpr(n *FuncExpr, parent SQLNode) (out SQLNo if c.pre == nil || c.pre(n, parent) { _Qualifier, changedQualifier := c.copyOnRewriteIdentifierCS(n.Qualifier, n) _Name, changedName := c.copyOnRewriteIdentifierCI(n.Name, n) - _Exprs, changedExprs := c.copyOnRewriteSelectExprs(n.Exprs, n) + _Exprs, changedExprs := c.copyOnRewriteExprs(n.Exprs, n) if changedQualifier || changedName || changedExprs { res := *n res.Qualifier, _ = _Qualifier.(IdentifierCS) res.Name, _ = _Name.(IdentifierCI) - res.Exprs, _ = _Exprs.(SelectExprs) + res.Exprs, _ = _Exprs.(Exprs) out = &res if c.cloned != nil { c.cloned(n, out) diff --git a/go/vt/sqlparser/ast_equals.go b/go/vt/sqlparser/ast_equals.go index 47ba31fcd20..5cfb46f6cde 100644 --- a/go/vt/sqlparser/ast_equals.go +++ b/go/vt/sqlparser/ast_equals.go @@ -2631,7 +2631,7 @@ func (cmp *Comparator) RefOfFuncExpr(a, b *FuncExpr) bool { } return cmp.IdentifierCS(a.Qualifier, b.Qualifier) && cmp.IdentifierCI(a.Name, b.Name) && - cmp.SelectExprs(a.Exprs, b.Exprs) + cmp.Exprs(a.Exprs, b.Exprs) } // RefOfGTIDFuncExpr does deep equals between the two objects. diff --git a/go/vt/sqlparser/ast_rewrite.go b/go/vt/sqlparser/ast_rewrite.go index 02308ed0758..ff5f72b2ef2 100644 --- a/go/vt/sqlparser/ast_rewrite.go +++ b/go/vt/sqlparser/ast_rewrite.go @@ -3138,8 +3138,8 @@ func (a *application) rewriteRefOfFuncExpr(parent SQLNode, node *FuncExpr, repla }) { return false } - if !a.rewriteSelectExprs(node, node.Exprs, func(newNode, parent SQLNode) { - parent.(*FuncExpr).Exprs = newNode.(SelectExprs) + if !a.rewriteExprs(node, node.Exprs, func(newNode, parent SQLNode) { + parent.(*FuncExpr).Exprs = newNode.(Exprs) }) { return false } diff --git a/go/vt/sqlparser/ast_visit.go b/go/vt/sqlparser/ast_visit.go index 007b4048da9..b63cd94ca3d 100644 --- a/go/vt/sqlparser/ast_visit.go +++ b/go/vt/sqlparser/ast_visit.go @@ -1674,7 +1674,7 @@ func VisitRefOfFuncExpr(in *FuncExpr, f Visit) error { if err := VisitIdentifierCI(in.Name, f); err != nil { return err } - if err := VisitSelectExprs(in.Exprs, f); err != nil { + if err := VisitExprs(in.Exprs, f); err != nil { return err } return nil diff --git a/go/vt/sqlparser/cached_size.go b/go/vt/sqlparser/cached_size.go index bf5620f8b09..11d7dc30c36 100644 --- a/go/vt/sqlparser/cached_size.go +++ b/go/vt/sqlparser/cached_size.go @@ -1432,7 +1432,7 @@ func (cached *FuncExpr) CachedSize(alloc bool) int64 { size += cached.Qualifier.CachedSize(false) // field Name vitess.io/vitess/go/vt/sqlparser.IdentifierCI size += cached.Name.CachedSize(false) - // field Exprs vitess.io/vitess/go/vt/sqlparser.SelectExprs + // field Exprs vitess.io/vitess/go/vt/sqlparser.Exprs { size += hack.RuntimeAllocSize(int64(cap(cached.Exprs)) * int64(16)) for _, elem := range cached.Exprs { diff --git a/go/vt/sqlparser/sql.go b/go/vt/sqlparser/sql.go index baa8e713f94..e694847c784 100644 --- a/go/vt/sqlparser/sql.go +++ b/go/vt/sqlparser/sql.go @@ -1523,7 +1523,7 @@ var yyExca = [...]int{ 244, 817, -2, 815, -1, 122, - 241, 1597, + 241, 1595, -2, 133, -1, 124, 1, 160, @@ -1542,18 +1542,18 @@ var yyExca = [...]int{ 165, 41, -2, 45, -1, 942, - 88, 1614, - -2, 1463, + 88, 1612, + -2, 1461, -1, 943, - 88, 1615, - 224, 1619, - -2, 1464, + 88, 1613, + 224, 1617, + -2, 1462, -1, 944, - 224, 1618, + 224, 1616, -2, 42, -1, 1028, 61, 889, - -2, 904, + -2, 902, -1, 1116, 252, 43, 257, 43, @@ -1563,14 +1563,14 @@ var yyExca = [...]int{ 735, 582, -2, 167, -1, 1504, - 224, 1619, - -2, 1464, + 224, 1617, + -2, 1462, -1, 1715, 61, 890, - -2, 908, + -2, 906, -1, 1716, 61, 891, - -2, 909, + -2, 907, -1, 1772, 137, 167, 179, 167, @@ -1584,34 +1584,34 @@ var yyExca = [...]int{ 252, 44, 257, 44, -2, 422, - -1, 2302, - 224, 1623, - -2, 1617, - -1, 2303, - 224, 1619, + -1, 2300, + 224, 1621, -2, 1615, - -1, 2405, + -1, 2301, + 224, 1617, + -2, 1613, + -1, 2404, 137, 167, 179, 167, 349, 167, -2, 461, - -1, 2412, + -1, 2411, 27, 188, -2, 190, - -1, 2866, + -1, 2865, 79, 98, 89, 98, - -2, 967, - -1, 2935, + -2, 965, + -1, 2934, 710, 702, -2, 676, - -1, 3145, - 51, 1565, - -2, 1559, - -1, 3970, + -1, 3144, + 51, 1563, + -2, 1557, + -1, 3969, 710, 702, -2, 690, - -1, 4056, + -1, 4055, 91, 634, 96, 634, 106, 634, @@ -1657,91 +1657,91 @@ var yyExca = [...]int{ 220, 634, 221, 634, 222, 634, - -2, 1988, + -2, 1986, } const yyPrivate = 57344 -const yyLast = 56127 +const yyLast = 55539 var yyAct = [...]int{ - 958, 3626, 3951, 87, 3627, 946, 3625, 953, 2095, 4037, - 4144, 2107, 4131, 3297, 4025, 2331, 3197, 3204, 4098, 1269, - 945, 4099, 1982, 3935, 3858, 2402, 3246, 3158, 4054, 3255, - 3260, 3257, 3427, 3256, 3254, 3259, 3258, 911, 3933, 3563, - 42, 1267, 2763, 2333, 3097, 2038, 3275, 3576, 5, 3212, - 739, 3162, 3159, 3474, 3468, 2476, 3668, 3274, 2999, 2357, - 3156, 2826, 733, 3458, 734, 3277, 2900, 907, 3146, 2439, - 767, 1831, 1775, 2981, 906, 3304, 2444, 2932, 2901, 4002, - 1731, 2464, 2902, 2507, 2390, 163, 1026, 1078, 87, 2376, - 1046, 1023, 2851, 2373, 2378, 1878, 2832, 43, 2819, 2377, - 2298, 2803, 3494, 2286, 2254, 2130, 1148, 1026, 2091, 2046, - 41, 2973, 2253, 2485, 149, 2463, 2365, 2524, 1860, 2446, - 2893, 1106, 1088, 1025, 1111, 1029, 1764, 2868, 2380, 1744, - 2135, 1696, 100, 104, 105, 1517, 2066, 2351, 1443, 1428, - 1867, 1978, 1085, 1082, 1048, 1959, 3161, 749, 1117, 2461, - 1086, 2435, 2436, 1112, 1113, 1763, 1063, 1749, 1065, 1035, - 2299, 1114, 744, 1718, 737, 1124, 2204, 3663, 2143, 2162, - 2801, 2839, 1476, 99, 1257, 107, 2037, 1045, 1990, 127, - 125, 1032, 3655, 2358, 85, 1031, 167, 1826, 126, 1852, - 132, 908, 1500, 133, 1058, 1021, 1197, 726, 1030, 743, - 1521, 1033, 98, 736, 1265, 1243, 4132, 2478, 2479, 2480, - 3986, 3564, 3243, 2478, 93, 1526, 2923, 1053, 1057, 2522, - 84, 1444, 106, 2955, 2954, 3556, 4081, 2989, 1020, 2990, - 3981, 3982, 1038, 2328, 2329, 2053, 3987, 2052, 2051, 128, - 1153, 3519, 2050, 134, 1079, 671, 2049, 2048, 2021, 1213, - 4075, 668, 1692, 669, 2799, 2572, 3142, 4102, 1150, 3101, - 4154, 4097, 4122, 3432, 1439, 1944, 3431, 2509, 2354, 2353, - 727, 1167, 1168, 1169, 1039, 1172, 1173, 1174, 1175, 1072, - 3265, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, - 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1127, 2511, - 1073, 2, 1128, 3960, 1102, 1101, 1024, 1022, 95, 1735, - 711, 128, 1103, 1100, 1733, 2828, 2948, 1154, 1157, 1158, - 3630, 1047, 3630, 1460, 1161, 3936, 2925, 729, 2764, 1454, - 95, 3982, 2058, 3323, 1090, 4137, 3263, 1095, 95, 1736, - 4085, 912, 4083, 2510, 1734, 3265, 111, 112, 113, 2069, - 116, 1170, 1019, 122, 705, 705, 191, 711, 3262, 663, - 4136, 3854, 3269, 3853, 1152, 4084, 3569, 4082, 2945, 3570, - 4112, 724, 725, 1214, 1071, 1075, 910, 1725, 190, 128, - 1151, 1014, 1015, 1016, 1017, 3864, 4079, 95, 1028, 961, - 962, 963, 961, 962, 963, 3588, 1104, 86, 702, 1430, - 3577, 3263, 129, 1071, 1075, 910, 4026, 3629, 4034, 3629, - 2504, 3863, 2100, 4059, 3344, 172, 1060, 1061, 3587, 705, - 1841, 2962, 2963, 2800, 86, 3194, 3195, 3269, 1094, 4064, - 3193, 1096, 2397, 2398, 2877, 2988, 2579, 2876, 1450, 4038, - 2878, 1442, 2030, 2031, 86, 705, 687, 4062, 705, 1099, - 2576, 1206, 1207, 1765, 2972, 1766, 4068, 4069, 2882, 685, - 1457, 1444, 1458, 1459, 2396, 3214, 3215, 1262, 2842, 1233, - 1012, 169, 4063, 3681, 170, 95, 3266, 1221, 1440, 1238, - 1239, 1011, 1222, 1209, 1221, 3952, 1234, 1227, 2361, 1222, - 1220, 2889, 1219, 2843, 705, 86, 3965, 189, 88, 682, - 1986, 2577, 95, 2455, 1250, 2330, 1252, 1097, 697, 705, - 4103, 2415, 2414, 3301, 3035, 4042, 2835, 2836, 4042, 2570, - 3331, 3329, 95, 692, 719, 1477, 2449, 2029, 3299, 1196, - 1099, 4104, 1091, 2033, 695, 723, 1761, 2361, 717, 1093, - 1092, 3266, 3305, 2974, 1249, 1251, 1934, 3320, 1700, 1478, - 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1485, 1487, 1488, - 2933, 3906, 1429, 3907, 2486, 2958, 706, 706, 3292, 1454, - 1960, 2525, 4134, 95, 3213, 1254, 3293, 1261, 2573, 2531, - 2574, 1235, 1228, 1260, 1240, 1259, 3216, 1202, 1097, 2548, - 1935, 2549, 1936, 2550, 1241, 2529, 2976, 1236, 1237, 3558, - 1242, 1064, 672, 3557, 674, 688, 3302, 708, 2551, 707, - 678, 173, 676, 680, 689, 681, 1177, 675, 2489, 686, - 179, 3300, 677, 690, 691, 694, 698, 699, 700, 696, - 693, 706, 684, 709, 2532, 1176, 1098, 2528, 1987, 2538, - 2534, 2536, 2537, 2535, 2539, 2540, 2541, 2527, 4076, 1703, - 2530, 1247, 1107, 3838, 3634, 1248, 1108, 706, 2374, 1108, - 706, 2926, 1146, 1145, 1845, 1253, 1144, 3471, 1143, 3100, - 1142, 1141, 1140, 1139, 1134, 2448, 1147, 3216, 1450, 1083, - 3036, 2359, 2360, 1083, 1120, 4109, 4155, 1081, 1156, 1083, - 1246, 1119, 2977, 1979, 1119, 1074, 1068, 1066, 1155, 2462, - 1059, 2515, 1266, 2514, 1266, 1266, 706, 1975, 1431, 1164, - 3236, 2957, 1839, 1838, 1837, 2943, 1976, 1098, 1835, 1212, - 662, 706, 1492, 1493, 1074, 1068, 1066, 4077, 3948, 2971, - 2359, 2360, 2970, 1449, 1446, 1447, 1448, 1453, 1455, 1452, - 3508, 1451, 2508, 3490, 2873, 164, 2838, 2776, 2103, 1753, - 1653, 1445, 1026, 1501, 1506, 1507, 1211, 1510, 1512, 1513, - 1514, 1515, 1516, 1762, 1519, 1520, 1522, 1522, 2960, 1522, + 958, 3625, 953, 87, 3626, 3950, 3624, 945, 946, 4143, + 2107, 4130, 4036, 4024, 3296, 3196, 3203, 4097, 1269, 2095, + 4098, 3934, 2401, 3245, 2329, 1982, 4053, 3857, 3254, 3426, + 3259, 3256, 911, 3255, 3253, 42, 3258, 3257, 3157, 3932, + 2038, 1267, 2761, 5, 3575, 3562, 3274, 2331, 3095, 3211, + 2475, 739, 3273, 3161, 3158, 3473, 3467, 3667, 2998, 2356, + 3155, 2825, 733, 3457, 2438, 907, 3145, 3493, 734, 1775, + 767, 2899, 1831, 2980, 906, 2931, 4001, 3303, 1078, 3276, + 2463, 2443, 2900, 2506, 1731, 2901, 1026, 163, 87, 2375, + 2389, 1046, 1023, 2850, 1148, 2376, 2372, 41, 2831, 2377, + 1053, 1878, 2253, 2817, 2801, 43, 2285, 1026, 1124, 2091, + 2252, 2972, 2484, 149, 1860, 2046, 2462, 2364, 1025, 2523, + 1029, 2445, 1088, 1111, 2892, 1106, 1764, 2867, 2129, 1744, + 2379, 1696, 1517, 100, 104, 105, 2350, 2135, 2066, 1048, + 1443, 1428, 1978, 1867, 3160, 1085, 749, 2460, 1959, 1082, + 1117, 1114, 2435, 2434, 1086, 1112, 1113, 1763, 1063, 1035, + 2838, 1065, 1749, 1718, 737, 2162, 3662, 2143, 2799, 1500, + 744, 1476, 2357, 2037, 1032, 1045, 107, 85, 1257, 1990, + 127, 3654, 1826, 1852, 132, 1030, 167, 125, 126, 1197, + 99, 133, 1033, 1031, 1021, 1058, 743, 93, 1521, 98, + 84, 4131, 908, 736, 1265, 1243, 2477, 2478, 2479, 3985, + 3563, 1526, 3242, 1057, 2477, 2954, 2953, 106, 2922, 2521, + 3555, 1020, 4080, 726, 2988, 2989, 1444, 3981, 2326, 2327, + 2053, 2052, 3980, 1038, 671, 3986, 3629, 134, 2051, 128, + 1944, 2050, 1153, 1079, 2049, 1128, 1150, 2048, 2, 2021, + 1213, 668, 4074, 669, 2797, 2571, 3141, 4153, 3099, 1167, + 1168, 1169, 4101, 1172, 1173, 1174, 1175, 1161, 4096, 1178, + 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, + 1189, 1190, 1191, 1192, 1193, 1194, 1024, 1072, 1127, 1073, + 3264, 1039, 1735, 111, 112, 113, 727, 116, 3518, 1214, + 122, 1103, 1022, 191, 1047, 1102, 663, 1154, 1157, 1158, + 711, 128, 1101, 1100, 2827, 2510, 1439, 1460, 724, 725, + 1733, 4121, 1736, 3628, 2353, 1095, 3959, 2924, 1014, 1015, + 1016, 1017, 1090, 3981, 1454, 1028, 3264, 4136, 95, 3431, + 1170, 912, 3430, 4084, 95, 1019, 3262, 3629, 95, 3261, + 1734, 711, 4082, 2352, 2947, 705, 3935, 2762, 2058, 2509, + 3322, 3853, 4135, 1060, 1061, 3852, 1152, 2069, 4083, 2944, + 3568, 1151, 3268, 3569, 1071, 1075, 910, 4081, 95, 128, + 4111, 3863, 705, 4078, 3587, 961, 962, 963, 1071, 1075, + 910, 1430, 3262, 3576, 4025, 4033, 2503, 3862, 702, 86, + 2100, 190, 4058, 3343, 1725, 961, 962, 963, 1841, 2876, + 3193, 3194, 2875, 2396, 2397, 2877, 2961, 2962, 3268, 705, + 2030, 2031, 2798, 86, 1104, 129, 2508, 3192, 2987, 86, + 2578, 2395, 1444, 705, 3628, 4037, 2575, 1765, 172, 1766, + 2971, 1262, 1233, 1450, 1012, 1221, 687, 2841, 705, 1011, + 1222, 2925, 2171, 3951, 1457, 1986, 1458, 1459, 1220, 685, + 1219, 1221, 2888, 1234, 2414, 2413, 1222, 1227, 3300, 3586, + 705, 1099, 2842, 1206, 1207, 2834, 2835, 95, 3680, 705, + 3033, 2881, 3330, 1238, 1239, 3328, 3265, 2569, 3298, 2029, + 2454, 2360, 719, 2033, 169, 2576, 723, 170, 2973, 682, + 2328, 95, 717, 1700, 3304, 1209, 1761, 95, 697, 2932, + 4063, 4041, 1171, 2448, 3905, 4102, 3906, 1196, 2485, 86, + 189, 2957, 88, 692, 2524, 3291, 3964, 4133, 4061, 1097, + 1440, 4041, 3265, 3292, 695, 1960, 4103, 4067, 4068, 1259, + 1454, 1934, 1236, 1237, 2530, 1242, 3213, 3214, 2528, 1202, + 2163, 1261, 1254, 4062, 1429, 2165, 2975, 1260, 1235, 2170, + 2166, 3301, 1228, 2167, 2168, 2169, 3837, 706, 2164, 2172, + 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2572, 3557, + 2573, 3299, 2547, 3556, 2548, 1935, 2549, 1936, 1240, 2550, + 2527, 1177, 2526, 1987, 706, 1176, 1137, 95, 1241, 2531, + 1135, 1064, 672, 2529, 674, 688, 1703, 708, 2488, 707, + 678, 3633, 676, 680, 689, 681, 2127, 675, 2373, 686, + 3553, 1108, 677, 690, 691, 694, 698, 699, 700, 696, + 693, 706, 684, 709, 173, 2537, 2533, 2535, 2536, 2534, + 2538, 2539, 2540, 179, 1107, 706, 3034, 1477, 1108, 1450, + 4075, 1146, 1442, 1145, 1144, 3212, 1143, 1142, 1098, 1141, + 706, 1140, 2447, 1139, 1134, 1845, 3215, 3215, 3098, 3319, + 1147, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1485, + 1487, 1488, 706, 1083, 2358, 2359, 1083, 4154, 1120, 4108, + 1081, 706, 1083, 1156, 3470, 1074, 1068, 1066, 1119, 1119, + 1979, 2461, 1266, 1155, 1266, 1266, 1059, 2976, 2514, 1074, + 1068, 1066, 1839, 2513, 2119, 2108, 2109, 2110, 2111, 2121, + 2112, 2113, 2114, 2126, 2122, 2115, 2116, 2123, 2124, 2125, + 2117, 2118, 2120, 1762, 1975, 3552, 1431, 1164, 1449, 1446, + 1447, 1448, 1453, 1455, 1452, 1138, 1451, 3235, 2926, 1136, + 2956, 2942, 1026, 1501, 1506, 1507, 1445, 1510, 1512, 1513, + 1514, 1515, 1516, 2959, 1519, 1520, 1522, 1522, 164, 1522, 1522, 1527, 1527, 1527, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, @@ -1754,1322 +1754,1001 @@ var yyAct = [...]int{ 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, - 1646, 1647, 1648, 1649, 1650, 1651, 2891, 1255, 3959, 1498, - 1652, 1200, 1654, 1655, 1656, 1657, 1658, 710, 1422, 1423, + 1646, 1647, 1648, 1649, 1650, 1651, 3627, 1255, 1498, 2890, + 1652, 2507, 1654, 1655, 1656, 1657, 1658, 710, 1422, 1423, 1494, 1495, 1496, 1497, 1527, 1527, 1527, 1527, 1527, 1527, - 1508, 2924, 3586, 959, 3517, 3518, 1105, 1438, 703, 1665, + 1508, 3958, 2923, 1946, 1945, 1947, 1948, 1949, 703, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, - 1676, 1677, 1678, 704, 1502, 959, 3267, 3268, 1946, 1945, - 1947, 1948, 1949, 959, 1126, 4067, 89, 1421, 2927, 3271, - 1693, 1511, 4040, 2947, 3321, 4040, 3472, 1523, 94, 1524, - 1525, 1067, 3554, 1449, 1446, 1447, 1448, 1453, 1455, 1452, - 3628, 1451, 3628, 165, 705, 1231, 1137, 1528, 1529, 1218, - 177, 1445, 3415, 2578, 4039, 94, 1690, 4039, 1205, 4066, - 1067, 1208, 3200, 1135, 1866, 2452, 1126, 2946, 1491, 1126, - 2506, 3267, 3268, 1491, 1699, 94, 2577, 2980, 3109, 3108, - 124, 1724, 2833, 1026, 3271, 670, 1171, 1026, 2804, 2806, - 2403, 185, 1491, 1026, 3192, 1488, 1725, 4148, 2602, 1471, - 2144, 1042, 1216, 1964, 1244, 2453, 1217, 3201, 1223, 1224, - 1225, 1226, 2451, 2171, 2145, 1991, 1258, 1125, 1099, 1195, - 1707, 3973, 1149, 119, 1711, 3021, 94, 3549, 1698, 1691, - 1025, 3203, 1263, 1264, 166, 171, 168, 174, 175, 176, - 178, 180, 181, 182, 183, 3484, 2454, 3553, 2526, 3198, - 184, 186, 187, 188, 2993, 1965, 2450, 2042, 3128, 2591, - 1483, 1484, 1486, 1485, 1487, 1488, 1972, 3214, 3215, 1125, - 3000, 1767, 1125, 1865, 3199, 2602, 1709, 1710, 4113, 2136, - 104, 105, 2136, 1199, 2612, 2916, 1459, 665, 2071, 1659, - 1660, 1661, 1662, 1663, 1664, 1138, 120, 1691, 1458, 1459, - 1697, 3677, 2072, 1489, 1490, 2070, 3524, 1013, 3205, 3523, - 3126, 2163, 1136, 1684, 2493, 1875, 2165, 1874, 1864, 1163, - 2170, 2166, 107, 2503, 2167, 2168, 2169, 4105, 2498, 2164, - 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2498, - 2501, 1137, 2983, 2983, 1126, 2142, 1215, 2982, 2982, 1084, - 1230, 1135, 1245, 1961, 3002, 1962, 706, 2805, 1963, 1705, - 3509, 1232, 1858, 1992, 1727, 1037, 2505, 2502, 1694, 4150, - 1842, 1843, 1844, 1201, 3846, 1126, 3213, 1126, 2500, 3583, - 1708, 3584, 3845, 4004, 1929, 1851, 1725, 4156, 3216, 1198, - 1880, 1984, 1881, 2141, 1883, 1885, 1730, 1706, 1889, 1891, - 1893, 1895, 1897, 1870, 3836, 1098, 1911, 1022, 2060, 2062, - 2063, 3941, 3600, 1024, 1266, 1758, 1759, 2127, 4146, 1460, - 3599, 4147, 3531, 4145, 1869, 3012, 3011, 3010, 4005, 3530, - 3004, 1126, 3008, 2061, 3003, 3520, 3001, 1919, 1920, 3244, - 1460, 3006, 3232, 1925, 1926, 2898, 1834, 1125, 1868, 1868, - 3005, 2291, 1126, 1119, 1122, 1123, 3942, 1083, 2897, 1848, - 1849, 1116, 1120, 1847, 1861, 2366, 2367, 2896, 3007, 3009, - 1968, 1954, 1966, 1967, 4157, 1969, 1970, 1971, 1125, 1872, - 1125, 2458, 1115, 1129, 1119, 1129, 1119, 1955, 1131, 1712, - 1131, 1939, 1132, 1130, 1132, 1130, 1481, 1482, 1483, 1484, - 1486, 1485, 1487, 1488, 3868, 3202, 1907, 1952, 1915, 1910, - 1980, 1912, 1941, 1133, 3296, 2119, 2108, 2109, 2110, 2111, - 2121, 2112, 2113, 2114, 2126, 2122, 2115, 2116, 2123, 2124, - 2125, 2117, 2118, 2120, 1125, 1953, 1162, 2583, 2584, 2585, - 1159, 1102, 1101, 961, 962, 963, 1938, 1937, 128, 1927, - 1100, 190, 1921, 1425, 1918, 1125, 1457, 1840, 1458, 1459, - 2291, 1119, 1122, 1123, 2288, 1083, 1917, 1916, 1997, 1116, - 1120, 1951, 1887, 2290, 1460, 129, 1940, 1457, 1460, 1458, - 1459, 1266, 1266, 1704, 711, 1993, 1994, 957, 172, 2019, - 1460, 3514, 711, 2880, 711, 87, 1477, 1761, 87, 1998, - 2474, 2473, 2647, 2472, 2471, 1460, 2005, 2006, 2007, 1464, - 1465, 1466, 1467, 1468, 1469, 1470, 1462, 2608, 2018, 1460, + 1676, 1677, 1678, 704, 1449, 1446, 1447, 1448, 1453, 1455, + 1452, 1421, 1451, 959, 1105, 1502, 3266, 3267, 4039, 959, + 1693, 1511, 1445, 959, 2946, 1523, 3199, 1524, 1525, 3270, + 94, 1067, 1217, 3585, 1223, 1224, 1225, 1226, 4039, 1438, + 89, 3516, 3517, 1528, 1529, 1067, 3414, 2577, 1218, 1208, + 4038, 1690, 2451, 3471, 94, 1965, 1205, 1838, 1263, 1264, + 94, 1491, 3266, 3267, 1200, 1126, 165, 3627, 2945, 1491, + 4038, 3200, 1837, 177, 1699, 3270, 1126, 1250, 2576, 1252, + 2979, 1724, 1866, 1026, 1976, 1835, 1212, 1026, 662, 1126, + 1126, 4076, 2452, 1026, 1094, 3202, 4066, 1096, 705, 2450, + 2802, 2804, 2970, 3947, 1231, 2969, 2402, 1163, 3507, 1492, + 1493, 3489, 2872, 3197, 185, 1707, 1691, 1249, 1251, 1711, + 4147, 2837, 2505, 2774, 1126, 1025, 2103, 1753, 1653, 1211, + 3107, 3213, 3214, 2453, 3106, 2832, 124, 670, 3198, 1491, + 4065, 2360, 1488, 2449, 3191, 2601, 3320, 2992, 1471, 3972, + 94, 1725, 1042, 119, 1149, 2590, 1258, 166, 171, 168, + 174, 175, 176, 178, 180, 181, 182, 183, 1125, 1216, + 3548, 1244, 3204, 184, 186, 187, 188, 1709, 1710, 1125, + 3483, 104, 105, 2525, 1691, 1659, 1660, 1661, 1662, 1663, + 1664, 1865, 1125, 1125, 1991, 2042, 1099, 1964, 1091, 1119, + 1122, 1123, 1697, 1083, 1972, 1093, 1092, 1116, 1120, 3126, + 1684, 2999, 1483, 1484, 1486, 1485, 1487, 1488, 2144, 1126, + 3124, 1099, 1195, 107, 1247, 1767, 120, 1125, 1248, 3019, + 2601, 2136, 2145, 1119, 1122, 1123, 2915, 1083, 1253, 4112, + 3212, 1116, 1120, 2136, 2982, 2610, 2982, 1126, 1459, 2981, + 2071, 2981, 3215, 1858, 1097, 3676, 1460, 1705, 1842, 1843, + 1844, 1460, 1115, 1246, 2072, 1489, 1490, 2070, 3523, 2803, + 1968, 1126, 1966, 1967, 3522, 1969, 1970, 1971, 4104, 1708, + 1706, 1727, 1458, 1459, 1851, 2492, 1199, 1730, 1929, 1875, + 1984, 1868, 1868, 1024, 1694, 3001, 1880, 1911, 1881, 1870, + 1883, 1885, 1022, 1874, 1889, 1891, 1893, 1895, 1897, 1230, + 706, 1864, 2497, 1215, 1266, 2502, 1758, 1759, 2504, 1245, + 1232, 2500, 1125, 2497, 1162, 1919, 1920, 1869, 1159, 1201, + 1137, 1925, 1926, 1460, 2358, 2359, 1712, 1135, 3508, 1834, + 1460, 4145, 1992, 1037, 4146, 4149, 4144, 1961, 1954, 1962, + 1125, 2501, 1963, 1848, 1849, 1129, 1119, 1460, 4003, 1861, + 1131, 1847, 2499, 2142, 1132, 1130, 3011, 3010, 3009, 3201, + 3940, 3003, 3845, 3007, 1125, 3002, 1460, 3000, 3844, 1129, + 1119, 4155, 3005, 1098, 1131, 1133, 3835, 1725, 1132, 1130, + 1872, 3004, 1198, 1457, 2141, 1458, 1459, 1915, 1457, 2637, + 1458, 1459, 3021, 4004, 1840, 1477, 3599, 1952, 1098, 3006, + 3008, 1980, 1953, 3598, 1460, 3941, 3530, 1907, 4117, 1725, + 1910, 2290, 1912, 1941, 3529, 4115, 1725, 3519, 1477, 1478, + 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1485, 1487, 1488, + 3243, 711, 1102, 1725, 2582, 2583, 2584, 3295, 128, 1101, + 1100, 190, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, + 1485, 1487, 1488, 2290, 2060, 2062, 2063, 2287, 4156, 1997, + 1457, 1951, 1458, 1459, 3231, 129, 2289, 1457, 2897, 1458, + 1459, 1266, 1266, 2896, 2895, 1993, 1994, 1940, 172, 2061, + 957, 2457, 1955, 2019, 1457, 87, 1458, 1459, 87, 1998, + 4106, 961, 962, 963, 1939, 1425, 2005, 2006, 2007, 1477, + 3582, 2991, 3583, 1457, 1938, 1458, 1459, 1460, 2018, 1481, + 1482, 1483, 1484, 1486, 1485, 1487, 1488, 42, 1937, 2606, + 42, 1927, 1921, 1478, 1479, 1480, 1481, 1482, 1483, 1484, + 1486, 1485, 1487, 1488, 169, 1918, 1917, 170, 1916, 1887, + 1477, 1457, 1704, 1458, 1459, 2098, 2098, 3513, 711, 1761, + 2096, 2096, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1462, + 189, 4105, 2649, 2099, 1478, 1479, 1480, 1481, 1482, 1483, + 1484, 1486, 1485, 1487, 1488, 2879, 711, 1995, 1460, 2473, + 2472, 3967, 2064, 1738, 1999, 3966, 2001, 2002, 2003, 2004, + 110, 101, 2605, 2008, 1477, 1690, 110, 1473, 2127, 1474, + 3205, 109, 102, 108, 3209, 2020, 1477, 109, 2589, 108, + 2182, 3208, 103, 1475, 1489, 1490, 1472, 3944, 1478, 1479, + 1480, 1481, 1482, 1483, 1484, 1486, 1485, 1487, 1488, 1739, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1485, 1487, - 1488, 4106, 42, 2824, 4133, 42, 2470, 2469, 4093, 1725, - 1456, 1725, 2639, 1738, 169, 2824, 4033, 170, 1478, 1479, - 1480, 1481, 1482, 1483, 1484, 1486, 1485, 1487, 1488, 3968, - 2098, 2098, 2099, 4118, 1725, 2824, 4012, 103, 1460, 3967, - 189, 3945, 1477, 2096, 2096, 1473, 1725, 1474, 1479, 1480, - 1481, 1482, 1483, 1484, 1486, 1485, 1487, 1488, 2064, 1739, - 2607, 1475, 1489, 1490, 1472, 3944, 1478, 1479, 1480, 1481, - 1482, 1483, 1484, 1486, 1485, 1487, 1488, 1477, 3943, 2992, - 1690, 1457, 101, 1458, 1459, 1457, 3841, 1458, 1459, 103, - 3023, 2182, 3825, 102, 2824, 4008, 1725, 1457, 3824, 1458, - 1459, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1485, - 1487, 1488, 1457, 3676, 1458, 1459, 3206, 3926, 1725, 1725, - 3210, 3674, 2649, 4116, 1725, 3961, 1457, 3209, 1458, 1459, - 3596, 1995, 1456, 1725, 3567, 3958, 3849, 1725, 1999, 1689, - 2001, 2002, 2003, 2004, 2043, 1688, 85, 2008, 1725, 85, - 2068, 2824, 3837, 1691, 173, 2026, 2027, 1477, 1687, 2020, - 1460, 3211, 3528, 179, 3513, 1460, 3207, 3306, 1477, 2127, - 2075, 3208, 3567, 1725, 3483, 1457, 2073, 1458, 1459, 2651, - 1460, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1485, - 1487, 1488, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, - 1485, 1487, 1488, 2302, 2129, 2131, 2301, 3303, 2074, 3235, + 1488, 2471, 2470, 2647, 1457, 3210, 1458, 1459, 2469, 2468, + 3206, 2823, 4132, 1456, 1725, 3207, 3943, 1725, 1460, 85, + 1691, 2043, 85, 4047, 1725, 4092, 1725, 1456, 1725, 2068, + 3942, 1725, 2823, 4032, 173, 2026, 2027, 1725, 2823, 4011, + 1460, 101, 3840, 179, 1460, 2823, 4007, 1725, 103, 3824, + 2075, 3823, 102, 2131, 3675, 2073, 2119, 2108, 2109, 2110, + 2111, 2121, 2112, 2113, 2114, 2126, 2122, 2115, 2116, 2123, + 2124, 2125, 2117, 2118, 2120, 1457, 3673, 1458, 1459, 1460, + 3595, 2102, 2300, 3925, 1725, 3566, 3957, 3960, 2074, 2299, 2076, 2077, 2078, 2079, 2080, 2081, 2083, 2085, 2086, 2087, - 2088, 2089, 2090, 1502, 2102, 2300, 1477, 3234, 2590, 1460, - 2146, 2147, 2148, 2149, 2907, 1460, 2824, 3565, 2289, 2498, - 1725, 2137, 2894, 2287, 2160, 4048, 1725, 3873, 2181, 1686, - 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1486, 1485, 1487, - 1488, 1204, 1679, 1210, 2561, 4046, 1725, 2119, 2108, 2109, - 2110, 2111, 2121, 2112, 2113, 2114, 2126, 2122, 2115, 2116, - 2123, 2124, 2125, 2117, 2118, 2120, 2305, 2306, 164, 2382, - 101, 3488, 1725, 2196, 2560, 1460, 2520, 1457, 2821, 1458, - 1459, 102, 1457, 2302, 1458, 1459, 2371, 2731, 1725, 3225, - 3224, 104, 105, 103, 4044, 1725, 110, 1457, 2519, 1458, - 1459, 1725, 1460, 1433, 2356, 2300, 2384, 109, 110, 108, - 2336, 2412, 104, 105, 3222, 3223, 3220, 3221, 103, 109, - 2194, 108, 3220, 3219, 2067, 2304, 2848, 1725, 2307, 2308, - 2205, 2577, 2956, 1830, 2937, 3872, 1725, 1460, 2930, 2931, - 3829, 1088, 2824, 2823, 2869, 2022, 1457, 2869, 1458, 1459, - 1988, 2604, 1457, 3828, 1458, 1459, 2421, 2422, 2423, 2424, - 3919, 1725, 2416, 1950, 2417, 2418, 2419, 2420, 2406, 1942, - 1038, 2407, 1460, 1932, 1088, 2323, 2335, 1725, 2840, 2388, - 2427, 2428, 2429, 2430, 1928, 2346, 1460, 3917, 1725, 1725, - 3575, 2347, 2604, 1725, 2101, 1725, 2341, 1924, 2342, 2349, - 2278, 2279, 2280, 2281, 2282, 2441, 1923, 2870, 2410, 1460, - 2870, 1922, 1457, 1460, 1458, 1459, 2487, 2872, 2369, 1460, - 2577, 2447, 3914, 1725, 1830, 1829, 3187, 2393, 2394, 2392, - 1773, 1772, 2934, 1072, 1740, 1256, 2577, 2409, 2408, 1457, - 2912, 1458, 1459, 1460, 86, 44, 45, 88, 3157, 2840, - 2848, 1460, 2847, 2411, 1073, 2484, 2325, 3503, 2457, 3483, - 2499, 2600, 2205, 3338, 92, 1456, 3485, 4000, 48, 76, - 77, 2599, 74, 78, 1457, 3972, 1458, 1459, 109, 2824, - 2442, 75, 2431, 2433, 2434, 2438, 1460, 2848, 3436, 3222, - 2460, 2456, 3131, 2492, 3896, 1725, 2495, 2395, 2496, 4107, - 2468, 1460, 2604, 2731, 3457, 1725, 165, 2848, 2512, 1457, - 62, 1458, 1459, 177, 2636, 2442, 2491, 2494, 2498, 2635, - 2490, 3483, 95, 1457, 2498, 1458, 1459, 2481, 1127, 1725, - 2364, 1729, 1128, 2326, 2516, 2513, 3450, 1725, 2517, 2518, - 2101, 2044, 1868, 2028, 1460, 1974, 1457, 1456, 1458, 1459, - 1457, 1460, 1458, 1459, 185, 1760, 1457, 3532, 1458, 1459, - 1110, 1109, 1726, 1728, 1027, 95, 1460, 1903, 83, 2582, - 4128, 3447, 1725, 1460, 2598, 4072, 4015, 2523, 3860, 1732, - 1457, 3826, 1458, 1459, 1460, 3247, 3445, 1725, 1457, 3688, - 1458, 1459, 3548, 1512, 1460, 1512, 3545, 166, 171, 168, - 174, 175, 176, 178, 180, 181, 182, 183, 3533, 3534, - 3535, 2594, 3976, 184, 186, 187, 188, 3526, 1904, 1905, - 1906, 3349, 4126, 1457, 3348, 1458, 1459, 1832, 2554, 3407, - 1725, 2440, 1460, 2302, 3294, 2904, 2301, 1757, 1457, 1460, - 1458, 1459, 95, 3249, 1460, 3245, 2938, 2437, 2432, 2426, - 2903, 3405, 1725, 2425, 1957, 2597, 1774, 1200, 3401, 1725, - 1460, 1863, 51, 54, 57, 56, 59, 1859, 73, 3398, - 1725, 82, 79, 1460, 1828, 121, 3495, 3496, 2569, 3396, - 1725, 1457, 1460, 1458, 1459, 3298, 3861, 2455, 1457, 2339, - 1458, 1459, 4100, 2575, 3536, 61, 91, 90, 2904, 2024, - 71, 72, 58, 1457, 3980, 1458, 1459, 1460, 80, 81, - 1457, 3901, 1458, 1459, 3498, 3241, 3240, 2586, 3956, 3239, - 1460, 1457, 3157, 1458, 1459, 3833, 2917, 2555, 2068, 3394, - 1725, 1457, 1460, 1458, 1459, 3179, 3654, 3862, 3653, 1913, - 3180, 3537, 3538, 3539, 3177, 3392, 1725, 2588, 3501, 3178, - 667, 63, 64, 3500, 65, 66, 67, 68, 3390, 1725, - 3176, 2025, 3181, 1460, 2857, 2858, 3175, 3388, 1725, 1457, - 2355, 1458, 1459, 1737, 1958, 2611, 1457, 1460, 1458, 1459, - 2345, 1457, 3489, 1458, 1459, 2587, 3652, 2589, 1460, 1899, - 3136, 1985, 3386, 1725, 3135, 1460, 2592, 1457, 2593, 1458, - 1459, 1460, 1040, 2595, 3940, 3384, 1725, 1996, 3667, 1460, - 1457, 2775, 1458, 1459, 2000, 60, 1460, 3382, 1725, 1457, - 3669, 1458, 1459, 1460, 728, 2011, 2012, 2013, 2014, 2015, - 2016, 2017, 3476, 1460, 3144, 2645, 1900, 1901, 1902, 1460, - 3475, 3147, 3149, 2807, 1457, 1043, 1458, 1459, 3380, 1725, - 3150, 1041, 1973, 1044, 3479, 2098, 2810, 1457, 1460, 1458, - 1459, 1026, 3378, 1725, 1010, 3218, 2887, 2908, 2096, 1457, - 1166, 1458, 1459, 3376, 1725, 1165, 2144, 2563, 2564, 1460, - 3374, 1725, 2566, 3314, 2845, 2846, 3372, 1725, 2808, 1460, - 2145, 2567, 2903, 2382, 3370, 1725, 1026, 2865, 1742, 2986, - 1457, 3452, 1458, 1459, 101, 89, 2618, 1460, 3368, 1725, - 2811, 1460, 2813, 1424, 1457, 102, 1458, 1459, 3354, 1725, - 2944, 42, 2067, 2633, 3448, 1457, 2825, 1458, 1459, 2844, - 2862, 129, 1457, 2864, 1458, 1459, 3481, 1460, 1457, 103, - 1458, 1459, 4142, 3336, 1725, 1460, 1457, 101, 1458, 1459, - 1460, 2366, 2367, 1457, 103, 1458, 1459, 3237, 102, 2558, - 1457, 4051, 1458, 1459, 1741, 1697, 3957, 2834, 2798, 3856, - 1457, 3217, 1458, 1459, 2796, 1725, 1457, 2861, 1458, 1459, - 2350, 2547, 2863, 1051, 1052, 2546, 2545, 2890, 2892, 2818, - 2544, 3134, 2794, 1725, 1460, 1457, 3413, 1458, 1459, 3133, - 3459, 2883, 2543, 1691, 2837, 2542, 2581, 2867, 2822, 108, - 2942, 1460, 3925, 3924, 3904, 94, 1457, 1460, 1458, 1459, - 3675, 2047, 2769, 1725, 1460, 3673, 1457, 2871, 1458, 1459, - 2746, 1725, 2874, 1460, 109, 3409, 2881, 2447, 3672, 1460, - 3665, 3664, 2884, 1460, 1457, 3546, 1458, 1459, 1457, 1460, - 1458, 1459, 2953, 1460, 2139, 110, 3469, 2895, 1460, 2140, - 3638, 3480, 3478, 3250, 2482, 2906, 109, 1460, 108, 1846, - 2909, 2910, 1050, 1460, 1457, 2905, 1458, 1459, 2840, 2738, - 1725, 2821, 1457, 110, 1458, 1459, 2913, 1457, 2914, 1458, - 1459, 2918, 2919, 2920, 109, 2200, 2729, 1725, 3037, 1460, - 2637, 2950, 2727, 1725, 4130, 4129, 1851, 2337, 1754, 2714, - 1725, 4130, 1746, 4129, 2996, 2997, 1460, 3946, 2712, 1725, - 3512, 70, 2939, 2940, 2710, 1725, 3, 97, 2708, 1725, - 2929, 1457, 1460, 1458, 1459, 3550, 2949, 1, 2706, 1725, - 1460, 114, 115, 2704, 1725, 1460, 1018, 1427, 1457, 1460, - 1458, 1459, 2702, 1725, 1457, 1460, 1458, 1459, 2700, 1725, - 1460, 1457, 1426, 1458, 1459, 2994, 1460, 2975, 3013, 3516, - 1457, 4061, 1458, 1459, 2978, 2284, 1457, 683, 1458, 1459, - 1457, 1460, 1458, 1459, 2698, 1725, 1457, 2327, 1458, 1459, - 1457, 2041, 1458, 1459, 10, 1457, 2039, 1458, 1459, 9, - 2040, 2696, 1725, 8, 1457, 2317, 1458, 1459, 1695, 4101, - 1457, 4057, 1458, 1459, 4058, 1943, 2951, 2694, 1725, 3014, - 3017, 1933, 3578, 1726, 2324, 2692, 1725, 2252, 3857, 3253, - 2690, 1725, 2488, 3544, 2688, 1725, 1457, 2445, 1458, 1459, - 2686, 1725, 1118, 154, 2404, 2684, 1725, 2405, 4028, 118, - 1076, 2682, 1725, 1457, 117, 1458, 1459, 1121, 1229, 2348, - 2483, 3568, 2888, 2413, 1779, 1460, 2995, 2899, 3039, 1457, - 1460, 1458, 1459, 1777, 1778, 3095, 1776, 1457, 2984, 1458, - 1459, 2985, 1457, 1781, 1458, 1459, 1457, 1780, 1458, 1459, - 3322, 1460, 1457, 2638, 1458, 1459, 3414, 1457, 2032, 1458, - 1459, 718, 1460, 1457, 110, 1458, 1459, 2860, 2998, 712, - 1460, 192, 1768, 1747, 3428, 109, 3015, 108, 1457, 3102, - 1458, 1459, 1160, 3104, 673, 2368, 103, 3226, 3113, 2521, - 679, 1509, 2382, 2372, 2023, 2375, 3132, 1460, 2047, 3030, - 2289, 2875, 2289, 1070, 1062, 2287, 3075, 2287, 1460, 2338, - 2680, 1725, 2812, 1069, 3164, 3346, 87, 3834, 3165, 2382, - 2382, 2382, 2382, 2382, 3473, 2459, 3016, 3143, 3145, 2384, - 3085, 3086, 3087, 3088, 3089, 2827, 2675, 1725, 3148, 2382, - 3141, 3103, 2382, 3105, 3939, 3169, 3112, 2671, 1725, 3666, - 3113, 4013, 3186, 1029, 1460, 3345, 2384, 2384, 2384, 2384, - 2384, 1460, 1457, 1984, 1458, 1459, 2885, 1457, 1743, 1458, - 1459, 1460, 3435, 3130, 3124, 2610, 2384, 2134, 1499, 2384, - 2381, 3139, 2669, 1725, 3633, 2059, 1460, 3137, 1457, 741, - 1458, 1459, 740, 2662, 1725, 738, 3151, 3152, 2814, 1457, - 1460, 1458, 1459, 2841, 1463, 947, 3270, 1457, 2802, 1458, - 1459, 1755, 3168, 1031, 3171, 3172, 3278, 3174, 3170, 2852, - 1460, 3173, 3182, 104, 105, 2850, 1030, 3190, 3188, 2849, - 1460, 3189, 2556, 2389, 1457, 1460, 1458, 1459, 3196, 3342, - 3125, 3127, 3129, 1460, 3497, 1457, 3340, 1458, 1459, 1460, - 3493, 3229, 4053, 3227, 3228, 2383, 2792, 3077, 2379, 3079, - 2820, 3138, 898, 897, 1460, 750, 742, 732, 1460, 960, - 896, 2660, 1725, 895, 3280, 3090, 3091, 3092, 3093, 1460, - 3230, 3231, 3281, 3282, 3272, 2791, 3279, 3154, 3251, 2447, - 3283, 1457, 2959, 1458, 1459, 3295, 2047, 3289, 1457, 1460, - 1458, 1459, 2961, 2533, 3160, 2787, 2886, 3291, 1457, 3160, - 1458, 1459, 1441, 2552, 2553, 2786, 3310, 2557, 1714, 1717, - 2785, 3307, 3309, 1457, 1089, 1458, 1459, 3317, 2784, 2562, - 1460, 3319, 3963, 2580, 2783, 1460, 2565, 1457, 3343, 1458, - 1459, 1713, 3324, 3325, 3327, 3326, 3273, 3970, 3328, 2782, - 3330, 3261, 3332, 2773, 3562, 3242, 2935, 1457, 2475, 1458, - 1459, 69, 2568, 46, 2772, 3934, 4001, 1457, 890, 1458, - 1459, 887, 1457, 3635, 1458, 1459, 3636, 1512, 3637, 3098, - 1457, 1512, 1458, 1459, 2771, 3099, 1457, 3983, 1458, 1459, - 3984, 886, 3985, 2189, 2596, 3252, 1437, 3460, 2601, 3462, - 1434, 1457, 4074, 1458, 1459, 1457, 2034, 1458, 1459, 96, - 3430, 36, 35, 34, 33, 2770, 1457, 3434, 1458, 1459, - 2767, 2605, 32, 2606, 26, 25, 1460, 24, 3318, 2614, - 23, 22, 29, 2616, 2617, 19, 1457, 21, 1458, 1459, - 20, 18, 2623, 2624, 2625, 2626, 2627, 2628, 2629, 2630, - 2631, 2632, 3264, 2634, 4096, 3163, 4141, 123, 2382, 55, - 52, 3461, 50, 3463, 3465, 131, 130, 1457, 53, 1458, - 1459, 3510, 1457, 3470, 1458, 1459, 2640, 2641, 2642, 2643, - 2644, 49, 2646, 1460, 3477, 1203, 2648, 47, 31, 3482, - 2653, 2654, 30, 2655, 17, 2384, 2658, 16, 2659, 2661, - 2663, 2664, 2665, 2666, 2667, 2668, 2670, 2672, 2673, 2674, - 2676, 2762, 2678, 2679, 2681, 2683, 2685, 2687, 2689, 2691, + 2088, 2089, 2090, 4045, 1725, 2298, 2204, 1725, 3872, 2146, + 2147, 2148, 2149, 1460, 1502, 3848, 1725, 3871, 2288, 2823, + 3836, 2286, 1689, 2160, 2181, 4043, 1725, 3482, 1688, 3918, + 1725, 3828, 2137, 1478, 1479, 1480, 1481, 1482, 1483, 1484, + 1486, 1485, 1487, 1488, 1479, 1480, 1481, 1482, 1483, 1484, + 1486, 1485, 1487, 1488, 1687, 1457, 3527, 1458, 1459, 3566, + 1725, 2823, 3564, 103, 3916, 1725, 1456, 3512, 164, 2381, + 2497, 1725, 2130, 2196, 3305, 1460, 3302, 1457, 3234, 1458, + 1459, 1457, 2300, 1458, 1459, 3487, 1725, 1460, 3233, 2370, + 2906, 2297, 104, 105, 2303, 2304, 2729, 1725, 3913, 1725, + 3827, 2383, 3224, 3223, 3574, 2298, 3221, 3222, 2411, 3219, + 3220, 2933, 1460, 104, 105, 2893, 1457, 1460, 1458, 1459, + 3219, 3218, 1725, 1460, 2067, 2345, 1686, 1460, 2847, 1725, + 2576, 2955, 1460, 1830, 2936, 2929, 2930, 2911, 2333, 2645, + 1679, 1088, 2823, 2822, 2101, 1725, 2410, 729, 2560, 2820, + 1457, 1460, 1458, 1459, 2559, 2519, 2420, 2421, 2422, 2423, + 3895, 1725, 2406, 2415, 103, 2416, 2417, 2418, 2419, 2518, + 2405, 1038, 3456, 1725, 1088, 1460, 2355, 2334, 2022, 1988, + 1950, 2426, 2427, 2428, 2429, 2387, 1942, 1932, 1460, 1928, + 1924, 2346, 2321, 1460, 2339, 3337, 2340, 3449, 1725, 2348, + 2440, 1923, 3446, 1725, 2839, 1922, 1740, 2409, 3444, 1725, + 2846, 1460, 1457, 1725, 1458, 1459, 2486, 3406, 1725, 1460, + 2446, 1256, 2818, 2368, 1457, 3186, 1458, 1459, 2839, 2392, + 2393, 1460, 2391, 1830, 1829, 2576, 3404, 1725, 1460, 2408, + 2407, 1072, 3156, 1073, 1773, 1772, 2483, 3484, 3999, 1457, + 2498, 1458, 1459, 3482, 1457, 3971, 1458, 1459, 2823, 2456, + 1457, 1725, 1458, 1459, 1457, 2847, 1458, 1459, 2868, 1457, + 2847, 1458, 1459, 3400, 1725, 1128, 2847, 109, 3397, 1725, + 1460, 3435, 2430, 2432, 2433, 1868, 2441, 2437, 1457, 2491, + 1458, 1459, 2494, 2459, 2495, 2455, 3395, 1725, 2467, 2511, + 3482, 1460, 3221, 3129, 3393, 1725, 165, 2394, 2497, 2729, + 2634, 1460, 1457, 177, 1458, 1459, 3391, 1725, 1127, 2490, + 2493, 2441, 2489, 3389, 1725, 1457, 2633, 1458, 1459, 2497, + 1457, 2869, 1458, 1459, 2512, 2515, 1460, 3531, 2480, 2516, + 2517, 2871, 1460, 2363, 1729, 2324, 1456, 2101, 1457, 1460, + 1458, 1459, 2044, 2028, 185, 1974, 1457, 1460, 1458, 1459, + 2868, 1460, 1726, 1728, 1760, 3387, 1725, 1460, 1457, 2581, + 1458, 1459, 1460, 1903, 1110, 1457, 1460, 1458, 1459, 1109, + 95, 1460, 4071, 2522, 4014, 1460, 3385, 1725, 3532, 3533, + 3534, 3859, 1460, 1512, 1027, 1512, 3867, 166, 171, 168, + 174, 175, 176, 178, 180, 181, 182, 183, 1732, 3825, + 3687, 2593, 3547, 184, 186, 187, 188, 1457, 1460, 1458, + 1459, 3383, 1725, 2869, 1904, 1905, 1906, 3381, 1725, 2553, + 3544, 3525, 2300, 2576, 3379, 1725, 3348, 3347, 1457, 2299, + 1458, 1459, 3377, 1725, 1832, 3246, 3375, 1725, 1457, 1460, + 1458, 1459, 3373, 1725, 1460, 2596, 2903, 3371, 1725, 2439, + 1460, 3369, 1725, 3293, 3248, 1200, 3367, 1725, 3244, 2902, + 3353, 1725, 95, 1457, 2937, 1458, 1459, 3335, 1725, 1457, + 2568, 1458, 1459, 1460, 2436, 2431, 1457, 1460, 1458, 1459, + 2425, 1460, 2424, 2599, 1457, 2574, 1458, 1459, 1457, 1957, + 1458, 1459, 3535, 2598, 1457, 1863, 1458, 1459, 1859, 1457, + 1828, 1458, 1459, 1457, 121, 1458, 1459, 2903, 1457, 2585, + 1458, 1459, 1457, 3297, 1458, 1459, 3860, 2068, 2454, 1457, + 1460, 1458, 1459, 2337, 2794, 1725, 1460, 3494, 3495, 2792, + 1725, 4127, 1460, 2024, 4125, 2767, 1725, 2587, 1460, 3536, + 3537, 3538, 4099, 3979, 1460, 1457, 3900, 1458, 1459, 3497, + 1460, 2365, 2366, 3240, 1460, 2597, 3239, 3238, 2744, 1725, + 3156, 2916, 2736, 1725, 1460, 2554, 2727, 1725, 3178, 1460, + 3500, 667, 2609, 3179, 3499, 2586, 1457, 2588, 1458, 1459, + 3175, 1457, 1460, 1458, 1459, 1899, 2591, 1457, 2592, 1458, + 1459, 3176, 3174, 2562, 2563, 2025, 3177, 3975, 2565, 2773, + 3861, 3653, 1460, 3652, 2594, 2725, 1725, 2566, 2354, 2343, + 1457, 1460, 1458, 1459, 1457, 1040, 1458, 1459, 1457, 1737, + 1458, 1459, 2643, 2712, 1725, 1460, 3488, 3134, 3133, 2710, + 1725, 2805, 1900, 1901, 1902, 2708, 1725, 3939, 2098, 2706, + 1725, 3666, 3668, 2096, 1460, 728, 3478, 3143, 1460, 3502, + 1026, 3651, 3146, 3148, 3451, 2808, 1973, 1457, 1460, 1458, + 1459, 3149, 3475, 1457, 1041, 1458, 1459, 2704, 1725, 1457, + 3474, 1458, 1459, 2844, 2845, 1457, 1010, 1458, 1459, 3217, + 2806, 1457, 2381, 1458, 1459, 1026, 2864, 1457, 3955, 1458, + 1459, 1457, 2886, 1458, 1459, 1166, 2702, 1725, 2809, 1043, + 2811, 1457, 2907, 1458, 1459, 42, 1457, 1044, 1458, 1459, + 2700, 1725, 2067, 2843, 2861, 2824, 1165, 2863, 1460, 1457, + 3313, 1458, 1459, 1460, 3180, 101, 2856, 2857, 1460, 2698, + 1725, 2144, 1460, 2696, 1725, 2902, 102, 2985, 1460, 1457, + 1424, 1458, 1459, 2694, 1725, 2145, 101, 1460, 1457, 2943, + 1458, 1459, 3480, 103, 129, 1697, 2796, 102, 2833, 4141, + 1460, 103, 1457, 3236, 1458, 1459, 2852, 2855, 2856, 2857, + 2853, 2862, 2854, 2858, 2365, 2366, 2889, 2891, 2816, 1691, + 2557, 1457, 4050, 1458, 1459, 1457, 3956, 1458, 1459, 3855, + 3216, 2860, 2882, 2836, 1460, 1457, 2821, 1458, 1459, 2941, + 2349, 2546, 2866, 2692, 1725, 1460, 1051, 1052, 2690, 1725, + 1460, 3132, 2545, 2688, 1725, 1460, 2870, 2686, 1725, 3131, + 3458, 2873, 2544, 2684, 1725, 2446, 2580, 1460, 2543, 2880, + 2883, 1460, 2682, 1725, 2542, 1460, 108, 2541, 2952, 3924, + 1460, 110, 2905, 3923, 2139, 2680, 1725, 2908, 2909, 2140, + 2894, 1460, 109, 109, 108, 1457, 3903, 1458, 1459, 3674, + 1457, 1460, 1458, 1459, 3672, 1457, 2904, 1458, 1459, 1457, + 1742, 1458, 1459, 3671, 3664, 1457, 2912, 1458, 1459, 2913, + 3832, 2917, 2918, 2919, 1457, 2200, 1458, 1459, 2949, 3545, + 2678, 1725, 3479, 1460, 1851, 2673, 1725, 1457, 1460, 1458, + 1459, 3549, 2995, 2996, 1460, 3477, 3249, 2938, 2939, 2481, + 3663, 1460, 2669, 1725, 1846, 3468, 2667, 1725, 2928, 1460, + 2660, 1725, 1050, 2839, 2948, 2658, 1725, 110, 4129, 4128, + 4129, 1457, 1460, 1458, 1459, 3637, 1741, 1460, 109, 2820, + 3035, 1460, 1457, 2635, 1458, 1459, 3447, 1457, 2335, 1458, + 1459, 1460, 1457, 4128, 1458, 1459, 2974, 3012, 2993, 1754, + 1746, 1460, 114, 115, 1457, 2283, 1458, 1459, 1457, 2977, + 1458, 1459, 1457, 3945, 1458, 1459, 3511, 1457, 3412, 1458, + 1459, 110, 2041, 3408, 2039, 10, 3, 9, 1457, 3345, + 1458, 1459, 109, 97, 108, 2315, 3344, 1460, 1457, 1, + 1458, 1459, 1460, 103, 3341, 2040, 1018, 1460, 8, 3013, + 1427, 1426, 3515, 1726, 2322, 4060, 2950, 3339, 683, 2325, + 1695, 1692, 4100, 2898, 1460, 4056, 2790, 4057, 1943, 1933, + 1457, 3577, 1458, 1459, 2251, 1457, 2789, 1458, 1459, 3856, + 3252, 1457, 2487, 1458, 1459, 3543, 2785, 2444, 1457, 2347, + 1458, 1459, 1118, 154, 2403, 2994, 1457, 3037, 1458, 1459, + 2404, 4027, 118, 3093, 1076, 117, 1121, 2983, 1229, 1457, + 2984, 1458, 1459, 2482, 1457, 3567, 1458, 1459, 1457, 2887, + 1458, 1459, 2784, 2412, 1460, 1779, 1777, 2783, 1457, 1778, + 1458, 1459, 2782, 1460, 1776, 1781, 1780, 2997, 1457, 3321, + 1458, 1459, 2636, 3413, 2032, 3014, 718, 3100, 2859, 2781, + 712, 192, 1768, 1747, 3427, 3102, 3111, 1160, 673, 1460, + 3225, 2381, 2520, 679, 1460, 1509, 3028, 2023, 2288, 3130, + 2288, 2286, 3073, 2286, 1457, 2874, 1458, 1459, 1070, 1457, + 1460, 1458, 1459, 3163, 1457, 87, 1458, 1459, 2381, 2381, + 2381, 2381, 2381, 2383, 1460, 2458, 3083, 3084, 3085, 3086, + 3087, 1457, 1062, 1458, 1459, 2336, 2810, 1069, 2381, 2780, + 3833, 2381, 3101, 3164, 3103, 3472, 3142, 1029, 2771, 3111, + 2383, 2383, 2383, 2383, 2383, 3168, 1460, 3144, 2826, 3147, + 3185, 1984, 3140, 3938, 3665, 4012, 1460, 2884, 1743, 3434, + 2383, 2608, 3110, 2383, 2770, 3122, 2134, 3128, 1499, 2769, + 3138, 3123, 3125, 3127, 2380, 3632, 1460, 2059, 741, 3137, + 3135, 1457, 1460, 1458, 1459, 2768, 1460, 3150, 3151, 740, + 1457, 738, 1458, 1459, 2812, 3269, 2840, 1463, 947, 2765, + 2800, 1755, 1030, 3169, 1460, 3277, 3172, 3167, 3170, 3171, + 1031, 3173, 3181, 104, 105, 1460, 1457, 3187, 1458, 1459, + 3188, 1457, 3189, 1458, 1459, 2851, 2849, 2848, 2555, 3195, + 2388, 2760, 3496, 1460, 3492, 4052, 2382, 1457, 3136, 1458, + 1459, 2753, 3226, 2378, 3228, 2819, 3227, 898, 897, 750, + 742, 1457, 1460, 1458, 1459, 732, 960, 3229, 3230, 896, + 1460, 2752, 895, 3279, 1460, 3280, 2958, 2751, 3250, 3294, + 3281, 2750, 2960, 2885, 3153, 3278, 3290, 2446, 3271, 3282, + 1441, 1460, 1714, 1457, 3288, 1458, 1459, 1717, 2344, 2749, + 1460, 1089, 3318, 1457, 3962, 1458, 1459, 2579, 3342, 1713, + 2748, 3969, 3260, 3561, 3159, 3241, 2934, 2474, 69, 3159, + 3309, 3308, 3306, 1457, 46, 1458, 1459, 1460, 2747, 1457, + 3316, 1458, 1459, 1457, 1460, 1458, 1459, 3933, 3326, 4000, + 890, 887, 3323, 3324, 3272, 3325, 3634, 2746, 3327, 3635, + 3329, 1457, 3331, 1458, 1459, 2745, 3636, 3096, 3097, 2739, + 3982, 3983, 1457, 886, 1458, 1459, 3984, 2852, 2855, 2856, + 2857, 2853, 2189, 2854, 2858, 1512, 2738, 3494, 3495, 1512, + 1457, 1437, 1458, 1459, 1434, 2737, 4073, 2034, 96, 36, + 35, 34, 33, 32, 2595, 3459, 26, 3461, 2600, 1457, + 25, 1458, 1459, 24, 23, 3251, 22, 1457, 3429, 1458, + 1459, 1457, 2734, 1458, 1459, 3433, 29, 19, 21, 2733, + 20, 2603, 18, 2604, 3263, 4095, 4140, 3317, 1457, 2612, + 1458, 1459, 123, 2614, 2615, 55, 52, 1457, 50, 1458, + 1459, 131, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, + 2629, 2630, 130, 2632, 3162, 53, 49, 2381, 1203, 3460, + 47, 3462, 3464, 31, 1457, 30, 1458, 1459, 17, 16, + 3509, 1457, 3469, 1458, 1459, 15, 2638, 2639, 2640, 2641, + 2642, 3476, 2644, 14, 13, 12, 2646, 11, 3481, 2383, + 2651, 2652, 7, 2653, 6, 39, 2656, 2657, 2659, 2661, + 2662, 2663, 2664, 2665, 2666, 2668, 2670, 2671, 2672, 2674, + 3498, 2676, 2677, 2679, 2681, 2683, 2685, 2687, 2689, 2691, 2693, 2695, 2697, 2699, 2701, 2703, 2705, 2707, 2709, 2711, - 2713, 2715, 2716, 2717, 3502, 2719, 3511, 2721, 3282, 2723, - 2724, 3279, 2726, 2728, 2730, 3283, 3499, 3505, 2733, 3527, - 3504, 3529, 2737, 15, 14, 13, 2742, 2743, 2744, 2745, - 3572, 3573, 12, 1457, 11, 1458, 1459, 7, 2755, 2756, - 2757, 2758, 2759, 2760, 2761, 1460, 1008, 2765, 2766, 3467, - 3437, 1009, 3439, 3440, 3441, 2768, 6, 3521, 3522, 39, - 2774, 2097, 38, 37, 1723, 1719, 2777, 2778, 2779, 2780, - 2781, 28, 27, 40, 4, 2922, 2477, 2788, 2789, 1720, - 2790, 3492, 0, 2793, 2795, 2348, 0, 2797, 0, 0, - 1457, 0, 1458, 1459, 1460, 0, 0, 2809, 3312, 3313, - 3506, 3507, 1460, 0, 2343, 2344, 1722, 0, 1721, 1460, - 3555, 3574, 0, 0, 3559, 3560, 3561, 0, 1460, 0, - 0, 0, 0, 0, 0, 3590, 0, 3551, 3552, 0, - 2754, 0, 0, 0, 0, 0, 966, 967, 968, 969, - 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, - 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, - 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, - 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1460, 2753, - 0, 0, 1457, 1460, 1458, 1459, 0, 2752, 0, 3641, - 1460, 3642, 3643, 3644, 2751, 1460, 2866, 0, 0, 3651, - 0, 0, 3658, 2750, 3660, 0, 0, 1460, 0, 0, - 0, 1460, 0, 0, 3631, 2853, 2856, 2857, 2858, 2854, - 3661, 2855, 2859, 0, 0, 0, 3164, 0, 87, 1460, - 3164, 1457, 0, 1458, 1459, 0, 0, 0, 0, 1457, - 0, 1458, 1459, 0, 1723, 1719, 1457, 0, 1458, 1459, - 0, 2098, 3690, 0, 0, 1457, 0, 1458, 1459, 1720, - 0, 3595, 3662, 2749, 2096, 42, 0, 3671, 2748, 3670, - 2915, 1460, 0, 3682, 0, 2747, 3678, 3680, 0, 0, - 2741, 0, 0, 0, 1715, 1716, 1722, 0, 1721, 0, - 1460, 0, 2740, 0, 0, 3840, 2739, 0, 2853, 2856, - 2857, 2858, 2854, 3694, 2855, 2859, 0, 0, 3495, 3496, - 0, 0, 0, 0, 2736, 1457, 0, 1458, 1459, 0, - 1457, 0, 1458, 1459, 0, 0, 0, 1457, 0, 1458, - 1459, 0, 1457, 0, 1458, 1459, 2964, 2965, 2966, 2967, - 2968, 2969, 3832, 3831, 1457, 3847, 1458, 1459, 1457, 0, - 1458, 1459, 0, 0, 3852, 3851, 2735, 0, 0, 3859, - 0, 3830, 0, 2047, 2979, 0, 1457, 3898, 1458, 1459, - 3899, 0, 0, 0, 0, 2734, 3684, 0, 2098, 3902, - 3025, 3026, 3027, 3028, 3029, 3659, 2987, 0, 0, 0, - 0, 2096, 0, 0, 0, 0, 0, 0, 0, 0, - 3034, 0, 3622, 3842, 3843, 3844, 0, 0, 1457, 0, - 1458, 1459, 0, 0, 0, 3160, 3691, 3692, 0, 0, - 3905, 0, 3164, 0, 3908, 0, 3835, 1457, 3686, 1458, - 1459, 0, 0, 0, 0, 0, 1530, 1531, 1532, 1533, - 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, - 1544, 1545, 1546, 1547, 1548, 1550, 1551, 1552, 1553, 1554, - 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, - 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, - 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, - 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, - 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, - 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, - 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, - 1625, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, - 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1648, 1649, 1650, - 1651, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, - 1674, 1675, 1676, 1677, 1678, 730, 3950, 3163, 3947, 3903, - 3932, 3163, 3931, 0, 3922, 0, 1460, 0, 0, 3964, - 1460, 3928, 0, 3930, 1460, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 87, 0, 0, - 0, 0, 0, 0, 3949, 0, 0, 3166, 0, 0, - 0, 1460, 0, 0, 0, 0, 0, 0, 0, 0, - 1460, 0, 0, 0, 0, 3184, 3966, 3953, 0, 3969, - 0, 0, 0, 0, 42, 0, 3839, 0, 0, 0, - 0, 0, 3971, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1460, 0, 0, 0, 3938, 0, - 0, 2732, 0, 0, 0, 2725, 0, 0, 0, 2722, - 0, 0, 0, 0, 1049, 0, 0, 1055, 1055, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3989, 0, - 0, 3990, 0, 4010, 0, 0, 2720, 0, 87, 0, - 0, 0, 0, 0, 3955, 2718, 0, 0, 0, 0, - 0, 3999, 0, 1457, 4006, 1458, 1459, 1457, 0, 1458, - 1459, 1457, 0, 1458, 1459, 0, 3238, 4016, 0, 0, - 0, 4041, 0, 0, 0, 42, 0, 4027, 3974, 2677, - 4019, 4024, 4021, 4014, 4020, 4018, 4023, 4022, 1457, 0, - 1458, 1459, 3276, 3316, 3859, 4030, 0, 1457, 0, 1458, - 1459, 0, 0, 3163, 4049, 4052, 3290, 0, 0, 4070, - 4060, 4065, 0, 0, 0, 3333, 3334, 0, 3335, 0, - 3337, 3339, 0, 0, 4041, 0, 3308, 4078, 4080, 3311, - 0, 1457, 4091, 1458, 1459, 3347, 0, 0, 0, 0, - 3351, 3352, 3353, 3355, 3356, 3357, 3358, 3359, 3360, 3361, - 3362, 3363, 3364, 3365, 3366, 3367, 3369, 3371, 3373, 3375, - 3377, 3379, 3381, 3383, 3385, 3387, 3389, 3391, 3393, 3395, - 3397, 3399, 3400, 3402, 3403, 3404, 3406, 1984, 4114, 3408, - 4110, 3410, 3411, 3412, 2098, 4124, 3416, 3417, 3418, 3419, - 3420, 3421, 3422, 3423, 3424, 3425, 3426, 2096, 4127, 4041, - 4125, 4123, 4121, 4135, 4120, 3433, 4111, 4143, 4095, 3438, - 4090, 4011, 190, 3442, 3443, 0, 3444, 3446, 3160, 3449, - 3451, 4149, 3453, 3454, 3455, 3456, 4151, 1460, 0, 3978, - 0, 1460, 3464, 0, 0, 0, 129, 3988, 151, 0, - 4160, 4161, 2098, 4158, 3899, 4159, 0, 1460, 0, 172, - 0, 0, 4094, 0, 0, 2096, 0, 0, 0, 0, - 3962, 1460, 1796, 0, 0, 0, 3486, 3487, 0, 0, - 3491, 0, 1460, 0, 0, 0, 190, 1460, 0, 0, - 162, 3466, 0, 0, 0, 0, 150, 2928, 1460, 0, - 4108, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 0, 151, 0, 0, 169, 0, 0, 170, 0, - 0, 0, 2657, 172, 0, 0, 2656, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4086, 138, 139, 161, - 160, 189, 2652, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 162, 0, 2650, 0, 0, 0, - 150, 0, 0, 0, 0, 0, 0, 2615, 0, 0, - 0, 0, 2609, 0, 1457, 3525, 1458, 1459, 1457, 169, - 1458, 1459, 170, 2603, 0, 0, 3566, 0, 0, 0, - 0, 0, 0, 0, 1457, 3540, 1458, 1459, 3541, 3542, - 3543, 1854, 1855, 161, 160, 189, 0, 0, 1457, 0, - 1458, 1459, 0, 0, 0, 0, 0, 0, 1784, 1457, - 0, 1458, 1459, 0, 1457, 0, 1458, 1459, 0, 0, - 0, 3585, 0, 0, 3589, 1457, 0, 1458, 1459, 0, - 0, 0, 155, 136, 158, 143, 135, 0, 156, 157, - 0, 0, 0, 0, 0, 173, 0, 0, 0, 0, - 0, 0, 3601, 0, 179, 144, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 147, - 145, 140, 141, 142, 146, 0, 0, 0, 0, 0, - 0, 137, 0, 0, 0, 0, 0, 0, 0, 0, - 148, 0, 1797, 0, 0, 0, 155, 1856, 158, 0, - 1853, 0, 156, 157, 0, 0, 0, 0, 0, 173, - 0, 0, 0, 0, 0, 0, 3624, 0, 179, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3632, - 0, 0, 0, 0, 0, 0, 0, 3639, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1810, 1813, 1814, 1815, 1816, - 1817, 1818, 0, 1819, 1820, 1822, 1823, 1821, 1824, 1825, - 1798, 1799, 1800, 1801, 1782, 1783, 1811, 0, 1785, 164, - 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 0, - 0, 1795, 1802, 1803, 1804, 1805, 0, 1806, 1807, 1808, - 1809, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1461, 0, 0, - 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3848, 0, 0, 0, 1518, 0, - 0, 0, 0, 3855, 0, 159, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3865, 3866, 3867, 0, 3869, 0, 3870, - 3871, 0, 0, 0, 3874, 3875, 3876, 3877, 3878, 3879, - 3880, 3881, 3882, 3883, 3884, 3885, 3886, 3887, 3888, 3889, - 3890, 3891, 3892, 3893, 3894, 3895, 0, 3897, 3900, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 159, - 0, 0, 0, 3909, 3910, 3911, 3912, 3913, 3915, 3916, - 3918, 3920, 3921, 3923, 0, 0, 0, 3927, 0, 0, + 2713, 2714, 2715, 730, 2717, 3281, 2719, 3501, 2721, 2722, + 3278, 2724, 2726, 2728, 3282, 1692, 3504, 2731, 3526, 3510, + 3528, 2735, 3503, 3311, 3312, 2740, 2741, 2742, 2743, 38, + 37, 28, 3571, 3572, 1460, 27, 3466, 40, 2754, 2755, + 2756, 2757, 2758, 2759, 3520, 3521, 2763, 2764, 3436, 4, + 3438, 3439, 3440, 2921, 2766, 2476, 0, 0, 0, 2772, + 2194, 0, 0, 0, 2775, 2776, 2777, 2778, 2779, 3491, + 1460, 0, 0, 0, 0, 2786, 2787, 1460, 2788, 0, + 0, 2791, 2793, 2347, 1460, 2795, 0, 0, 3505, 3506, + 1723, 1719, 0, 1460, 0, 2807, 0, 3554, 1460, 0, + 0, 3558, 3559, 3560, 0, 1720, 0, 1460, 1723, 1719, + 0, 0, 1049, 0, 3573, 1055, 1055, 1460, 0, 2732, + 0, 0, 0, 1720, 3589, 3550, 3551, 0, 0, 0, + 2341, 2342, 1722, 1460, 1721, 0, 0, 0, 0, 0, + 2277, 2278, 2279, 2280, 2281, 0, 1460, 0, 1715, 1716, + 1722, 1460, 1721, 0, 0, 2730, 1460, 2302, 0, 0, + 2305, 2306, 2723, 0, 0, 0, 0, 1460, 0, 2720, + 0, 1457, 0, 1458, 1459, 1460, 0, 0, 2718, 0, + 0, 0, 0, 2716, 0, 0, 0, 3640, 0, 3641, + 3642, 3643, 2675, 0, 0, 0, 2323, 0, 3650, 0, + 0, 3657, 2655, 3659, 0, 0, 0, 1457, 0, 1458, + 1459, 0, 0, 3630, 1457, 0, 1458, 1459, 2654, 0, + 0, 1457, 0, 1458, 1459, 3163, 0, 87, 3660, 3163, + 1457, 2650, 1458, 1459, 0, 1457, 2648, 1458, 1459, 0, + 0, 2613, 0, 0, 1457, 2098, 1458, 1459, 0, 0, + 2096, 0, 2607, 0, 1457, 0, 1458, 1459, 3594, 42, + 2602, 0, 3689, 3661, 0, 0, 0, 3681, 3670, 3669, + 1457, 0, 1458, 1459, 0, 0, 0, 3677, 3679, 0, + 0, 0, 0, 1457, 0, 1458, 1459, 0, 1457, 0, + 1458, 1459, 0, 1457, 3839, 1458, 1459, 0, 0, 0, + 0, 0, 0, 3693, 1457, 0, 1458, 1459, 0, 0, + 0, 0, 1457, 0, 1458, 1459, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3831, 3830, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3846, 0, + 0, 0, 0, 3851, 3850, 0, 0, 0, 3858, 0, + 0, 0, 0, 0, 3829, 0, 3897, 0, 0, 3898, + 0, 0, 2098, 3683, 0, 0, 0, 2096, 3023, 3024, + 3025, 3026, 3027, 3658, 0, 0, 0, 0, 0, 3901, + 3841, 3842, 3843, 0, 0, 0, 0, 0, 3032, 0, + 0, 0, 0, 0, 3690, 3691, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3163, 0, 3904, 3834, 3159, 3685, 3907, 0, 0, + 0, 0, 0, 0, 0, 1530, 1531, 1532, 1533, 1534, + 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, + 1545, 1546, 1547, 1548, 1550, 1551, 1552, 1553, 1554, 1555, + 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, + 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, + 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, + 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, + 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, + 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, + 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, + 1637, 1638, 1639, 1640, 1641, 1642, 1648, 1649, 1650, 1651, + 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, + 1675, 1676, 1677, 1678, 3949, 3946, 3162, 3902, 3931, 3930, + 3162, 0, 3921, 0, 0, 0, 0, 0, 3963, 3927, 0, 3929, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 87, 0, 0, 0, + 0, 3948, 0, 0, 0, 0, 3165, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3183, 3952, 0, 0, 42, 3965, + 0, 0, 0, 0, 3968, 3838, 3970, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2616, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2631, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3988, 0, 0, + 3989, 0, 4009, 0, 0, 0, 0, 87, 0, 0, + 0, 0, 3954, 0, 0, 0, 0, 0, 0, 0, + 0, 3998, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4015, 4005, 0, 0, 0, 0, 42, + 0, 0, 0, 4040, 0, 1461, 3973, 4013, 4018, 4026, + 4023, 4020, 0, 4019, 4017, 0, 4022, 4021, 0, 0, + 0, 0, 3315, 3858, 4029, 0, 0, 0, 0, 0, + 0, 4048, 3162, 0, 0, 0, 1518, 4069, 4059, 4064, + 0, 0, 0, 4051, 3332, 3333, 0, 3334, 3336, 3338, + 0, 0, 0, 0, 0, 0, 4040, 4077, 0, 0, + 4079, 4090, 0, 3346, 0, 0, 0, 0, 3350, 3351, + 3352, 3354, 3355, 3356, 3357, 3358, 3359, 3360, 3361, 3362, + 3363, 3364, 3365, 3366, 3368, 3370, 3372, 3374, 3376, 3378, + 3380, 3382, 3384, 3386, 3388, 3390, 3392, 3394, 3396, 3398, + 3399, 3401, 3402, 3403, 3405, 1984, 4113, 3407, 2098, 3409, + 3410, 3411, 4109, 2096, 3415, 3416, 3417, 3418, 3419, 3420, + 3421, 3422, 3423, 3424, 3425, 4123, 4126, 4122, 4124, 4120, + 4119, 4040, 4110, 3432, 4094, 4134, 4089, 3437, 4010, 4142, + 0, 3441, 3442, 0, 3443, 3445, 0, 3448, 3450, 4148, + 3452, 3453, 3454, 3455, 4150, 0, 0, 0, 3159, 0, + 3463, 0, 0, 0, 0, 0, 2098, 0, 0, 4159, + 4160, 2096, 0, 3898, 4158, 0, 0, 0, 0, 0, + 0, 0, 0, 4157, 0, 0, 0, 0, 0, 3961, + 0, 0, 0, 0, 0, 3485, 3486, 0, 0, 3490, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4107, 0, + 0, 0, 0, 0, 4093, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1796, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4085, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1008, 0, 2290, 0, 0, 1009, 0, 0, + 0, 0, 0, 0, 0, 3565, 0, 2097, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1745, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3584, 0, 0, 3588, 0, 0, 0, 0, 0, 0, + 0, 0, 1833, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 943, 0, 3015, 0, 0, 0, 0, + 1784, 3600, 966, 967, 968, 969, 970, 971, 972, 973, + 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, + 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, + 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, + 1004, 1005, 1006, 1007, 0, 0, 0, 0, 0, 195, + 0, 0, 195, 0, 0, 0, 716, 0, 0, 0, + 0, 722, 0, 0, 0, 3623, 0, 0, 0, 0, + 0, 0, 195, 0, 0, 0, 0, 0, 3631, 0, + 0, 0, 0, 0, 1797, 0, 3638, 0, 195, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1989, 0, 0, 722, 195, 722, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3075, 0, 3077, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3088, 3089, 3090, 3091, 1810, 1813, 1814, + 1815, 1816, 1817, 1818, 0, 1819, 1820, 1822, 1823, 1821, + 1824, 1825, 1798, 1799, 1800, 1801, 1782, 1783, 1811, 0, + 1785, 0, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, + 1794, 0, 0, 1795, 1802, 1803, 1804, 1805, 0, 1806, + 1807, 1808, 1809, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3847, 0, 0, 0, 0, 0, 0, + 0, 0, 3854, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3864, 3865, 3866, 0, 3868, 0, 3869, 3870, + 0, 0, 0, 3873, 3874, 3875, 3876, 3877, 3878, 3879, + 3880, 3881, 3882, 3883, 3884, 3885, 3886, 3887, 3888, 3889, + 3890, 3891, 3892, 3893, 3894, 0, 3896, 3899, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3908, 3909, 3910, 3911, 3912, 3914, 3915, 3917, + 3919, 3920, 3922, 0, 0, 0, 3926, 0, 0, 0, + 3928, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3953, 0, 0, 0, 0, 0, + 2054, 2055, 2056, 2057, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2065, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1812, + 2104, 2105, 0, 0, 0, 0, 2128, 0, 0, 2132, + 2133, 0, 0, 0, 2138, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2150, + 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 0, + 2161, 0, 0, 0, 2183, 2184, 2185, 2186, 2187, 2188, + 2190, 0, 2195, 0, 2197, 2198, 2199, 0, 2201, 2202, + 2203, 0, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, + 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, + 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, + 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, + 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2254, 2255, + 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, + 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, + 2276, 0, 0, 0, 0, 0, 2282, 0, 2284, 0, + 2291, 2292, 2293, 2294, 2295, 2296, 0, 0, 0, 3978, + 0, 0, 0, 0, 0, 0, 1692, 0, 0, 2307, + 2308, 2309, 2310, 2311, 2312, 2313, 2314, 0, 2316, 2317, + 2318, 2319, 2320, 3993, 0, 0, 0, 0, 0, 3996, + 0, 3997, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4008, 0, 0, 0, 0, 0, 1055, 0, + 0, 0, 0, 190, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4034, 4035, + 0, 0, 0, 0, 0, 2361, 2362, 129, 0, 151, + 0, 0, 4042, 4044, 4046, 0, 0, 0, 0, 0, + 172, 0, 0, 0, 0, 0, 195, 0, 195, 0, + 0, 2400, 0, 0, 0, 0, 0, 0, 4072, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 190, + 0, 162, 0, 0, 0, 0, 0, 150, 0, 0, + 2927, 0, 0, 0, 0, 722, 0, 722, 722, 0, + 0, 0, 0, 129, 4091, 151, 169, 0, 0, 170, + 0, 0, 0, 0, 0, 0, 172, 722, 195, 0, + 0, 0, 2442, 0, 0, 0, 0, 0, 138, 139, + 161, 160, 189, 0, 0, 0, 0, 0, 4114, 4116, + 4118, 0, 0, 0, 0, 0, 1504, 162, 0, 0, + 0, 0, 0, 150, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4139, 169, 0, 0, 170, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4151, + 4152, 0, 0, 0, 1854, 1855, 161, 160, 189, 0, + 0, 3621, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 155, 136, 158, 143, 135, 0, 156, + 157, 0, 0, 0, 0, 0, 173, 0, 0, 0, + 0, 0, 0, 0, 0, 179, 144, 0, 0, 0, + 86, 44, 45, 88, 0, 0, 0, 0, 0, 0, + 147, 145, 140, 141, 142, 146, 0, 0, 0, 0, + 92, 0, 137, 0, 48, 76, 77, 0, 74, 78, + 0, 148, 0, 0, 0, 0, 0, 75, 0, 155, + 1856, 158, 0, 1853, 0, 156, 157, 0, 0, 0, + 0, 0, 173, 0, 0, 0, 0, 0, 0, 0, + 0, 179, 0, 0, 0, 0, 62, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, + 0, 0, 0, 0, 0, 0, 0, 1504, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 152, 0, 0, 153, 0, 0, - 0, 0, 0, 0, 0, 3954, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1812, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 165, 0, 0, - 0, 0, 0, 0, 177, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 152, 0, - 0, 153, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 185, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 165, 0, 0, 0, 0, 0, 0, 177, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 166, 171, - 168, 174, 175, 176, 178, 180, 181, 182, 183, 0, - 0, 0, 0, 0, 184, 186, 187, 188, 0, 185, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1745, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 166, 171, 168, 174, 175, 176, 178, 180, - 181, 182, 183, 0, 0, 0, 0, 0, 184, 186, - 187, 188, 0, 0, 1833, 0, 0, 0, 1796, 0, - 3979, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3975, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3994, 0, 0, 0, 0, 0, - 3997, 0, 3998, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4009, 0, 0, 0, 0, 0, 0, - 0, 0, 943, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 4035, - 4036, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4043, 4045, 4047, 0, 0, 0, 0, + 164, 0, 0, 0, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 195, 4073, - 0, 195, 1989, 0, 0, 716, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 195, 0, 0, 0, 722, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 195, 0, 0, 1784, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1008, 4092, 2291, 195, 0, 1009, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2097, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 722, 195, 722, 0, 0, 0, 0, 4115, - 4117, 4119, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 4140, 0, 0, 0, 0, 0, 1797, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 4152, 4153, 0, 0, 966, 967, 968, 969, 970, 971, - 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, - 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, - 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, - 1002, 1003, 1004, 1005, 1006, 1007, 0, 0, 0, 0, - 0, 1810, 1813, 1814, 1815, 1816, 1817, 1818, 0, 1819, - 1820, 1822, 1823, 1821, 1824, 1825, 1798, 1799, 1800, 1801, - 1782, 1783, 1811, 0, 1785, 0, 1786, 1787, 1788, 1789, - 1790, 1791, 1792, 1793, 1794, 0, 0, 1795, 1802, 1803, - 1804, 1805, 0, 1806, 1807, 1808, 1809, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2054, 2055, 2056, 2057, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2065, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2104, 2105, 0, 0, 0, 0, 2128, 1055, - 1055, 2132, 2133, 0, 0, 0, 2138, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, - 2159, 0, 2161, 0, 0, 0, 2183, 2184, 2185, 2186, - 2187, 2188, 2190, 0, 2195, 0, 2197, 2198, 2199, 0, - 2201, 2202, 2203, 0, 2206, 2207, 2208, 2209, 2210, 2211, - 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, - 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, - 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, - 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, - 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, - 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, - 2275, 2276, 2277, 1812, 0, 0, 0, 0, 2283, 0, - 2285, 0, 2292, 2293, 2294, 2295, 2296, 2297, 1055, 0, - 1055, 1055, 1055, 1055, 1055, 0, 0, 0, 0, 0, - 0, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 0, - 2318, 2319, 2320, 2321, 2322, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1055, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2362, 2363, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 190, 0, 0, 0, 0, 0, - 0, 0, 0, 2401, 0, 1850, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 129, 0, - 151, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 172, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 195, 0, 195, 0, 0, - 0, 0, 162, 0, 2443, 0, 0, 95, 150, 0, - 1008, 0, 0, 0, 948, 1009, 961, 962, 963, 949, - 0, 0, 950, 951, 0, 952, 0, 169, 0, 0, - 170, 0, 0, 0, 722, 0, 722, 722, 0, 957, - 964, 965, 0, 0, 0, 0, 0, 0, 0, 1854, - 1855, 161, 160, 189, 0, 0, 722, 195, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1504, 0, 0, 3284, 3285, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, - 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, - 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, - 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, - 1006, 1007, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 155, 1856, 158, 0, 1853, 0, - 156, 157, 0, 0, 0, 0, 0, 173, 0, 0, - 0, 0, 0, 0, 0, 0, 179, 0, 0, 0, - 0, 0, 0, 3286, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3287, 3288, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1504, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 164, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2613, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2619, 2620, 2621, 2622, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 195, 913, 0, 0, 722, 722, - 0, 917, 0, 0, 0, 914, 915, 0, 0, 0, - 916, 918, 0, 0, 0, 1518, 0, 195, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 195, 0, + 2611, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2617, 2618, 2619, 2620, 0, 0, 164, 0, 0, 722, + 0, 0, 195, 0, 0, 0, 0, 3937, 0, 0, + 0, 0, 0, 0, 722, 0, 0, 0, 0, 0, + 0, 195, 0, 0, 0, 0, 159, 0, 51, 54, + 57, 56, 59, 1518, 73, 0, 0, 82, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 722, 0, - 0, 195, 0, 0, 0, 0, 0, 159, 0, 0, - 0, 0, 0, 722, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 61, 91, 90, 0, 0, 71, 72, 58, 0, + 0, 1504, 0, 0, 80, 81, 0, 722, 722, 0, + 722, 0, 722, 722, 0, 722, 722, 722, 722, 722, + 722, 0, 159, 0, 0, 0, 0, 0, 1504, 0, + 0, 1504, 722, 1504, 195, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 63, 64, 0, + 65, 66, 67, 68, 195, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 152, 0, 722, 153, 195, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 722, 0, 195, 195, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 165, 0, + 0, 0, 195, 0, 0, 177, 0, 0, 0, 195, + 0, 60, 1692, 0, 0, 0, 0, 0, 195, 195, + 195, 195, 195, 195, 195, 195, 195, 722, 0, 0, + 0, 152, 0, 0, 153, 0, 0, 1745, 0, 0, + 0, 0, 0, 0, 0, 0, 185, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 165, 0, 0, 0, 3977, 0, + 0, 177, 0, 0, 0, 0, 3987, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 166, + 171, 168, 174, 175, 176, 178, 180, 181, 182, 183, + 0, 89, 0, 0, 0, 184, 186, 187, 188, 0, + 0, 0, 185, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1692, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 166, 171, 168, 174, 175, + 176, 178, 180, 181, 182, 183, 0, 0, 0, 0, + 0, 184, 186, 187, 188, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 722, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 722, 0, 0, + 0, 94, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1504, 0, 0, 0, 0, 0, 722, 722, 0, 722, - 0, 722, 722, 0, 722, 722, 722, 722, 722, 722, - 0, 0, 0, 0, 0, 0, 0, 1504, 0, 0, - 1504, 722, 1504, 195, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 152, 0, 0, 153, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 722, 0, 195, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 165, - 1745, 0, 722, 0, 195, 195, 177, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 0, 195, 0, - 0, 0, 0, 0, 0, 0, 0, 195, 195, 195, - 195, 195, 195, 195, 195, 195, 722, 185, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 942, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 166, 171, 168, 174, 175, 176, 178, 180, 181, 182, - 183, 0, 0, 0, 0, 0, 184, 186, 187, 188, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 701, 0, 0, 0, 0, - 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 721, 0, 721, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 722, 722, 0, 0, 0, 2991, 0, - 0, 0, 0, 0, 0, 0, 722, 0, 0, 0, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 1055, 0, 0, 3018, 3019, 3020, 0, 0, 3022, 0, - 0, 3024, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3031, 3032, 3033, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3038, 722, 0, 3040, 3041, 3042, 0, - 0, 0, 3043, 3044, 1504, 0, 3045, 0, 3046, 0, - 0, 0, 0, 0, 0, 3047, 0, 3048, 0, 0, - 0, 3049, 1504, 3050, 0, 0, 3051, 0, 3052, 0, + 0, 0, 0, 0, 0, 2990, 1796, 0, 0, 0, + 0, 0, 0, 0, 0, 722, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1504, 0, 0, 0, 3016, + 3017, 3018, 0, 0, 3020, 0, 0, 3022, 0, 0, + 0, 0, 0, 1504, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3029, 3030, 3031, + 0, 0, 0, 0, 0, 0, 0, 70, 0, 3036, + 0, 0, 3038, 3039, 3040, 0, 0, 0, 3041, 3042, + 0, 0, 3043, 0, 3044, 0, 0, 0, 0, 0, + 0, 3045, 0, 3046, 0, 0, 0, 3047, 0, 3048, + 0, 0, 3049, 0, 3050, 0, 3051, 0, 3052, 0, 3053, 0, 3054, 0, 3055, 0, 3056, 0, 3057, 0, 3058, 0, 3059, 0, 3060, 0, 3061, 0, 3062, 0, - 3063, 0, 3064, 0, 3065, 0, 3066, 0, 3067, 0, - 3068, 0, 0, 0, 3069, 0, 3070, 0, 3071, 0, - 0, 3072, 0, 3073, 0, 3074, 0, 2255, 3076, 0, - 0, 3078, 0, 0, 3080, 3081, 3082, 3083, 0, 0, - 0, 0, 3084, 2255, 2255, 2255, 2255, 2255, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3094, 0, - 0, 0, 0, 0, 0, 0, 3107, 0, 0, 3111, - 0, 1055, 0, 0, 0, 0, 0, 0, 3114, 3115, - 3116, 3117, 3118, 3119, 0, 0, 0, 3120, 3121, 0, - 3122, 0, 3123, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2303, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3155, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 722, 0, 0, 0, - 0, 3185, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 195, 0, 0, 722, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 722, 0, 0, 2303, 195, 0, 195, - 0, 195, 195, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3248, 0, 0, 0, 722, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 722, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 722, 0, 0, 0, 0, 0, 722, 0, 0, 3341, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3350, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 722, 0, 0, 0, 0, 722, 0, - 0, 0, 722, 722, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 195, 195, 0, - 0, 195, 0, 195, 0, 721, 1420, 721, 721, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 721, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, - 0, 0, 0, 0, 0, 722, 1503, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3547, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1504, 0, 2303, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3571, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3591, 0, 3592, 0, 3593, 0, 3594, 0, - 0, 3597, 3598, 0, 0, 0, 0, 0, 0, 0, - 3602, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3603, 0, 3604, 0, 3605, 0, - 3606, 0, 3607, 0, 3608, 0, 3609, 0, 3610, 0, - 3611, 0, 3612, 0, 3613, 0, 3614, 1503, 3615, 0, - 3616, 0, 3617, 0, 3618, 0, 0, 3619, 0, 0, - 0, 3620, 0, 3621, 0, 0, 0, 0, 0, 3623, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3640, 0, 0, 0, 0, 0, 0, 0, - 0, 3645, 0, 3646, 3647, 0, 3648, 0, 3649, 721, - 721, 0, 0, 3650, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, - 3679, 0, 0, 0, 0, 0, 0, 195, 0, 721, - 0, 3687, 0, 0, 3689, 0, 0, 0, 722, 0, - 0, 0, 0, 0, 721, 0, 3693, 0, 0, 0, - 0, 722, 0, 0, 0, 1827, 0, 0, 0, 0, - 0, 0, 3827, 0, 0, 1836, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 0, 721, 0, - 1862, 0, 0, 0, 0, 0, 0, 0, 1871, 0, - 0, 1503, 1873, 0, 0, 1876, 1877, 721, 721, 0, - 721, 0, 721, 721, 0, 721, 721, 721, 721, 721, - 721, 0, 0, 0, 0, 0, 0, 0, 1503, 1908, - 1909, 1503, 721, 1503, 0, 1914, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 722, 0, - 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 721, 0, 0, - 0, 0, 0, 0, 0, 722, 0, 0, 0, 0, - 1977, 0, 722, 721, 0, 0, 0, 0, 0, 0, - 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, - 3937, 0, 0, 0, 0, 0, 0, 1504, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 195, 195, 195, 195, 195, 195, 0, 721, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 195, 195, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3063, 0, 3064, 0, 3065, 0, 3066, 0, 0, 0, + 3067, 0, 3068, 0, 3069, 0, 0, 3070, 0, 3071, + 0, 3072, 1784, 2254, 3074, 0, 0, 3076, 0, 0, + 3078, 3079, 3080, 3081, 0, 0, 0, 0, 3082, 2254, + 2254, 2254, 2254, 2254, 0, 0, 0, 2301, 0, 0, + 0, 0, 0, 0, 3092, 0, 0, 0, 0, 0, + 0, 0, 3105, 0, 0, 3109, 0, 0, 0, 0, + 0, 0, 0, 0, 3112, 3113, 3114, 3115, 3116, 3117, + 0, 0, 0, 3118, 3119, 0, 3120, 0, 3121, 0, + 0, 0, 195, 0, 0, 0, 0, 722, 0, 0, + 0, 0, 0, 0, 0, 0, 1797, 0, 0, 0, + 0, 0, 1055, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 195, 0, 0, 722, 0, 0, 0, + 0, 0, 0, 3154, 0, 0, 0, 0, 0, 0, + 195, 0, 0, 0, 722, 0, 0, 2301, 195, 0, + 195, 0, 195, 195, 0, 0, 0, 0, 3184, 0, + 0, 0, 0, 0, 0, 0, 0, 722, 0, 1810, + 1813, 1814, 1815, 1816, 1817, 1818, 0, 1819, 1820, 1822, + 1823, 1821, 1824, 1825, 1798, 1799, 1800, 1801, 1782, 1783, + 1811, 0, 1785, 0, 1786, 1787, 1788, 1789, 1790, 1791, + 1792, 1793, 1794, 0, 0, 1795, 1802, 1803, 1804, 1805, + 0, 1806, 1807, 1808, 1809, 0, 0, 0, 0, 3247, + 0, 0, 0, 0, 722, 0, 0, 0, 0, 0, + 0, 0, 942, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 722, 1698, 0, 0, 0, 0, 722, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 701, 0, 0, 0, 0, 0, + 721, 0, 0, 0, 722, 0, 0, 0, 0, 722, + 0, 665, 0, 722, 722, 3340, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3349, + 0, 1013, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 195, 721, 0, 721, 190, 0, 0, 195, 0, + 0, 0, 0, 0, 0, 0, 1850, 0, 195, 195, + 0, 0, 195, 1084, 195, 0, 0, 0, 0, 129, + 0, 151, 0, 0, 195, 0, 0, 0, 0, 0, + 0, 195, 172, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 195, 0, 0, + 0, 1812, 0, 162, 0, 0, 722, 0, 0, 150, 0, 0, 900, 0, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 722, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 169, 0, + 0, 170, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1854, 1855, 161, 160, 189, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 193, 0, - 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 666, 0, 0, 0, 1504, 0, 2301, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 666, 722, 0, 0, 0, 0, 0, 0, 0, + 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1036, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3546, 0, 0, 0, 0, 0, 1056, 1056, 0, 0, 0, 0, 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 721, 721, 0, 0, 0, 0, - 0, 0, 0, 0, 3977, 0, 0, 721, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3570, 0, 0, 0, 155, 1856, 158, 0, 1853, + 0, 156, 157, 0, 0, 0, 0, 0, 173, 0, + 0, 0, 0, 0, 0, 0, 0, 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3991, 0, 0, 3992, 0, 3993, 0, 722, 0, 0, - 0, 0, 0, 0, 0, 721, 0, 0, 899, 722, - 0, 0, 0, 0, 0, 1503, 0, 0, 0, 0, - 0, 0, 0, 0, 2106, 0, 0, 0, 0, 0, - 0, 0, 0, 1503, 0, 0, 0, 0, 0, 0, - 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 195, 0, 0, 722, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3590, + 0, 3591, 0, 3592, 0, 3593, 0, 0, 3596, 3597, + 0, 0, 0, 0, 0, 0, 0, 3601, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 722, 0, 0, 0, 1504, 720, 0, 722, 722, - 1504, 195, 195, 195, 195, 195, 0, 0, 0, 0, - 0, 4071, 0, 195, 0, 0, 0, 0, 0, 195, - 0, 195, 0, 0, 195, 195, 195, 0, 0, 0, + 0, 3602, 0, 3603, 0, 3604, 0, 3605, 0, 3606, + 0, 3607, 0, 3608, 0, 3609, 0, 3610, 0, 3611, + 0, 3612, 0, 3613, 0, 3614, 0, 3615, 0, 3616, + 0, 3617, 0, 0, 3618, 0, 0, 0, 3619, 0, + 3620, 0, 0, 0, 0, 0, 3622, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 195, 0, + 0, 0, 164, 0, 0, 0, 195, 0, 0, 3639, + 0, 0, 0, 0, 0, 0, 0, 722, 3644, 0, + 3645, 3646, 0, 3647, 0, 3648, 0, 0, 0, 0, + 3649, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 4087, 0, 4088, 0, 4089, 0, 0, 0, 1080, 0, - 1087, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 899, 0, 0, 195, 0, 3678, 0, 0, + 195, 0, 0, 0, 0, 0, 0, 0, 3686, 0, + 0, 3688, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3692, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 159, 3826, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 722, 0, 0, 1504, 721, 0, 0, - 0, 722, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 195, 0, 4138, 0, 4139, 0, 0, 0, 0, 0, + 720, 0, 0, 0, 0, 0, 0, 0, 722, 0, + 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, + 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 722, 0, 0, 0, 0, + 0, 0, 722, 0, 0, 0, 0, 0, 0, 0, + 0, 722, 1080, 0, 1087, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1504, 0, 0, + 0, 0, 0, 0, 0, 1204, 0, 1210, 0, 0, + 195, 195, 195, 195, 195, 195, 0, 152, 0, 0, + 153, 0, 0, 0, 721, 1420, 721, 721, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 195, 195, 0, + 0, 0, 0, 0, 0, 0, 721, 3936, 0, 0, + 165, 0, 0, 0, 0, 0, 0, 177, 0, 0, + 195, 0, 0, 0, 0, 0, 0, 1433, 0, 0, + 0, 0, 0, 0, 0, 1503, 0, 0, 0, 0, + 0, 0, 0, 722, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 185, 1008, + 0, 0, 0, 0, 1009, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2097, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 195, 0, 0, 0, 721, 0, 0, + 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 166, 171, 168, 174, 175, 176, 178, 180, 181, + 182, 183, 0, 0, 0, 0, 0, 184, 186, 187, + 188, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 666, 0, 666, 0, 966, + 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, + 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, + 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, + 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, + 1007, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 722, 666, 0, 0, + 0, 3976, 0, 0, 0, 0, 0, 0, 722, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1505, 1503, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 722, + 0, 0, 0, 0, 0, 0, 0, 3990, 0, 0, + 3991, 0, 3992, 0, 195, 0, 0, 722, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 722, 0, 0, 0, 1504, 0, 0, 722, 722, + 1504, 195, 195, 195, 195, 195, 0, 0, 721, 721, + 0, 0, 0, 195, 0, 0, 0, 0, 0, 195, + 0, 195, 0, 0, 195, 195, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 721, 0, 0, 0, 0, 4070, 0, + 195, 1757, 0, 0, 1827, 0, 0, 0, 0, 0, + 0, 0, 0, 722, 1836, 0, 1504, 0, 0, 0, + 1774, 722, 0, 0, 0, 0, 195, 4086, 0, 4087, + 0, 4088, 0, 0, 0, 0, 0, 721, 0, 1862, + 195, 0, 0, 0, 0, 0, 0, 1871, 0, 0, + 1503, 1873, 0, 0, 1876, 1877, 721, 721, 0, 721, + 195, 721, 721, 195, 721, 721, 721, 721, 721, 721, + 0, 0, 0, 0, 0, 0, 1505, 1503, 1908, 1909, + 1503, 721, 1503, 0, 1914, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4137, + 0, 4138, 0, 1913, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1977, + 0, 0, 721, 0, 666, 0, 0, 0, 1958, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1985, 0, 1036, 0, 0, + 0, 0, 0, 0, 1268, 0, 1268, 1268, 0, 0, + 0, 1996, 0, 0, 0, 0, 721, 722, 2000, 0, + 0, 666, 0, 0, 0, 0, 1432, 0, 0, 2011, + 2012, 2013, 2014, 2015, 2016, 2017, 0, 0, 0, 0, + 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 721, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1505, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 195, 0, 0, 0, 0, 0, 0, 1505, 0, 0, + 1505, 0, 1505, 666, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, + 0, 0, 0, 1930, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 666, 195, + 0, 0, 195, 195, 195, 0, 0, 0, 0, 0, + 0, 0, 722, 722, 1983, 666, 0, 0, 0, 0, + 0, 0, 0, 721, 721, 0, 0, 0, 0, 0, + 0, 666, 0, 0, 0, 0, 721, 0, 666, 0, + 0, 0, 0, 0, 0, 0, 0, 2009, 2010, 666, + 666, 666, 666, 666, 666, 666, 0, 0, 0, 0, + 0, 722, 722, 722, 722, 2047, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, - 0, 2465, 2466, 2467, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, - 0, 721, 0, 0, 0, 0, 0, 721, 1871, 0, - 0, 1871, 0, 1871, 0, 0, 0, 0, 0, 2497, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1503, 0, 0, 0, 0, 0, + 0, 0, 0, 2106, 0, 0, 0, 0, 0, 0, + 0, 0, 1503, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 721, 0, 0, 0, 0, 721, - 0, 0, 0, 721, 721, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 666, 0, 666, 0, 195, - 0, 0, 195, 195, 195, 0, 0, 0, 0, 0, - 0, 0, 722, 722, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1701, 1702, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 666, 0, 0, - 0, 722, 722, 722, 722, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, - 0, 0, 0, 0, 0, 1505, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1751, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1769, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 722, 0, 722, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 666, 1504, 0, 0, 0, + 0, 722, 0, 722, 0, 0, 721, 1080, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1879, 1879, 0, 1879, + 0, 1879, 1879, 0, 1888, 1879, 1879, 1879, 1879, 1879, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1080, 0, 0, 1505, 0, 721, 0, 0, 0, + 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1505, 0, 195, 0, 0, 722, 0, 0, + 0, 0, 0, 0, 0, 721, 1956, 0, 0, 0, + 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1981, 721, 0, 0, 721, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2367, + 0, 0, 0, 0, 0, 0, 721, 2371, 0, 2374, + 0, 0, 2047, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1268, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1503, 0, 721, 0, 0, + 0, 0, 0, 0, 722, 0, 0, 0, 0, 0, + 0, 722, 0, 722, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, + 2464, 2465, 2466, 0, 0, 0, 0, 0, 0, 0, + 0, 722, 0, 0, 0, 0, 1983, 0, 0, 0, + 721, 0, 0, 0, 0, 0, 721, 1871, 0, 0, + 1871, 0, 1871, 0, 0, 0, 0, 0, 2496, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1930, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 721, 0, 0, 0, 1056, 721, 0, + 0, 0, 721, 721, 0, 0, 0, 0, 0, 0, + 0, 0, 1036, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 666, + 0, 0, 0, 0, 0, 0, 1983, 666, 0, 666, + 0, 666, 2390, 1268, 1268, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2035, 0, 0, 0, + 2047, 0, 0, 0, 0, 0, 0, 2532, 0, 722, + 0, 0, 0, 0, 0, 0, 0, 2551, 2552, 0, + 0, 2556, 0, 0, 0, 195, 0, 0, 0, 0, + 0, 0, 0, 2561, 0, 0, 0, 0, 0, 0, + 2564, 0, 0, 722, 195, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2092, 721, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2567, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 722, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 722, + 0, 0, 0, 0, 1503, 0, 721, 0, 0, 1504, + 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 722, 2301, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 722, 0, 722, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1268, 0, 1268, 1268, 0, 0, 1504, 0, 0, 0, - 0, 722, 0, 722, 0, 0, 0, 0, 0, 0, - 0, 0, 1432, 0, 0, 0, 0, 0, 0, 0, + 666, 0, 0, 0, 0, 0, 0, 666, 0, 0, + 0, 0, 195, 722, 0, 0, 0, 666, 666, 0, + 0, 666, 0, 2558, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 666, 0, 0, 1268, 0, 0, 0, + 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 722, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 666, 0, 0, 0, + 0, 0, 0, 0, 0, 722, 0, 0, 0, 0, + 195, 0, 0, 0, 0, 0, 2338, 0, 0, 0, + 0, 0, 0, 0, 722, 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1505, 0, 0, 0, + 0, 0, 0, 0, 0, 2351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1751, 0, 0, 1268, 0, 0, 0, + 0, 0, 0, 0, 1505, 0, 1983, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1080, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 195, 0, 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 722, 0, 0, 0, 666, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1036, 0, 0, + 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1087, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 721, - 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, - 666, 0, 0, 0, 722, 0, 0, 0, 0, 0, - 0, 722, 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2879, 0, 0, - 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, - 1505, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1080, 0, 0, 0, 0, 2878, 1087, 0, 0, 2865, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1505, 0, 0, - 1505, 0, 1505, 666, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1930, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 721, 0, 666, 0, - 0, 0, 0, 721, 0, 0, 0, 1871, 1871, 0, - 0, 0, 721, 0, 1983, 666, 0, 0, 0, 0, - 0, 0, 0, 0, 1701, 1702, 0, 0, 1503, 2952, - 0, 666, 0, 0, 0, 0, 0, 0, 666, 0, - 0, 0, 0, 0, 0, 0, 0, 2009, 2010, 666, - 666, 666, 666, 666, 666, 666, 0, 0, 0, 722, - 0, 0, 0, 0, 1751, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 195, 0, 0, 0, 1769, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 722, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, - 0, 0, 0, 1080, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1080, 0, 0, 0, 721, 2092, 0, + 0, 0, 2092, 2092, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1879, 1879, 0, 1879, 0, 1879, 1879, 0, - 1888, 1879, 1879, 1879, 1879, 1879, 0, 0, 0, 722, - 0, 0, 0, 721, 0, 0, 0, 1080, 0, 722, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1504, - 0, 722, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2914, 721, 0, 0, 0, 0, 0, + 0, 721, 0, 0, 0, 1871, 1871, 0, 0, 0, + 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1503, 2951, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 666, 0, 0, + 0, 0, 0, 0, 0, 1930, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2963, + 2964, 2965, 2966, 2967, 2968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1956, 0, 0, 722, 2303, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1981, 0, + 0, 0, 0, 0, 0, 2570, 2047, 2978, 0, 0, + 0, 0, 0, 0, 666, 0, 0, 0, 0, 666, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2986, + 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 195, 722, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1268, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, - 0, 0, 0, 722, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1268, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1505, 722, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 1056, 1056, 0, 0, - 0, 721, 1505, 0, 722, 0, 722, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 721, 0, 0, 0, 1503, 0, 0, 721, - 721, 1503, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, + 2920, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1505, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 666, + 666, 666, 666, 666, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 666, 666, 0, 0, + 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 721, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3233, 0, 0, 0, 0, 0, 0, 1268, - 1268, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2035, 0, 721, 0, 0, 1503, 0, 0, - 0, 0, 721, 0, 0, 1056, 1983, 1056, 1056, 1056, - 1056, 1056, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2092, 1930, 0, 0, 3315, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1056, 0, 0, + 721, 0, 0, 0, 1503, 0, 0, 721, 721, 1503, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1036, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 666, - 0, 0, 0, 0, 0, 0, 1983, 666, 0, 666, - 0, 666, 2391, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2813, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 721, + 2828, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3232, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 721, 0, 0, 1503, 0, 0, 0, 3237, + 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3275, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3289, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3314, 0, 0, 0, 0, 2910, 0, 3307, + 0, 0, 3310, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1056, 0, 666, 2351, 0, 0, 0, 0, 0, + 0, 2935, 0, 0, 0, 0, 0, 0, 0, 0, + 2940, 0, 0, 0, 1505, 0, 0, 0, 0, 1505, + 666, 666, 666, 666, 666, 0, 0, 0, 0, 0, + 0, 0, 3182, 0, 0, 0, 0, 0, 1930, 0, + 666, 0, 0, 666, 3190, 1983, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1268, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1505, 0, 0, 0, 0, + 0, 0, 2092, 0, 0, 666, 0, 0, 0, 0, + 0, 0, 0, 3465, 0, 0, 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 666, + 0, 0, 666, 0, 0, 0, 0, 0, 0, 0, + 2092, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2340, 0, 0, 0, 0, 0, 0, 3515, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3524, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2352, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1751, - 666, 0, 1268, 721, 721, 0, 0, 666, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 666, 666, 0, - 0, 666, 1080, 2559, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, - 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 721, 721, 721, 721, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 666, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1087, + 0, 721, 721, 0, 0, 0, 0, 0, 3539, 0, + 0, 3540, 3541, 3542, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1080, 0, 0, 0, - 0, 0, 1087, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 721, 721, 721, 721, 0, 3094, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1268, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1505, 0, 1983, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1080, - 0, 0, 0, 0, 2092, 0, 0, 0, 2092, 2092, + 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1879, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3139, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1268, 0, 0, 0, 0, 0, 0, 3166, 1879, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 95, 0, 0, 1008, 0, 0, 0, 948, 1009, + 961, 962, 963, 949, 0, 0, 950, 951, 666, 952, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 721, 0, 721, 0, 0, 0, + 0, 0, 0, 957, 964, 965, 0, 0, 666, 0, + 0, 666, 666, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1503, 0, 0, 0, 0, 721, 0, 721, 0, 0, 0, 0, 0, + 0, 0, 1080, 0, 0, 0, 0, 0, 0, 0, + 2351, 0, 3283, 3284, 0, 1503, 0, 0, 0, 0, + 721, 0, 721, 0, 966, 967, 968, 969, 970, 971, + 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, + 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, + 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, + 1002, 1003, 1004, 1005, 1006, 1007, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3285, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2571, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1268, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 666, - 0, 0, 0, 0, 0, 0, 0, 1930, 0, 0, + 0, 0, 0, 0, 0, 0, 3428, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 721, 0, 3286, 3287, 0, 0, 0, + 721, 0, 721, 0, 0, 0, 1930, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, - 0, 0, 721, 0, 721, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 666, 0, 0, 0, 0, - 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1505, 0, 0, 0, 0, + 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 913, + 0, 0, 0, 0, 0, 917, 0, 0, 0, 914, + 915, 0, 0, 0, 916, 918, 0, 0, 0, 0, + 0, 0, 0, 1930, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 666, 0, 0, 0, 0, 0, - 0, 2921, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2351, 2351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1505, 0, 0, + 3578, 3579, 3580, 3581, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 666, 666, 666, 666, 666, 666, 0, 0, 0, 0, - 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2815, 0, 0, 666, 666, 0, - 0, 0, 0, 0, 0, 0, 0, 2829, 0, 0, - 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, - 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1056, 0, 0, + 0, 0, 0, 3974, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1503, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1503, 0, 721, 0, 2911, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 721, 721, 0, 0, - 0, 2352, 0, 0, 0, 0, 0, 0, 2936, 0, - 0, 0, 0, 0, 0, 0, 0, 2941, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 721, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3655, 0, 3655, 0, 0, 0, 0, 0, + 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3682, 0, 3684, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1930, 0, 0, 0, 0, 0, + 0, 0, 721, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1056, 0, - 0, 0, 0, 0, 0, 0, 721, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 721, 0, 721, 0, 2092, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 666, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1505, 0, 0, 0, 0, - 1505, 666, 666, 666, 666, 666, 0, 0, 2092, 0, - 0, 0, 0, 3183, 0, 0, 0, 0, 0, 1930, - 0, 666, 0, 0, 666, 3191, 1983, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2351, 0, 0, 721, 0, 721, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3849, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1268, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1505, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 666, 3715, 3717, 3716, - 3780, 3781, 3782, 3783, 3784, 3785, 3786, 792, 0, 0, - 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3096, 0, 0, 0, 0, 0, 0, - 666, 0, 0, 666, 0, 1268, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1505, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1879, 0, 0, 0, + 0, 0, 0, 0, 0, 4028, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3140, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1268, 0, 0, - 0, 0, 0, 0, 3167, 1879, 0, 0, 0, 0, + 0, 0, 0, 3655, 0, 0, 0, 0, 0, 0, + 3655, 0, 3655, 0, 0, 0, 0, 0, 0, 0, + 0, 1930, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1983, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 666, 0, 0, 0, 1080, - 0, 0, 0, 0, 0, 0, 0, 2352, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3721, 0, 0, 0, 0, 0, - 666, 0, 0, 0, 0, 0, 0, 0, 0, 3729, - 3730, 0, 0, 3805, 3804, 3803, 0, 0, 3801, 3802, - 3800, 0, 0, 0, 0, 0, 0, 0, 0, 666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 666, - 0, 0, 666, 666, 666, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3806, 913, 0, 768, 769, 3807, 3808, - 917, 3809, 771, 772, 914, 915, 0, 766, 770, 916, - 918, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3429, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3712, 3713, 3714, 3718, - 3719, 3720, 3731, 3778, 3779, 3787, 3789, 869, 3788, 3790, - 3791, 3792, 3795, 3796, 3797, 3798, 3793, 3794, 3799, 3695, - 3699, 3696, 3697, 3698, 3710, 3700, 3701, 3702, 3703, 3704, - 3705, 3706, 3707, 3708, 3709, 3711, 3810, 3811, 3812, 3813, - 3814, 3815, 3724, 3728, 3727, 3725, 3726, 3722, 3723, 3750, - 3749, 3751, 3752, 3753, 3754, 3755, 3756, 3758, 3757, 3759, - 3760, 3761, 3762, 3763, 3764, 3732, 3733, 3736, 3737, 3735, - 3734, 3738, 3747, 3748, 3739, 3740, 3741, 3742, 3743, 3744, - 3746, 3745, 3765, 3766, 3767, 3768, 3769, 3771, 3770, 3774, - 3775, 3773, 3772, 3777, 3776, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 919, 0, 920, - 0, 0, 924, 0, 0, 0, 926, 925, 0, 927, - 889, 888, 0, 0, 921, 922, 0, 923, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2352, 2352, - 0, 0, 0, 0, 0, 0, 0, 1930, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1505, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3579, 3580, 3581, - 3582, 0, 3816, 3817, 3818, 3819, 3820, 3821, 3822, 3823, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1930, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3994, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4006, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1268, 1268, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4054, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3656, - 0, 3656, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3683, 0, 3685, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2352, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 3850, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1268, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1930, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3656, 0, 0, 0, 666, 0, 0, 3656, 0, 3656, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2352, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1505, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4029, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1930, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2352, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2352, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1983, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3995, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 4003, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 4007, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1268, 1268, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 4055, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 4003, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2352, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 393, 0, - 3429, 0, 4055, 1403, 1389, 522, 0, 1331, 1406, 1300, - 1319, 1416, 1322, 1325, 1368, 1278, 1346, 413, 1316, 1271, - 1304, 1273, 1311, 1274, 1302, 1333, 269, 1299, 1391, 1350, - 1405, 363, 266, 1280, 1305, 427, 1321, 203, 1370, 483, - 251, 374, 371, 577, 281, 272, 268, 249, 316, 382, - 425, 512, 419, 1412, 367, 1356, 0, 493, 398, 0, - 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, - 1407, 1317, 1365, 1408, 322, 247, 324, 202, 410, 494, - 285, 0, 0, 0, 0, 4031, 944, 0, 0, 0, - 0, 4032, 0, 0, 0, 0, 237, 0, 0, 244, - 0, 0, 0, 348, 357, 356, 337, 338, 340, 342, - 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, - 271, 263, 574, 1413, 1394, 1277, 1343, 1401, 1338, 0, - 0, 228, 1404, 1337, 0, 1367, 0, 1419, 1272, 1358, - 0, 1275, 1279, 1415, 1399, 1308, 274, 0, 0, 0, - 0, 0, 0, 0, 1334, 1345, 1379, 1383, 1328, 0, - 0, 0, 0, 0, 0, 0, 0, 1306, 0, 1354, - 0, 0, 0, 1284, 1276, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1332, 0, 0, - 0, 0, 1287, 0, 1307, 1380, 0, 1270, 296, 1281, - 399, 256, 0, 450, 1387, 1398, 1329, 618, 1400, 1327, - 1326, 1374, 1285, 1393, 1320, 362, 1283, 329, 197, 224, - 0, 1318, 409, 458, 470, 1392, 1303, 1312, 252, 1310, - 468, 423, 596, 232, 283, 455, 429, 466, 437, 286, - 1353, 1372, 467, 369, 579, 447, 593, 619, 620, 262, - 403, 605, 516, 613, 637, 225, 259, 417, 501, 599, - 490, 394, 575, 576, 328, 489, 294, 201, 366, 625, - 223, 476, 368, 241, 230, 581, 602, 298, 288, 453, - 632, 212, 511, 591, 238, 480, 0, 0, 640, 246, - 500, 214, 588, 499, 390, 325, 326, 213, 0, 454, - 267, 292, 0, 0, 257, 412, 583, 584, 255, 641, - 227, 612, 219, 1282, 611, 405, 578, 589, 391, 380, - 218, 587, 389, 379, 333, 352, 353, 279, 306, 444, - 372, 445, 305, 307, 401, 400, 402, 206, 600, 0, - 207, 0, 495, 601, 642, 449, 211, 233, 234, 236, - 1298, 278, 282, 290, 293, 302, 303, 312, 364, 416, - 443, 439, 448, 1388, 573, 594, 606, 617, 623, 624, - 626, 627, 628, 629, 630, 633, 631, 404, 310, 491, - 332, 370, 1377, 1418, 422, 469, 239, 598, 492, 199, - 1292, 1297, 1290, 0, 253, 254, 1359, 569, 1293, 1291, - 1348, 1349, 1294, 1409, 1410, 1411, 1396, 643, 644, 645, - 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, - 656, 657, 658, 659, 660, 638, 502, 508, 503, 504, - 505, 506, 507, 0, 509, 1381, 1286, 0, 1295, 1296, - 395, 1390, 585, 586, 661, 381, 482, 595, 334, 346, - 349, 339, 358, 0, 359, 335, 336, 341, 343, 344, - 345, 350, 351, 355, 361, 248, 209, 387, 396, 572, - 311, 215, 216, 217, 518, 519, 520, 521, 609, 610, - 614, 204, 459, 460, 461, 462, 291, 604, 308, 465, - 464, 330, 331, 376, 446, 534, 536, 547, 551, 553, - 555, 561, 564, 535, 537, 548, 552, 554, 556, 562, - 565, 524, 526, 528, 530, 543, 542, 539, 567, 568, - 545, 550, 529, 541, 546, 559, 566, 563, 523, 527, - 531, 540, 558, 557, 538, 549, 560, 544, 532, 525, - 533, 1352, 196, 220, 365, 1414, 451, 287, 639, 608, - 603, 205, 222, 1289, 261, 1301, 1309, 0, 1315, 1323, - 1324, 1336, 1339, 1340, 1341, 1342, 1360, 1361, 1363, 1371, - 1373, 1376, 1378, 1385, 1397, 1417, 198, 200, 208, 221, - 231, 235, 242, 260, 275, 277, 284, 297, 309, 317, - 318, 321, 327, 377, 383, 384, 385, 386, 406, 407, - 408, 411, 414, 415, 418, 420, 421, 424, 428, 432, - 433, 434, 436, 438, 440, 452, 457, 471, 472, 473, - 474, 475, 478, 479, 484, 485, 486, 487, 488, 496, - 497, 510, 580, 582, 597, 615, 621, 477, 300, 301, - 441, 442, 313, 314, 635, 636, 299, 592, 622, 590, - 634, 616, 435, 375, 1351, 1357, 378, 280, 304, 319, - 1366, 607, 498, 226, 463, 289, 250, 1384, 1386, 210, - 245, 229, 258, 273, 276, 323, 388, 397, 426, 431, - 295, 270, 243, 456, 240, 481, 513, 514, 515, 517, - 392, 265, 430, 1347, 1375, 373, 570, 571, 315, 393, - 0, 0, 0, 0, 1403, 1389, 522, 0, 1331, 1406, - 1300, 1319, 1416, 1322, 1325, 1368, 1278, 1346, 413, 1316, - 1271, 1304, 1273, 1311, 1274, 1302, 1333, 269, 1299, 1391, - 1350, 1405, 363, 266, 1280, 1305, 427, 1321, 203, 1370, - 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, - 382, 425, 512, 419, 1412, 367, 1356, 0, 493, 398, - 0, 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, - 1355, 1407, 1317, 1365, 1408, 322, 247, 324, 202, 410, - 494, 285, 0, 0, 0, 0, 0, 194, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, - 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, - 342, 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, - 320, 271, 263, 574, 1413, 1394, 1277, 1343, 1401, 1338, - 0, 0, 228, 1404, 1337, 0, 1367, 0, 1419, 1272, - 1358, 0, 1275, 1279, 1415, 1399, 1308, 274, 0, 0, - 0, 0, 0, 0, 0, 1334, 1345, 1379, 1383, 1328, - 0, 0, 0, 0, 0, 0, 3192, 0, 1306, 0, - 1354, 0, 0, 0, 1284, 1276, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1332, 0, - 0, 0, 0, 1287, 0, 1307, 1380, 0, 1270, 296, - 1281, 399, 256, 0, 450, 1387, 1398, 1329, 618, 1400, - 1327, 1326, 1374, 1285, 1393, 1320, 362, 1283, 329, 197, - 224, 0, 1318, 409, 458, 470, 1392, 1303, 1312, 252, - 1310, 468, 423, 596, 232, 283, 455, 429, 466, 437, - 286, 1353, 1372, 467, 369, 579, 447, 593, 619, 620, - 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, - 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, - 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, - 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, - 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, - 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, - 641, 227, 612, 219, 1282, 611, 405, 578, 589, 391, - 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, - 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, - 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, - 236, 1298, 278, 282, 290, 293, 302, 303, 312, 364, - 416, 443, 439, 448, 1388, 573, 594, 606, 617, 623, - 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, - 491, 332, 370, 1377, 1418, 422, 469, 239, 598, 492, - 199, 1292, 1297, 1290, 0, 253, 254, 1359, 569, 1293, - 1291, 1348, 1349, 1294, 1409, 1410, 1411, 1396, 643, 644, - 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, - 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, - 504, 505, 506, 507, 0, 509, 1381, 1286, 0, 1295, - 1296, 395, 1390, 585, 586, 661, 381, 482, 595, 334, - 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, - 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, - 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, - 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, - 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, - 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, - 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, - 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, - 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, - 525, 533, 1352, 196, 220, 365, 1414, 451, 287, 639, - 608, 603, 205, 222, 1289, 261, 1301, 1309, 0, 1315, - 1323, 1324, 1336, 1339, 1340, 1341, 1342, 1360, 1361, 1363, - 1371, 1373, 1376, 1378, 1385, 1397, 1417, 198, 200, 208, - 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, - 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, - 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, - 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, - 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, - 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, - 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, - 590, 634, 616, 435, 375, 1351, 1357, 378, 280, 304, - 319, 1366, 607, 498, 226, 463, 289, 250, 1384, 1386, - 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, - 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, - 517, 392, 265, 430, 1347, 1375, 373, 570, 571, 315, - 393, 0, 0, 0, 0, 1403, 1389, 522, 0, 1331, - 1406, 1300, 1319, 1416, 1322, 1325, 1368, 1278, 1346, 413, - 1316, 1271, 1304, 1273, 1311, 1274, 1302, 1333, 269, 1299, - 1391, 1350, 1405, 363, 266, 1280, 1305, 427, 1321, 203, - 1370, 483, 251, 374, 371, 577, 281, 272, 268, 249, - 316, 382, 425, 512, 419, 1412, 367, 1356, 0, 493, - 398, 0, 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, - 1288, 1355, 1407, 1317, 1365, 1408, 322, 247, 324, 202, - 410, 494, 285, 0, 0, 0, 0, 0, 711, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, - 0, 244, 0, 0, 0, 348, 357, 356, 337, 338, - 340, 342, 347, 354, 360, 1313, 1362, 1402, 1314, 1364, - 264, 320, 271, 263, 574, 1413, 1394, 1277, 1343, 1401, - 1338, 0, 0, 228, 1404, 1337, 0, 1367, 0, 1419, - 1272, 1358, 0, 1275, 1279, 1415, 1399, 1308, 274, 0, - 0, 0, 0, 0, 0, 0, 1334, 1345, 1379, 1383, - 1328, 0, 0, 0, 0, 0, 0, 3153, 0, 1306, - 0, 1354, 0, 0, 0, 1284, 1276, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1332, - 0, 0, 0, 0, 1287, 0, 1307, 1380, 0, 1270, - 296, 1281, 399, 256, 0, 450, 1387, 1398, 1329, 618, - 1400, 1327, 1326, 1374, 1285, 1393, 1320, 362, 1283, 329, - 197, 224, 0, 1318, 409, 458, 470, 1392, 1303, 1312, - 252, 1310, 468, 423, 596, 232, 283, 455, 429, 466, - 437, 286, 1353, 1372, 467, 369, 579, 447, 593, 619, - 620, 262, 403, 605, 516, 613, 637, 225, 259, 417, - 501, 599, 490, 394, 575, 576, 328, 489, 294, 201, - 366, 625, 223, 476, 368, 241, 230, 581, 602, 298, - 288, 453, 632, 212, 511, 591, 238, 480, 0, 0, - 640, 246, 500, 214, 588, 499, 390, 325, 326, 213, - 0, 454, 267, 292, 0, 0, 257, 412, 583, 584, - 255, 641, 227, 612, 219, 1282, 611, 405, 578, 589, - 391, 380, 218, 587, 389, 379, 333, 352, 353, 279, - 306, 444, 372, 445, 305, 307, 401, 400, 402, 206, - 600, 0, 207, 0, 495, 601, 642, 449, 211, 233, - 234, 236, 1298, 278, 282, 290, 293, 302, 303, 312, - 364, 416, 443, 439, 448, 1388, 573, 594, 606, 617, - 623, 624, 626, 627, 628, 629, 630, 633, 631, 404, - 310, 491, 332, 370, 1377, 1418, 422, 469, 239, 598, - 492, 199, 1292, 1297, 1290, 0, 253, 254, 1359, 569, - 1293, 1291, 1348, 1349, 1294, 1409, 1410, 1411, 1396, 643, - 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, - 654, 655, 656, 657, 658, 659, 660, 638, 502, 508, - 503, 504, 505, 506, 507, 0, 509, 1381, 1286, 0, - 1295, 1296, 395, 1390, 585, 586, 661, 381, 482, 595, - 334, 346, 349, 339, 358, 0, 359, 335, 336, 341, - 343, 344, 345, 350, 351, 355, 361, 248, 209, 387, - 396, 572, 311, 215, 216, 217, 518, 519, 520, 521, - 609, 610, 614, 204, 459, 460, 461, 462, 291, 604, - 308, 465, 464, 330, 331, 376, 446, 534, 536, 547, - 551, 553, 555, 561, 564, 535, 537, 548, 552, 554, - 556, 562, 565, 524, 526, 528, 530, 543, 542, 539, - 567, 568, 545, 550, 529, 541, 546, 559, 566, 563, - 523, 527, 531, 540, 558, 557, 538, 549, 560, 544, - 532, 525, 533, 1352, 196, 220, 365, 1414, 451, 287, - 639, 608, 603, 205, 222, 1289, 261, 1301, 1309, 0, - 1315, 1323, 1324, 1336, 1339, 1340, 1341, 1342, 1360, 1361, - 1363, 1371, 1373, 1376, 1378, 1385, 1397, 1417, 198, 200, - 208, 221, 231, 235, 242, 260, 275, 277, 284, 297, - 309, 317, 318, 321, 327, 377, 383, 384, 385, 386, - 406, 407, 408, 411, 414, 415, 418, 420, 421, 424, - 428, 432, 433, 434, 436, 438, 440, 452, 457, 471, - 472, 473, 474, 475, 478, 479, 484, 485, 486, 487, - 488, 496, 497, 510, 580, 582, 597, 615, 621, 477, - 300, 301, 441, 442, 313, 314, 635, 636, 299, 592, - 622, 590, 634, 616, 435, 375, 1351, 1357, 378, 280, - 304, 319, 1366, 607, 498, 226, 463, 289, 250, 1384, - 1386, 210, 245, 229, 258, 273, 276, 323, 388, 397, - 426, 431, 295, 270, 243, 456, 240, 481, 513, 514, - 515, 517, 392, 265, 430, 1347, 1375, 373, 570, 571, - 315, 393, 0, 0, 0, 0, 1403, 1389, 522, 0, + 0, 393, 0, 3428, 0, 4054, 1403, 1389, 522, 0, 1331, 1406, 1300, 1319, 1416, 1322, 1325, 1368, 1278, 1346, 413, 1316, 1271, 1304, 1273, 1311, 1274, 1302, 1333, 269, 1299, 1391, 1350, 1405, 363, 266, 1280, 1305, 427, 1321, @@ -3077,15 +2756,15 @@ var yyAct = [...]int{ 249, 316, 382, 425, 512, 419, 1412, 367, 1356, 0, 493, 398, 0, 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, 1407, 1317, 1365, 1408, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 944, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, + 202, 410, 494, 285, 0, 0, 0, 0, 4030, 944, + 0, 0, 0, 0, 4031, 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, 271, 263, 574, 1413, 1394, 1277, 1343, 1401, 1338, 0, 0, 228, 1404, 1337, 0, 1367, 0, 1419, 1272, 1358, 0, 1275, 1279, 1415, 1399, 1308, 274, 0, 0, 0, 0, 0, 0, 0, 1334, 1345, 1379, - 1383, 1328, 0, 0, 0, 0, 0, 0, 2370, 0, + 1383, 1328, 0, 0, 0, 0, 0, 0, 0, 0, 1306, 0, 1354, 0, 0, 0, 1284, 1276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3150,15 +2829,15 @@ var yyAct = [...]int{ 268, 249, 316, 382, 425, 512, 419, 1412, 367, 1356, 0, 493, 398, 0, 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, 1407, 1317, 1365, 1408, 322, 247, - 324, 202, 410, 494, 285, 0, 95, 0, 0, 0, - 711, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 324, 202, 410, 494, 285, 0, 0, 0, 0, 0, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, 271, 263, 574, 1413, 1394, 1277, 1343, 1401, 1338, 0, 0, 228, 1404, 1337, 0, 1367, 0, 1419, 1272, 1358, 0, 1275, 1279, 1415, 1399, 1308, 274, 0, 0, 0, 0, 0, 0, 0, 1334, 1345, - 1379, 1383, 1328, 0, 0, 0, 0, 0, 0, 0, + 1379, 1383, 1328, 0, 0, 0, 0, 0, 0, 3191, 0, 1306, 0, 1354, 0, 0, 0, 1284, 1276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3224,7 +2903,7 @@ var yyAct = [...]int{ 1356, 0, 493, 398, 0, 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, 1407, 1317, 1365, 1408, 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, 0, - 0, 194, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 711, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, 271, 263, 574, 1413, 1394, @@ -3232,7 +2911,7 @@ var yyAct = [...]int{ 1367, 0, 1419, 1272, 1358, 0, 1275, 1279, 1415, 1399, 1308, 274, 0, 0, 0, 0, 0, 0, 0, 1334, 1345, 1379, 1383, 1328, 0, 0, 0, 0, 0, 0, - 0, 0, 1306, 0, 1354, 0, 0, 0, 1284, 1276, + 3152, 0, 1306, 0, 1354, 0, 0, 0, 1284, 1276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3297,7 +2976,7 @@ var yyAct = [...]int{ 367, 1356, 0, 493, 398, 0, 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, 1407, 1317, 1365, 1408, 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, - 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 944, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, 271, 263, 574, 1413, @@ -3305,7 +2984,7 @@ var yyAct = [...]int{ 0, 1367, 0, 1419, 1272, 1358, 0, 1275, 1279, 1415, 1399, 1308, 274, 0, 0, 0, 0, 0, 0, 0, 1334, 1345, 1379, 1383, 1328, 0, 0, 0, 0, 0, - 0, 0, 0, 1306, 0, 1354, 0, 0, 0, 1284, + 0, 2369, 0, 1306, 0, 1354, 0, 0, 0, 1284, 1276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -3369,8 +3048,8 @@ var yyAct = [...]int{ 577, 281, 272, 268, 249, 316, 382, 425, 512, 419, 1412, 367, 1356, 0, 493, 398, 0, 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, 1407, 1317, 1365, - 1408, 322, 247, 324, 202, 410, 494, 285, 0, 0, - 0, 0, 0, 944, 0, 0, 0, 0, 0, 0, + 1408, 322, 247, 324, 202, 410, 494, 285, 0, 95, + 0, 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, 271, 263, 574, @@ -3435,891 +3114,1110 @@ var yyAct = [...]int{ 273, 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, 430, 1347, 1375, 373, 570, 571, 315, 393, 0, 0, 0, - 0, 0, 0, 522, 0, 764, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 751, 0, 0, 0, 269, 756, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 763, 367, 0, 0, 493, 398, 0, 0, 0, - 0, 0, 758, 759, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 0, 1008, 944, 735, 910, 948, 1009, 961, - 962, 963, 949, 0, 237, 950, 951, 244, 952, 0, - 909, 794, 796, 795, 859, 860, 861, 862, 863, 864, - 865, 792, 957, 964, 965, 0, 264, 320, 271, 263, - 574, 0, 0, 2191, 2192, 2193, 0, 0, 0, 228, - 0, 0, 0, 0, 0, 0, 0, 731, 748, 0, - 762, 0, 0, 0, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 745, 746, 0, 0, 0, 0, 904, 0, 747, - 0, 0, 755, 966, 967, 968, 969, 970, 971, 972, - 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, - 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, - 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, - 1003, 1004, 1005, 1006, 1007, 757, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 903, 0, 0, 618, 0, 0, 901, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 954, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 955, 956, 255, 641, 800, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 808, 809, 279, 306, 885, 884, 883, - 305, 307, 881, 882, 880, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 891, 913, 902, - 768, 769, 892, 893, 917, 894, 771, 772, 914, 915, - 765, 766, 770, 916, 918, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 905, 754, 753, 0, 760, 761, 0, - 790, 791, 793, 797, 798, 799, 810, 857, 858, 866, - 868, 869, 867, 870, 871, 872, 875, 876, 877, 878, - 873, 874, 879, 773, 777, 774, 775, 776, 788, 778, - 779, 780, 781, 782, 783, 784, 785, 786, 787, 789, - 928, 929, 930, 931, 932, 933, 803, 807, 806, 804, - 805, 801, 802, 829, 828, 830, 831, 832, 833, 834, - 835, 837, 836, 838, 839, 840, 841, 842, 843, 811, - 812, 815, 816, 814, 813, 817, 826, 827, 818, 819, - 820, 821, 822, 823, 825, 824, 844, 845, 846, 847, - 848, 850, 849, 853, 854, 852, 851, 856, 855, 752, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 919, 261, 920, 0, 0, 924, 0, 0, 0, - 926, 925, 0, 927, 889, 888, 0, 0, 921, 922, - 0, 923, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 934, 935, 936, 937, - 938, 939, 940, 941, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 959, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 764, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 751, 0, 0, 0, 269, - 756, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 763, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 0, 0, 2399, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 1008, 944, - 735, 910, 948, 1009, 961, 962, 963, 949, 0, 237, - 950, 951, 244, 952, 0, 909, 794, 796, 795, 859, - 860, 861, 862, 863, 864, 865, 792, 957, 964, 965, - 2400, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 731, 748, 0, 762, 0, 0, 0, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 745, 746, 0, 0, - 0, 0, 904, 0, 747, 0, 0, 755, 966, 967, - 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, - 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, - 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 757, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 903, 0, 0, - 618, 0, 0, 901, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 954, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 955, - 956, 255, 641, 800, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 808, 809, - 279, 306, 885, 884, 883, 305, 307, 881, 882, 880, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 891, 913, 902, 768, 769, 892, 893, 917, - 894, 771, 772, 914, 915, 765, 766, 770, 916, 918, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 905, 754, - 753, 0, 760, 761, 0, 790, 791, 793, 797, 798, - 799, 810, 857, 858, 866, 868, 869, 867, 870, 871, - 872, 875, 876, 877, 878, 873, 874, 879, 773, 777, - 774, 775, 776, 788, 778, 779, 780, 781, 782, 783, - 784, 785, 786, 787, 789, 928, 929, 930, 931, 932, - 933, 803, 807, 806, 804, 805, 801, 802, 829, 828, - 830, 831, 832, 833, 834, 835, 837, 836, 838, 839, - 840, 841, 842, 843, 811, 812, 815, 816, 814, 813, - 817, 826, 827, 818, 819, 820, 821, 822, 823, 825, - 824, 844, 845, 846, 847, 848, 850, 849, 853, 854, - 852, 851, 856, 855, 752, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 919, 261, 920, 0, - 0, 924, 0, 0, 0, 926, 925, 0, 927, 889, - 888, 0, 0, 921, 922, 0, 923, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 934, 935, 936, 937, 938, 939, 940, 941, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 959, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 86, 522, 0, 764, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 751, 0, 0, 0, 269, 756, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 763, 367, 0, 0, 493, 398, 0, 0, 0, - 0, 0, 758, 759, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 0, 1008, 944, 735, 910, 948, 1009, 961, - 962, 963, 949, 0, 237, 950, 951, 244, 952, 0, - 909, 794, 796, 795, 859, 860, 861, 862, 863, 864, - 865, 792, 957, 964, 965, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, - 0, 0, 0, 0, 0, 0, 0, 731, 748, 0, - 762, 0, 0, 0, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 745, 746, 0, 0, 0, 0, 904, 0, 747, - 0, 0, 755, 966, 967, 968, 969, 970, 971, 972, - 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, - 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, - 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, - 1003, 1004, 1005, 1006, 1007, 757, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 903, 0, 0, 618, 0, 0, 901, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 954, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 955, 956, 255, 641, 800, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 808, 809, 279, 306, 885, 884, 883, - 305, 307, 881, 882, 880, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 891, 913, 902, - 768, 769, 892, 893, 917, 894, 771, 772, 914, 915, - 765, 766, 770, 916, 918, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 905, 754, 753, 0, 760, 761, 0, - 790, 791, 793, 797, 798, 799, 810, 857, 858, 866, - 868, 869, 867, 870, 871, 872, 875, 876, 877, 878, - 873, 874, 879, 773, 777, 774, 775, 776, 788, 778, - 779, 780, 781, 782, 783, 784, 785, 786, 787, 789, - 928, 929, 930, 931, 932, 933, 803, 807, 806, 804, - 805, 801, 802, 829, 828, 830, 831, 832, 833, 834, - 835, 837, 836, 838, 839, 840, 841, 842, 843, 811, - 812, 815, 816, 814, 813, 817, 826, 827, 818, 819, - 820, 821, 822, 823, 825, 824, 844, 845, 846, 847, - 848, 850, 849, 853, 854, 852, 851, 856, 855, 752, - 196, 220, 365, 94, 451, 287, 639, 608, 603, 205, - 222, 919, 261, 920, 0, 0, 924, 0, 0, 0, - 926, 925, 0, 927, 889, 888, 0, 0, 921, 922, - 0, 923, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 934, 935, 936, 937, - 938, 939, 940, 941, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 959, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 764, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 751, 0, 0, 0, 269, - 756, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 763, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 1008, 944, - 735, 910, 948, 1009, 961, 962, 963, 949, 0, 237, - 950, 951, 244, 952, 0, 909, 794, 796, 795, 859, - 860, 861, 862, 863, 864, 865, 792, 957, 964, 965, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 731, 748, 0, 762, 0, 0, 0, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 745, 746, 0, 0, - 0, 0, 904, 0, 747, 0, 0, 755, 966, 967, - 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, - 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, - 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 757, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 903, 0, 0, - 618, 0, 0, 901, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 954, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 4017, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 955, - 956, 255, 641, 800, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 808, 809, - 279, 306, 885, 884, 883, 305, 307, 881, 882, 880, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 891, 913, 902, 768, 769, 892, 893, 917, - 894, 771, 772, 914, 915, 765, 766, 770, 916, 918, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 905, 754, - 753, 0, 760, 761, 0, 790, 791, 793, 797, 798, - 799, 810, 857, 858, 866, 868, 869, 867, 870, 871, - 872, 875, 876, 877, 878, 873, 874, 879, 773, 777, - 774, 775, 776, 788, 778, 779, 780, 781, 782, 783, - 784, 785, 786, 787, 789, 928, 929, 930, 931, 932, - 933, 803, 807, 806, 804, 805, 801, 802, 829, 828, - 830, 831, 832, 833, 834, 835, 837, 836, 838, 839, - 840, 841, 842, 843, 811, 812, 815, 816, 814, 813, - 817, 826, 827, 818, 819, 820, 821, 822, 823, 825, - 824, 844, 845, 846, 847, 848, 850, 849, 853, 854, - 852, 851, 856, 855, 752, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 919, 261, 920, 0, - 0, 924, 0, 0, 0, 926, 925, 0, 927, 889, - 888, 0, 0, 921, 922, 0, 923, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 934, 935, 936, 937, 938, 939, 940, 941, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 959, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 764, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 751, 0, 0, 0, 269, 756, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, + 0, 1403, 1389, 522, 0, 1331, 1406, 1300, 1319, 1416, + 1322, 1325, 1368, 1278, 1346, 413, 1316, 1271, 1304, 1273, + 1311, 1274, 1302, 1333, 269, 1299, 1391, 1350, 1405, 363, + 266, 1280, 1305, 427, 1321, 203, 1370, 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 763, 367, 0, 0, 493, 398, 0, 0, 0, - 0, 0, 758, 759, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 1725, 1008, 944, 735, 910, 948, 1009, 961, - 962, 963, 949, 0, 237, 950, 951, 244, 952, 0, - 909, 794, 796, 795, 859, 860, 861, 862, 863, 864, - 865, 792, 957, 964, 965, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, - 0, 0, 0, 0, 0, 0, 0, 731, 748, 0, - 762, 0, 0, 0, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 745, 746, 0, 0, 0, 0, 904, 0, 747, - 0, 0, 755, 966, 967, 968, 969, 970, 971, 972, - 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, - 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, - 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, - 1003, 1004, 1005, 1006, 1007, 757, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 903, 0, 0, 618, 0, 0, 901, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 954, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, + 419, 1412, 367, 1356, 0, 493, 398, 0, 0, 0, + 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, 1407, 1317, + 1365, 1408, 322, 247, 324, 202, 410, 494, 285, 0, + 0, 0, 0, 0, 194, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, + 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, + 360, 1313, 1362, 1402, 1314, 1364, 264, 320, 271, 263, + 574, 1413, 1394, 1277, 1343, 1401, 1338, 0, 0, 228, + 1404, 1337, 0, 1367, 0, 1419, 1272, 1358, 0, 1275, + 1279, 1415, 1399, 1308, 274, 0, 0, 0, 0, 0, + 0, 0, 1334, 1345, 1379, 1383, 1328, 0, 0, 0, + 0, 0, 0, 0, 0, 1306, 0, 1354, 0, 0, + 0, 1284, 1276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1332, 0, 0, 0, 0, + 1287, 0, 1307, 1380, 0, 1270, 296, 1281, 399, 256, + 0, 450, 1387, 1398, 1329, 618, 1400, 1327, 1326, 1374, + 1285, 1393, 1320, 362, 1283, 329, 197, 224, 0, 1318, + 409, 458, 470, 1392, 1303, 1312, 252, 1310, 468, 423, + 596, 232, 283, 455, 429, 466, 437, 286, 1353, 1372, 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 955, 956, 255, 641, 800, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 808, 809, 279, 306, 885, 884, 883, - 305, 307, 881, 882, 880, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, + 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, + 219, 1282, 611, 405, 578, 589, 391, 380, 218, 587, + 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, + 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, + 495, 601, 642, 449, 211, 233, 234, 236, 1298, 278, 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, + 448, 1388, 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 891, 913, 902, - 768, 769, 892, 893, 917, 894, 771, 772, 914, 915, - 765, 766, 770, 916, 918, 643, 644, 645, 646, 647, + 1377, 1418, 422, 469, 239, 598, 492, 199, 1292, 1297, + 1290, 0, 253, 254, 1359, 569, 1293, 1291, 1348, 1349, + 1294, 1409, 1410, 1411, 1396, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 905, 754, 753, 0, 760, 761, 0, - 790, 791, 793, 797, 798, 799, 810, 857, 858, 866, - 868, 869, 867, 870, 871, 872, 875, 876, 877, 878, - 873, 874, 879, 773, 777, 774, 775, 776, 788, 778, - 779, 780, 781, 782, 783, 784, 785, 786, 787, 789, - 928, 929, 930, 931, 932, 933, 803, 807, 806, 804, - 805, 801, 802, 829, 828, 830, 831, 832, 833, 834, - 835, 837, 836, 838, 839, 840, 841, 842, 843, 811, - 812, 815, 816, 814, 813, 817, 826, 827, 818, 819, - 820, 821, 822, 823, 825, 824, 844, 845, 846, 847, - 848, 850, 849, 853, 854, 852, 851, 856, 855, 752, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 919, 261, 920, 0, 0, 924, 0, 0, 0, - 926, 925, 0, 927, 889, 888, 0, 0, 921, 922, - 0, 923, 0, 0, 198, 200, 208, 221, 231, 235, + 507, 0, 509, 1381, 1286, 0, 1295, 1296, 395, 1390, + 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, + 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, + 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, + 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, + 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, + 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, + 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, + 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, + 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, + 558, 557, 538, 549, 560, 544, 532, 525, 533, 1352, + 196, 220, 365, 1414, 451, 287, 639, 608, 603, 205, + 222, 1289, 261, 1301, 1309, 0, 1315, 1323, 1324, 1336, + 1339, 1340, 1341, 1342, 1360, 1361, 1363, 1371, 1373, 1376, + 1378, 1385, 1397, 1417, 198, 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 934, 935, 936, 937, - 938, 939, 940, 941, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 959, 0, 210, 245, 229, + 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, + 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, + 435, 375, 1351, 1357, 378, 280, 304, 319, 1366, 607, + 498, 226, 463, 289, 250, 1384, 1386, 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 764, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 751, 0, 0, 0, 269, - 756, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 763, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 1008, 944, - 735, 910, 948, 1009, 961, 962, 963, 949, 0, 237, - 950, 951, 244, 952, 0, 909, 794, 796, 795, 859, - 860, 861, 862, 863, 864, 865, 792, 957, 964, 965, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 731, 748, 0, 762, 0, 0, 0, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 745, 746, 1054, 0, - 0, 0, 904, 0, 747, 0, 0, 755, 966, 967, - 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, - 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, - 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 757, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 903, 0, 0, - 618, 0, 0, 901, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 954, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 955, - 956, 255, 641, 800, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 808, 809, - 279, 306, 885, 884, 883, 305, 307, 881, 882, 880, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 891, 913, 902, 768, 769, 892, 893, 917, - 894, 771, 772, 914, 915, 765, 766, 770, 916, 918, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 905, 754, - 753, 0, 760, 761, 0, 790, 791, 793, 797, 798, - 799, 810, 857, 858, 866, 868, 869, 867, 870, 871, - 872, 875, 876, 877, 878, 873, 874, 879, 773, 777, - 774, 775, 776, 788, 778, 779, 780, 781, 782, 783, - 784, 785, 786, 787, 789, 928, 929, 930, 931, 932, - 933, 803, 807, 806, 804, 805, 801, 802, 829, 828, - 830, 831, 832, 833, 834, 835, 837, 836, 838, 839, - 840, 841, 842, 843, 811, 812, 815, 816, 814, 813, - 817, 826, 827, 818, 819, 820, 821, 822, 823, 825, - 824, 844, 845, 846, 847, 848, 850, 849, 853, 854, - 852, 851, 856, 855, 752, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 919, 261, 920, 0, - 0, 924, 0, 0, 0, 926, 925, 0, 927, 889, - 888, 0, 0, 921, 922, 0, 923, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 934, 935, 936, 937, 938, 939, 940, 941, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 959, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 764, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 751, 0, 0, 0, 269, 756, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 763, 367, 0, 0, 493, 398, 0, 0, 0, - 0, 0, 758, 759, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 0, 1008, 944, 735, 910, 948, 1009, 961, - 962, 963, 949, 0, 237, 950, 951, 244, 952, 0, - 909, 794, 796, 795, 859, 860, 861, 862, 863, 864, - 865, 792, 957, 964, 965, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, - 0, 0, 0, 0, 0, 0, 0, 731, 748, 0, - 762, 0, 0, 0, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 745, 746, 0, 0, 0, 0, 904, 0, 747, - 0, 0, 755, 966, 967, 968, 969, 970, 971, 972, - 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, - 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, - 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, - 1003, 1004, 1005, 1006, 1007, 757, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 903, 0, 0, 618, 0, 0, 901, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 954, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 955, 956, 255, 641, 800, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 808, 809, 279, 306, 885, 884, 883, - 305, 307, 881, 882, 880, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 891, 913, 902, - 768, 769, 892, 893, 917, 894, 771, 772, 914, 915, - 765, 766, 770, 916, 918, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 905, 754, 753, 0, 760, 761, 0, - 790, 791, 793, 797, 798, 799, 810, 857, 858, 866, - 868, 869, 867, 870, 871, 872, 875, 876, 877, 878, - 873, 874, 879, 773, 777, 774, 775, 776, 788, 778, - 779, 780, 781, 782, 783, 784, 785, 786, 787, 789, - 928, 929, 930, 931, 932, 933, 803, 807, 806, 804, - 805, 801, 802, 829, 828, 830, 831, 832, 833, 834, - 835, 837, 836, 838, 839, 840, 841, 842, 843, 811, - 812, 815, 816, 814, 813, 817, 826, 827, 818, 819, - 820, 821, 822, 823, 825, 824, 844, 845, 846, 847, - 848, 850, 849, 853, 854, 852, 851, 856, 855, 752, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 919, 261, 920, 0, 0, 924, 0, 0, 0, - 926, 925, 0, 927, 889, 888, 0, 0, 921, 922, - 0, 923, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 934, 935, 936, 937, - 938, 939, 940, 941, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 959, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 764, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 751, 0, 0, 0, 269, - 756, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 763, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 1008, 944, - 735, 910, 948, 1009, 961, 962, 963, 949, 0, 237, - 950, 951, 244, 952, 0, 909, 794, 796, 795, 859, - 860, 861, 862, 863, 864, 865, 792, 957, 964, 965, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 731, 748, 0, 762, 0, 0, 0, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 745, 746, 0, 0, - 0, 0, 904, 0, 747, 0, 0, 755, 966, 967, - 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, - 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, - 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 3110, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 903, 0, 0, - 618, 0, 0, 901, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 954, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 955, - 956, 255, 641, 800, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 808, 809, - 279, 306, 885, 884, 883, 305, 307, 881, 882, 880, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 891, 913, 902, 768, 769, 892, 893, 917, - 894, 771, 772, 914, 915, 765, 766, 770, 916, 918, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 905, 754, - 753, 0, 760, 761, 0, 790, 791, 793, 797, 798, - 799, 810, 857, 858, 866, 868, 869, 867, 870, 871, - 872, 875, 876, 877, 878, 873, 874, 879, 773, 777, - 774, 775, 776, 788, 778, 779, 780, 781, 782, 783, - 784, 785, 786, 787, 789, 928, 929, 930, 931, 932, - 933, 803, 807, 806, 804, 805, 801, 802, 829, 828, - 830, 831, 832, 833, 834, 835, 837, 836, 838, 839, - 840, 841, 842, 843, 811, 812, 815, 816, 814, 813, - 817, 826, 827, 818, 819, 820, 821, 822, 823, 825, - 824, 844, 845, 846, 847, 848, 850, 849, 853, 854, - 852, 851, 856, 855, 752, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 919, 261, 920, 0, - 0, 924, 0, 0, 0, 926, 925, 0, 927, 889, - 888, 0, 0, 921, 922, 0, 923, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 934, 935, 936, 937, 938, 939, 940, 941, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 959, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 764, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 751, 0, 0, 0, 269, 756, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 763, 367, 0, 0, 493, 398, 0, 0, 0, - 0, 0, 758, 759, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 0, 1008, 944, 735, 910, 948, 1009, 961, - 962, 963, 949, 0, 237, 950, 951, 244, 952, 0, - 909, 794, 796, 795, 859, 860, 861, 862, 863, 864, - 865, 792, 957, 964, 965, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, - 0, 0, 0, 0, 0, 0, 0, 731, 748, 0, - 762, 0, 0, 0, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 745, 746, 0, 0, 0, 0, 904, 0, 747, - 0, 0, 755, 966, 967, 968, 969, 970, 971, 972, - 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, - 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, - 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, - 1003, 1004, 1005, 1006, 1007, 3106, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 903, 0, 0, 618, 0, 0, 901, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 954, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 955, 956, 255, 641, 800, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 808, 809, 279, 306, 885, 884, 883, - 305, 307, 881, 882, 880, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 891, 913, 902, - 768, 769, 892, 893, 917, 894, 771, 772, 914, 915, - 765, 766, 770, 916, 918, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 905, 754, 753, 0, 760, 761, 0, - 790, 791, 793, 797, 798, 799, 810, 857, 858, 866, - 868, 869, 867, 870, 871, 872, 875, 876, 877, 878, - 873, 874, 879, 773, 777, 774, 775, 776, 788, 778, - 779, 780, 781, 782, 783, 784, 785, 786, 787, 789, - 928, 929, 930, 931, 932, 933, 803, 807, 806, 804, - 805, 801, 802, 829, 828, 830, 831, 832, 833, 834, - 835, 837, 836, 838, 839, 840, 841, 842, 843, 811, - 812, 815, 816, 814, 813, 817, 826, 827, 818, 819, - 820, 821, 822, 823, 825, 824, 844, 845, 846, 847, - 848, 850, 849, 853, 854, 852, 851, 856, 855, 752, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 919, 261, 920, 0, 0, 924, 0, 0, 0, - 926, 925, 0, 927, 889, 888, 0, 0, 921, 922, - 0, 923, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 934, 935, 936, 937, - 938, 939, 940, 941, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 959, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 764, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 751, 0, 0, 0, 269, - 756, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 763, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 1008, 944, - 1075, 910, 948, 1009, 961, 962, 963, 949, 0, 237, - 950, 951, 244, 952, 0, 909, 794, 796, 795, 859, - 860, 861, 862, 863, 864, 865, 792, 957, 964, 965, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 748, 0, 762, 0, 0, 0, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 745, 746, 0, 0, - 0, 0, 904, 0, 747, 0, 0, 755, 966, 967, - 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, - 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, - 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 757, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 903, 0, 0, - 618, 0, 0, 901, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 954, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 955, - 956, 255, 641, 800, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 808, 809, - 279, 306, 885, 884, 883, 305, 307, 881, 882, 880, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 891, 913, 902, 768, 769, 892, 893, 917, - 894, 771, 772, 914, 915, 765, 766, 770, 916, 918, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 905, 754, - 753, 0, 760, 761, 0, 790, 791, 793, 797, 798, - 799, 810, 857, 858, 866, 868, 869, 867, 870, 871, - 872, 875, 876, 877, 878, 873, 874, 879, 773, 777, - 774, 775, 776, 788, 778, 779, 780, 781, 782, 783, - 784, 785, 786, 787, 789, 928, 929, 930, 931, 932, - 933, 803, 807, 806, 804, 805, 801, 802, 829, 828, - 830, 831, 832, 833, 834, 835, 837, 836, 838, 839, - 840, 841, 842, 843, 811, 812, 815, 816, 814, 813, - 817, 826, 827, 818, 819, 820, 821, 822, 823, 825, - 824, 844, 845, 846, 847, 848, 850, 849, 853, 854, - 852, 851, 856, 855, 752, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 919, 261, 920, 0, - 0, 924, 0, 0, 0, 926, 925, 0, 927, 889, - 888, 0, 0, 921, 922, 0, 923, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 934, 935, 936, 937, 938, 939, 940, 941, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 959, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 764, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 751, 0, 0, 0, 269, 756, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 763, 367, 0, 0, 493, 398, 0, 0, 0, - 0, 0, 758, 759, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 0, 1008, 944, 1075, 910, 948, 1009, 961, - 962, 963, 949, 0, 237, 950, 951, 244, 952, 0, - 909, 794, 796, 795, 859, 860, 861, 862, 863, 864, - 865, 792, 957, 964, 965, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, - 0, 0, 0, 0, 0, 0, 0, 0, 748, 0, - 762, 0, 0, 0, 274, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 745, 746, 0, 0, 0, 0, 904, 0, 747, - 0, 0, 755, 966, 967, 968, 969, 970, 971, 972, - 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, - 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, - 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, - 1003, 1004, 1005, 1006, 1007, 2084, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 903, 0, 0, 618, 0, 0, 901, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 954, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 955, 956, 255, 641, 800, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 808, 809, 279, 306, 885, 884, 883, - 305, 307, 881, 882, 880, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 891, 913, 902, - 768, 769, 892, 893, 917, 894, 771, 772, 914, 915, - 765, 766, 770, 916, 918, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 905, 754, 753, 0, 760, 761, 0, - 790, 791, 793, 797, 798, 799, 810, 857, 858, 866, - 868, 869, 867, 870, 871, 872, 875, 876, 877, 878, - 873, 874, 879, 773, 777, 774, 775, 776, 788, 778, - 779, 780, 781, 782, 783, 784, 785, 786, 787, 789, - 928, 929, 930, 931, 932, 933, 803, 807, 806, 804, - 805, 801, 802, 829, 828, 830, 831, 832, 833, 834, - 835, 837, 836, 838, 839, 840, 841, 842, 843, 811, - 812, 815, 816, 814, 813, 817, 826, 827, 818, 819, - 820, 821, 822, 823, 825, 824, 844, 845, 846, 847, - 848, 850, 849, 853, 854, 852, 851, 856, 855, 752, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 919, 261, 920, 0, 0, 924, 0, 0, 0, - 926, 925, 0, 927, 889, 888, 0, 0, 921, 922, - 0, 923, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 934, 935, 936, 937, - 938, 939, 940, 941, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 959, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 764, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 751, 0, 0, 0, 269, - 756, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 763, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 1008, 944, - 1075, 910, 948, 1009, 961, 962, 963, 949, 0, 237, - 950, 951, 244, 952, 0, 909, 794, 796, 795, 859, - 860, 861, 862, 863, 864, 865, 792, 957, 964, 965, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 748, 0, 762, 0, 0, 0, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 745, 746, 0, 0, - 0, 0, 904, 0, 747, 0, 0, 755, 966, 967, - 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, - 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, - 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 2082, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 903, 0, 0, - 618, 0, 0, 901, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 954, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 955, - 956, 255, 641, 800, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 808, 809, - 279, 306, 885, 884, 883, 305, 307, 881, 882, 880, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 891, 913, 902, 768, 769, 892, 893, 917, - 894, 771, 772, 914, 915, 765, 766, 770, 916, 918, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 905, 754, - 753, 0, 760, 761, 0, 790, 791, 793, 797, 798, - 799, 810, 857, 858, 866, 868, 869, 867, 870, 871, - 872, 875, 876, 877, 878, 873, 874, 879, 773, 777, - 774, 775, 776, 788, 778, 779, 780, 781, 782, 783, - 784, 785, 786, 787, 789, 928, 929, 930, 931, 932, - 933, 803, 807, 806, 804, 805, 801, 802, 829, 828, - 830, 831, 832, 833, 834, 835, 837, 836, 838, 839, - 840, 841, 842, 843, 811, 812, 815, 816, 814, 813, - 817, 826, 827, 818, 819, 820, 821, 822, 823, 825, - 824, 844, 845, 846, 847, 848, 850, 849, 853, 854, - 852, 851, 856, 855, 752, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 919, 261, 920, 0, - 0, 924, 0, 0, 0, 926, 925, 0, 927, 889, - 888, 0, 0, 921, 922, 0, 923, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 934, 935, 936, 937, 938, 939, 940, 941, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 959, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 430, 1347, 1375, 373, 570, 571, 315, 393, 0, 0, + 0, 0, 1403, 1389, 522, 0, 1331, 1406, 1300, 1319, + 1416, 1322, 1325, 1368, 1278, 1346, 413, 1316, 1271, 1304, + 1273, 1311, 1274, 1302, 1333, 269, 1299, 1391, 1350, 1405, + 363, 266, 1280, 1305, 427, 1321, 203, 1370, 483, 251, + 374, 371, 577, 281, 272, 268, 249, 316, 382, 425, + 512, 419, 1412, 367, 1356, 0, 493, 398, 0, 0, + 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, 1407, + 1317, 1365, 1408, 322, 247, 324, 202, 410, 494, 285, + 0, 0, 0, 0, 0, 711, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 237, 0, 0, 244, 0, + 0, 0, 348, 357, 356, 337, 338, 340, 342, 347, + 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, 271, + 263, 574, 1413, 1394, 1277, 1343, 1401, 1338, 0, 0, + 228, 1404, 1337, 0, 1367, 0, 1419, 1272, 1358, 0, + 1275, 1279, 1415, 1399, 1308, 274, 0, 0, 0, 0, + 0, 0, 0, 1334, 1345, 1379, 1383, 1328, 0, 0, + 0, 0, 0, 0, 0, 0, 1306, 0, 1354, 0, + 0, 0, 1284, 1276, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1332, 0, 0, 0, + 0, 1287, 0, 1307, 1380, 0, 1270, 296, 1281, 399, + 256, 0, 450, 1387, 1398, 1329, 618, 1400, 1327, 1326, + 1374, 1285, 1393, 1320, 362, 1283, 329, 197, 224, 0, + 1318, 409, 458, 470, 1392, 1303, 1312, 252, 1310, 468, + 423, 596, 232, 283, 455, 429, 466, 437, 286, 1353, + 1372, 467, 369, 579, 447, 593, 619, 620, 262, 403, + 605, 516, 613, 637, 225, 259, 417, 501, 599, 490, + 394, 575, 576, 328, 489, 294, 201, 366, 625, 223, + 476, 368, 241, 230, 581, 602, 298, 288, 453, 632, + 212, 511, 591, 238, 480, 0, 0, 640, 246, 500, + 214, 588, 499, 390, 325, 326, 213, 0, 454, 267, + 292, 0, 0, 257, 412, 583, 584, 255, 641, 227, + 612, 219, 1282, 611, 405, 578, 589, 391, 380, 218, + 587, 389, 379, 333, 352, 353, 279, 306, 444, 372, + 445, 305, 307, 401, 400, 402, 206, 600, 0, 207, + 0, 495, 601, 642, 449, 211, 233, 234, 236, 1298, + 278, 282, 290, 293, 302, 303, 312, 364, 416, 443, + 439, 448, 1388, 573, 594, 606, 617, 623, 624, 626, + 627, 628, 629, 630, 633, 631, 404, 310, 491, 332, + 370, 1377, 1418, 422, 469, 239, 598, 492, 199, 1292, + 1297, 1290, 0, 253, 254, 1359, 569, 1293, 1291, 1348, + 1349, 1294, 1409, 1410, 1411, 1396, 643, 644, 645, 646, + 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, + 657, 658, 659, 660, 638, 502, 508, 503, 504, 505, + 506, 507, 0, 509, 1381, 1286, 0, 1295, 1296, 395, + 1390, 585, 586, 661, 381, 482, 595, 334, 346, 349, + 339, 358, 0, 359, 335, 336, 341, 343, 344, 345, + 350, 351, 355, 361, 248, 209, 387, 396, 572, 311, + 215, 216, 217, 518, 519, 520, 521, 609, 610, 614, + 204, 459, 460, 461, 462, 291, 604, 308, 465, 464, + 330, 331, 376, 446, 534, 536, 547, 551, 553, 555, + 561, 564, 535, 537, 548, 552, 554, 556, 562, 565, + 524, 526, 528, 530, 543, 542, 539, 567, 568, 545, + 550, 529, 541, 546, 559, 566, 563, 523, 527, 531, + 540, 558, 557, 538, 549, 560, 544, 532, 525, 533, + 1352, 196, 220, 365, 1414, 451, 287, 639, 608, 603, + 205, 222, 1289, 261, 1301, 1309, 0, 1315, 1323, 1324, + 1336, 1339, 1340, 1341, 1342, 1360, 1361, 1363, 1371, 1373, + 1376, 1378, 1385, 1397, 1417, 198, 200, 208, 221, 231, + 235, 242, 260, 275, 277, 284, 297, 309, 317, 318, + 321, 327, 377, 383, 384, 385, 386, 406, 407, 408, + 411, 414, 415, 418, 420, 421, 424, 428, 432, 433, + 434, 436, 438, 440, 452, 457, 471, 472, 473, 474, + 475, 478, 479, 484, 485, 486, 487, 488, 496, 497, + 510, 580, 582, 597, 615, 621, 477, 300, 301, 441, + 442, 313, 314, 635, 636, 299, 592, 622, 590, 634, + 616, 435, 375, 1351, 1357, 378, 280, 304, 319, 1366, + 607, 498, 226, 463, 289, 250, 1384, 1386, 210, 245, + 229, 258, 273, 276, 323, 388, 397, 426, 431, 295, + 270, 243, 456, 240, 481, 513, 514, 515, 517, 392, + 265, 430, 1347, 1375, 373, 570, 571, 315, 393, 0, + 0, 0, 0, 1403, 1389, 522, 0, 1331, 1406, 1300, + 1319, 1416, 1322, 1325, 1368, 1278, 1346, 413, 1316, 1271, + 1304, 1273, 1311, 1274, 1302, 1333, 269, 1299, 1391, 1350, + 1405, 363, 266, 1280, 1305, 427, 1321, 203, 1370, 483, + 251, 374, 371, 577, 281, 272, 268, 249, 316, 382, + 425, 512, 419, 1412, 367, 1356, 0, 493, 398, 0, + 0, 0, 1335, 1395, 1344, 1382, 1330, 1369, 1288, 1355, + 1407, 1317, 1365, 1408, 322, 247, 324, 202, 410, 494, + 285, 0, 0, 0, 0, 0, 944, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 237, 0, 0, 244, + 0, 0, 0, 348, 357, 356, 337, 338, 340, 342, + 347, 354, 360, 1313, 1362, 1402, 1314, 1364, 264, 320, + 271, 263, 574, 1413, 1394, 1277, 1343, 1401, 1338, 0, + 0, 228, 1404, 1337, 0, 1367, 0, 1419, 1272, 1358, + 0, 1275, 1279, 1415, 1399, 1308, 274, 0, 0, 0, + 0, 0, 0, 0, 1334, 1345, 1379, 1383, 1328, 0, + 0, 0, 0, 0, 0, 0, 0, 1306, 0, 1354, + 0, 0, 0, 1284, 1276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1332, 0, 0, + 0, 0, 1287, 0, 1307, 1380, 0, 1270, 296, 1281, + 399, 256, 0, 450, 1387, 1398, 1329, 618, 1400, 1327, + 1326, 1374, 1285, 1393, 1320, 362, 1283, 329, 197, 224, + 0, 1318, 409, 458, 470, 1392, 1303, 1312, 252, 1310, + 468, 423, 596, 232, 283, 455, 429, 466, 437, 286, + 1353, 1372, 467, 369, 579, 447, 593, 619, 620, 262, + 403, 605, 516, 613, 637, 225, 259, 417, 501, 599, + 490, 394, 575, 576, 328, 489, 294, 201, 366, 625, + 223, 476, 368, 241, 230, 581, 602, 298, 288, 453, + 632, 212, 511, 591, 238, 480, 0, 0, 640, 246, + 500, 214, 588, 499, 390, 325, 326, 213, 0, 454, + 267, 292, 0, 0, 257, 412, 583, 584, 255, 641, + 227, 612, 219, 1282, 611, 405, 578, 589, 391, 380, + 218, 587, 389, 379, 333, 352, 353, 279, 306, 444, + 372, 445, 305, 307, 401, 400, 402, 206, 600, 0, + 207, 0, 495, 601, 642, 449, 211, 233, 234, 236, + 1298, 278, 282, 290, 293, 302, 303, 312, 364, 416, + 443, 439, 448, 1388, 573, 594, 606, 617, 623, 624, + 626, 627, 628, 629, 630, 633, 631, 404, 310, 491, + 332, 370, 1377, 1418, 422, 469, 239, 598, 492, 199, + 1292, 1297, 1290, 0, 253, 254, 1359, 569, 1293, 1291, + 1348, 1349, 1294, 1409, 1410, 1411, 1396, 643, 644, 645, + 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, + 656, 657, 658, 659, 660, 638, 502, 508, 503, 504, + 505, 506, 507, 0, 509, 1381, 1286, 0, 1295, 1296, + 395, 1390, 585, 586, 661, 381, 482, 595, 334, 346, + 349, 339, 358, 0, 359, 335, 336, 341, 343, 344, + 345, 350, 351, 355, 361, 248, 209, 387, 396, 572, + 311, 215, 216, 217, 518, 519, 520, 521, 609, 610, + 614, 204, 459, 460, 461, 462, 291, 604, 308, 465, + 464, 330, 331, 376, 446, 534, 536, 547, 551, 553, + 555, 561, 564, 535, 537, 548, 552, 554, 556, 562, + 565, 524, 526, 528, 530, 543, 542, 539, 567, 568, + 545, 550, 529, 541, 546, 559, 566, 563, 523, 527, + 531, 540, 558, 557, 538, 549, 560, 544, 532, 525, + 533, 1352, 196, 220, 365, 1414, 451, 287, 639, 608, + 603, 205, 222, 1289, 261, 1301, 1309, 0, 1315, 1323, + 1324, 1336, 1339, 1340, 1341, 1342, 1360, 1361, 1363, 1371, + 1373, 1376, 1378, 1385, 1397, 1417, 198, 200, 208, 221, + 231, 235, 242, 260, 275, 277, 284, 297, 309, 317, + 318, 321, 327, 377, 383, 384, 385, 386, 406, 407, + 408, 411, 414, 415, 418, 420, 421, 424, 428, 432, + 433, 434, 436, 438, 440, 452, 457, 471, 472, 473, + 474, 475, 478, 479, 484, 485, 486, 487, 488, 496, + 497, 510, 580, 582, 597, 615, 621, 477, 300, 301, + 441, 442, 313, 314, 635, 636, 299, 592, 622, 590, + 634, 616, 435, 375, 1351, 1357, 378, 280, 304, 319, + 1366, 607, 498, 226, 463, 289, 250, 1384, 1386, 210, + 245, 229, 258, 273, 276, 323, 388, 397, 426, 431, + 295, 270, 243, 456, 240, 481, 513, 514, 515, 517, + 392, 265, 430, 1347, 1375, 373, 570, 571, 315, 393, + 0, 0, 0, 0, 0, 0, 522, 0, 764, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 751, 0, 0, 0, 269, 756, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 763, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 758, 759, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 0, 1008, 944, 735, 910, + 948, 1009, 961, 962, 963, 949, 0, 237, 950, 951, + 244, 952, 0, 909, 794, 796, 795, 859, 860, 861, + 862, 863, 864, 865, 792, 957, 964, 965, 0, 264, + 320, 271, 263, 574, 0, 0, 2191, 2192, 2193, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 731, 748, 0, 762, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 745, 746, 0, 0, 0, 0, + 904, 0, 747, 0, 0, 755, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, + 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 757, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 903, 0, 0, 618, 0, + 0, 901, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 954, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 955, 956, 255, + 641, 800, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 808, 809, 279, 306, + 885, 884, 883, 305, 307, 881, 882, 880, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 891, 913, 902, 768, 769, 892, 893, 917, 894, 771, + 772, 914, 915, 765, 766, 770, 916, 918, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 905, 754, 753, 0, + 760, 761, 0, 790, 791, 793, 797, 798, 799, 810, + 857, 858, 866, 868, 869, 867, 870, 871, 872, 875, + 876, 877, 878, 873, 874, 879, 773, 777, 774, 775, + 776, 788, 778, 779, 780, 781, 782, 783, 784, 785, + 786, 787, 789, 928, 929, 930, 931, 932, 933, 803, + 807, 806, 804, 805, 801, 802, 829, 828, 830, 831, + 832, 833, 834, 835, 837, 836, 838, 839, 840, 841, + 842, 843, 811, 812, 815, 816, 814, 813, 817, 826, + 827, 818, 819, 820, 821, 822, 823, 825, 824, 844, + 845, 846, 847, 848, 850, 849, 853, 854, 852, 851, + 856, 855, 752, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 919, 261, 920, 0, 0, 924, + 0, 0, 0, 926, 925, 0, 927, 889, 888, 0, + 0, 921, 922, 0, 923, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 934, + 935, 936, 937, 938, 939, 940, 941, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 959, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 764, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 751, 0, + 0, 0, 269, 756, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 763, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 758, 759, 0, 0, 0, 0, 0, 0, 2398, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 1008, 944, 735, 910, 948, 1009, 961, 962, 963, + 949, 0, 237, 950, 951, 244, 952, 0, 909, 794, + 796, 795, 859, 860, 861, 862, 863, 864, 865, 792, + 957, 964, 965, 2399, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, + 0, 0, 0, 0, 0, 731, 748, 0, 762, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 745, + 746, 0, 0, 0, 0, 904, 0, 747, 0, 0, + 755, 966, 967, 968, 969, 970, 971, 972, 973, 974, + 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, + 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, + 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 757, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 903, 0, 0, 618, 0, 0, 901, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 954, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 955, 956, 255, 641, 800, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 808, 809, 279, 306, 885, 884, 883, 305, 307, + 881, 882, 880, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 891, 913, 902, 768, 769, + 892, 893, 917, 894, 771, 772, 914, 915, 765, 766, + 770, 916, 918, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 905, 754, 753, 0, 760, 761, 0, 790, 791, + 793, 797, 798, 799, 810, 857, 858, 866, 868, 869, + 867, 870, 871, 872, 875, 876, 877, 878, 873, 874, + 879, 773, 777, 774, 775, 776, 788, 778, 779, 780, + 781, 782, 783, 784, 785, 786, 787, 789, 928, 929, + 930, 931, 932, 933, 803, 807, 806, 804, 805, 801, + 802, 829, 828, 830, 831, 832, 833, 834, 835, 837, + 836, 838, 839, 840, 841, 842, 843, 811, 812, 815, + 816, 814, 813, 817, 826, 827, 818, 819, 820, 821, + 822, 823, 825, 824, 844, 845, 846, 847, 848, 850, + 849, 853, 854, 852, 851, 856, 855, 752, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 919, + 261, 920, 0, 0, 924, 0, 0, 0, 926, 925, + 0, 927, 889, 888, 0, 0, 921, 922, 0, 923, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 934, 935, 936, 937, 938, 939, + 940, 941, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 959, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 86, 522, 0, 764, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 751, 0, 0, 0, 269, 756, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 763, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 758, 759, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 0, 1008, 944, 735, 910, + 948, 1009, 961, 962, 963, 949, 0, 237, 950, 951, + 244, 952, 0, 909, 794, 796, 795, 859, 860, 861, + 862, 863, 864, 865, 792, 957, 964, 965, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 731, 748, 0, 762, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 745, 746, 0, 0, 0, 0, + 904, 0, 747, 0, 0, 755, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, + 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 757, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 903, 0, 0, 618, 0, + 0, 901, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 954, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 955, 956, 255, + 641, 800, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 808, 809, 279, 306, + 885, 884, 883, 305, 307, 881, 882, 880, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 891, 913, 902, 768, 769, 892, 893, 917, 894, 771, + 772, 914, 915, 765, 766, 770, 916, 918, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 905, 754, 753, 0, + 760, 761, 0, 790, 791, 793, 797, 798, 799, 810, + 857, 858, 866, 868, 869, 867, 870, 871, 872, 875, + 876, 877, 878, 873, 874, 879, 773, 777, 774, 775, + 776, 788, 778, 779, 780, 781, 782, 783, 784, 785, + 786, 787, 789, 928, 929, 930, 931, 932, 933, 803, + 807, 806, 804, 805, 801, 802, 829, 828, 830, 831, + 832, 833, 834, 835, 837, 836, 838, 839, 840, 841, + 842, 843, 811, 812, 815, 816, 814, 813, 817, 826, + 827, 818, 819, 820, 821, 822, 823, 825, 824, 844, + 845, 846, 847, 848, 850, 849, 853, 854, 852, 851, + 856, 855, 752, 196, 220, 365, 94, 451, 287, 639, + 608, 603, 205, 222, 919, 261, 920, 0, 0, 924, + 0, 0, 0, 926, 925, 0, 927, 889, 888, 0, + 0, 921, 922, 0, 923, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 934, + 935, 936, 937, 938, 939, 940, 941, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 959, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 764, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 751, 0, + 0, 0, 269, 756, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 763, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 758, 759, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 1008, 944, 735, 910, 948, 1009, 961, 962, 963, + 949, 0, 237, 950, 951, 244, 952, 0, 909, 794, + 796, 795, 859, 860, 861, 862, 863, 864, 865, 792, + 957, 964, 965, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, + 0, 0, 0, 0, 0, 731, 748, 0, 762, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 745, + 746, 0, 0, 0, 0, 904, 0, 747, 0, 0, + 755, 966, 967, 968, 969, 970, 971, 972, 973, 974, + 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, + 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, + 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 757, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 903, 0, 0, 618, 0, 0, 901, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 954, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 4016, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 955, 956, 255, 641, 800, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 808, 809, 279, 306, 885, 884, 883, 305, 307, + 881, 882, 880, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 891, 913, 902, 768, 769, + 892, 893, 917, 894, 771, 772, 914, 915, 765, 766, + 770, 916, 918, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 905, 754, 753, 0, 760, 761, 0, 790, 791, + 793, 797, 798, 799, 810, 857, 858, 866, 868, 869, + 867, 870, 871, 872, 875, 876, 877, 878, 873, 874, + 879, 773, 777, 774, 775, 776, 788, 778, 779, 780, + 781, 782, 783, 784, 785, 786, 787, 789, 928, 929, + 930, 931, 932, 933, 803, 807, 806, 804, 805, 801, + 802, 829, 828, 830, 831, 832, 833, 834, 835, 837, + 836, 838, 839, 840, 841, 842, 843, 811, 812, 815, + 816, 814, 813, 817, 826, 827, 818, 819, 820, 821, + 822, 823, 825, 824, 844, 845, 846, 847, 848, 850, + 849, 853, 854, 852, 851, 856, 855, 752, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 919, + 261, 920, 0, 0, 924, 0, 0, 0, 926, 925, + 0, 927, 889, 888, 0, 0, 921, 922, 0, 923, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 934, 935, 936, 937, 938, 939, + 940, 941, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 959, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 764, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 751, 0, 0, 0, 269, 756, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 763, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 758, 759, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 1725, 1008, 944, 735, 910, + 948, 1009, 961, 962, 963, 949, 0, 237, 950, 951, + 244, 952, 0, 909, 794, 796, 795, 859, 860, 861, + 862, 863, 864, 865, 792, 957, 964, 965, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 731, 748, 0, 762, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 745, 746, 0, 0, 0, 0, + 904, 0, 747, 0, 0, 755, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, + 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 757, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 903, 0, 0, 618, 0, + 0, 901, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 954, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 955, 956, 255, + 641, 800, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 808, 809, 279, 306, + 885, 884, 883, 305, 307, 881, 882, 880, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 891, 913, 902, 768, 769, 892, 893, 917, 894, 771, + 772, 914, 915, 765, 766, 770, 916, 918, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 905, 754, 753, 0, + 760, 761, 0, 790, 791, 793, 797, 798, 799, 810, + 857, 858, 866, 868, 869, 867, 870, 871, 872, 875, + 876, 877, 878, 873, 874, 879, 773, 777, 774, 775, + 776, 788, 778, 779, 780, 781, 782, 783, 784, 785, + 786, 787, 789, 928, 929, 930, 931, 932, 933, 803, + 807, 806, 804, 805, 801, 802, 829, 828, 830, 831, + 832, 833, 834, 835, 837, 836, 838, 839, 840, 841, + 842, 843, 811, 812, 815, 816, 814, 813, 817, 826, + 827, 818, 819, 820, 821, 822, 823, 825, 824, 844, + 845, 846, 847, 848, 850, 849, 853, 854, 852, 851, + 856, 855, 752, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 919, 261, 920, 0, 0, 924, + 0, 0, 0, 926, 925, 0, 927, 889, 888, 0, + 0, 921, 922, 0, 923, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 934, + 935, 936, 937, 938, 939, 940, 941, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 959, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 764, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 751, 0, + 0, 0, 269, 756, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 763, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 758, 759, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 1008, 944, 735, 910, 948, 1009, 961, 962, 963, + 949, 0, 237, 950, 951, 244, 952, 0, 909, 794, + 796, 795, 859, 860, 861, 862, 863, 864, 865, 792, + 957, 964, 965, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, + 0, 0, 0, 0, 0, 731, 748, 0, 762, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 745, + 746, 1054, 0, 0, 0, 904, 0, 747, 0, 0, + 755, 966, 967, 968, 969, 970, 971, 972, 973, 974, + 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, + 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, + 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 757, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 903, 0, 0, 618, 0, 0, 901, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 954, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 955, 956, 255, 641, 800, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 808, 809, 279, 306, 885, 884, 883, 305, 307, + 881, 882, 880, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 891, 913, 902, 768, 769, + 892, 893, 917, 894, 771, 772, 914, 915, 765, 766, + 770, 916, 918, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 905, 754, 753, 0, 760, 761, 0, 790, 791, + 793, 797, 798, 799, 810, 857, 858, 866, 868, 869, + 867, 870, 871, 872, 875, 876, 877, 878, 873, 874, + 879, 773, 777, 774, 775, 776, 788, 778, 779, 780, + 781, 782, 783, 784, 785, 786, 787, 789, 928, 929, + 930, 931, 932, 933, 803, 807, 806, 804, 805, 801, + 802, 829, 828, 830, 831, 832, 833, 834, 835, 837, + 836, 838, 839, 840, 841, 842, 843, 811, 812, 815, + 816, 814, 813, 817, 826, 827, 818, 819, 820, 821, + 822, 823, 825, 824, 844, 845, 846, 847, 848, 850, + 849, 853, 854, 852, 851, 856, 855, 752, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 919, + 261, 920, 0, 0, 924, 0, 0, 0, 926, 925, + 0, 927, 889, 888, 0, 0, 921, 922, 0, 923, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 934, 935, 936, 937, 938, 939, + 940, 941, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 959, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 764, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 751, 0, 0, 0, 269, 756, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 763, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 758, 759, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 0, 1008, 944, 735, 910, + 948, 1009, 961, 962, 963, 949, 0, 237, 950, 951, + 244, 952, 0, 909, 794, 796, 795, 859, 860, 861, + 862, 863, 864, 865, 792, 957, 964, 965, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 731, 748, 0, 762, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 745, 746, 0, 0, 0, 0, + 904, 0, 747, 0, 0, 755, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, + 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 757, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 903, 0, 0, 618, 0, + 0, 901, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 954, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 955, 956, 255, + 641, 800, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 808, 809, 279, 306, + 885, 884, 883, 305, 307, 881, 882, 880, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 891, 913, 902, 768, 769, 892, 893, 917, 894, 771, + 772, 914, 915, 765, 766, 770, 916, 918, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 905, 754, 753, 0, + 760, 761, 0, 790, 791, 793, 797, 798, 799, 810, + 857, 858, 866, 868, 869, 867, 870, 871, 872, 875, + 876, 877, 878, 873, 874, 879, 773, 777, 774, 775, + 776, 788, 778, 779, 780, 781, 782, 783, 784, 785, + 786, 787, 789, 928, 929, 930, 931, 932, 933, 803, + 807, 806, 804, 805, 801, 802, 829, 828, 830, 831, + 832, 833, 834, 835, 837, 836, 838, 839, 840, 841, + 842, 843, 811, 812, 815, 816, 814, 813, 817, 826, + 827, 818, 819, 820, 821, 822, 823, 825, 824, 844, + 845, 846, 847, 848, 850, 849, 853, 854, 852, 851, + 856, 855, 752, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 919, 261, 920, 0, 0, 924, + 0, 0, 0, 926, 925, 0, 927, 889, 888, 0, + 0, 921, 922, 0, 923, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 934, + 935, 936, 937, 938, 939, 940, 941, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 959, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 764, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 751, 0, + 0, 0, 269, 756, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 763, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 758, 759, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 1008, 944, 735, 910, 948, 1009, 961, 962, 963, + 949, 0, 237, 950, 951, 244, 952, 0, 909, 794, + 796, 795, 859, 860, 861, 862, 863, 864, 865, 792, + 957, 964, 965, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, + 0, 0, 0, 0, 0, 731, 748, 0, 762, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 745, + 746, 0, 0, 0, 0, 904, 0, 747, 0, 0, + 755, 966, 967, 968, 969, 970, 971, 972, 973, 974, + 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, + 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, + 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 3108, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 903, 0, 0, 618, 0, 0, 901, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 954, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 955, 956, 255, 641, 800, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 808, 809, 279, 306, 885, 884, 883, 305, 307, + 881, 882, 880, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 891, 913, 902, 768, 769, + 892, 893, 917, 894, 771, 772, 914, 915, 765, 766, + 770, 916, 918, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 905, 754, 753, 0, 760, 761, 0, 790, 791, + 793, 797, 798, 799, 810, 857, 858, 866, 868, 869, + 867, 870, 871, 872, 875, 876, 877, 878, 873, 874, + 879, 773, 777, 774, 775, 776, 788, 778, 779, 780, + 781, 782, 783, 784, 785, 786, 787, 789, 928, 929, + 930, 931, 932, 933, 803, 807, 806, 804, 805, 801, + 802, 829, 828, 830, 831, 832, 833, 834, 835, 837, + 836, 838, 839, 840, 841, 842, 843, 811, 812, 815, + 816, 814, 813, 817, 826, 827, 818, 819, 820, 821, + 822, 823, 825, 824, 844, 845, 846, 847, 848, 850, + 849, 853, 854, 852, 851, 856, 855, 752, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 919, + 261, 920, 0, 0, 924, 0, 0, 0, 926, 925, + 0, 927, 889, 888, 0, 0, 921, 922, 0, 923, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 934, 935, 936, 937, 938, 939, + 940, 941, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 959, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 764, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 751, 0, 0, 0, 269, 756, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 763, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 758, 759, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 0, 1008, 944, 735, 910, + 948, 1009, 961, 962, 963, 949, 0, 237, 950, 951, + 244, 952, 0, 909, 794, 796, 795, 859, 860, 861, + 862, 863, 864, 865, 792, 957, 964, 965, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 731, 748, 0, 762, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 745, 746, 0, 0, 0, 0, + 904, 0, 747, 0, 0, 755, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, + 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 3104, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 903, 0, 0, 618, 0, + 0, 901, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 954, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 955, 956, 255, + 641, 800, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 808, 809, 279, 306, + 885, 884, 883, 305, 307, 881, 882, 880, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 891, 913, 902, 768, 769, 892, 893, 917, 894, 771, + 772, 914, 915, 765, 766, 770, 916, 918, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 905, 754, 753, 0, + 760, 761, 0, 790, 791, 793, 797, 798, 799, 810, + 857, 858, 866, 868, 869, 867, 870, 871, 872, 875, + 876, 877, 878, 873, 874, 879, 773, 777, 774, 775, + 776, 788, 778, 779, 780, 781, 782, 783, 784, 785, + 786, 787, 789, 928, 929, 930, 931, 932, 933, 803, + 807, 806, 804, 805, 801, 802, 829, 828, 830, 831, + 832, 833, 834, 835, 837, 836, 838, 839, 840, 841, + 842, 843, 811, 812, 815, 816, 814, 813, 817, 826, + 827, 818, 819, 820, 821, 822, 823, 825, 824, 844, + 845, 846, 847, 848, 850, 849, 853, 854, 852, 851, + 856, 855, 752, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 919, 261, 920, 0, 0, 924, + 0, 0, 0, 926, 925, 0, 927, 889, 888, 0, + 0, 921, 922, 0, 923, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 934, + 935, 936, 937, 938, 939, 940, 941, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 959, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 764, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 751, 0, + 0, 0, 269, 756, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 763, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 758, 759, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 1008, 944, 1075, 910, 948, 1009, 961, 962, 963, + 949, 0, 237, 950, 951, 244, 952, 0, 909, 794, + 796, 795, 859, 860, 861, 862, 863, 864, 865, 792, + 957, 964, 965, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, + 0, 0, 0, 0, 0, 0, 748, 0, 762, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 745, + 746, 0, 0, 0, 0, 904, 0, 747, 0, 0, + 755, 966, 967, 968, 969, 970, 971, 972, 973, 974, + 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, + 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, + 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 757, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 903, 0, 0, 618, 0, 0, 901, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 954, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 955, 956, 255, 641, 800, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 808, 809, 279, 306, 885, 884, 883, 305, 307, + 881, 882, 880, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 891, 913, 902, 768, 769, + 892, 893, 917, 894, 771, 772, 914, 915, 765, 766, + 770, 916, 918, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 905, 754, 753, 0, 760, 761, 0, 790, 791, + 793, 797, 798, 799, 810, 857, 858, 866, 868, 869, + 867, 870, 871, 872, 875, 876, 877, 878, 873, 874, + 879, 773, 777, 774, 775, 776, 788, 778, 779, 780, + 781, 782, 783, 784, 785, 786, 787, 789, 928, 929, + 930, 931, 932, 933, 803, 807, 806, 804, 805, 801, + 802, 829, 828, 830, 831, 832, 833, 834, 835, 837, + 836, 838, 839, 840, 841, 842, 843, 811, 812, 815, + 816, 814, 813, 817, 826, 827, 818, 819, 820, 821, + 822, 823, 825, 824, 844, 845, 846, 847, 848, 850, + 849, 853, 854, 852, 851, 856, 855, 752, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 919, + 261, 920, 0, 0, 924, 0, 0, 0, 926, 925, + 0, 927, 889, 888, 0, 0, 921, 922, 0, 923, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 934, 935, 936, 937, 938, 939, + 940, 941, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 959, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 764, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 751, 0, 0, 0, 269, 756, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 763, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 758, 759, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 0, 1008, 944, 1075, 910, + 948, 1009, 961, 962, 963, 949, 0, 237, 950, 951, + 244, 952, 0, 909, 794, 796, 795, 859, 860, 861, + 862, 863, 864, 865, 792, 957, 964, 965, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 748, 0, 762, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 745, 746, 0, 0, 0, 0, + 904, 0, 747, 0, 0, 755, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, + 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 2084, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 903, 0, 0, 618, 0, + 0, 901, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 954, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 955, 956, 255, + 641, 800, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 808, 809, 279, 306, + 885, 884, 883, 305, 307, 881, 882, 880, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 891, 913, 902, 768, 769, 892, 893, 917, 894, 771, + 772, 914, 915, 765, 766, 770, 916, 918, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 905, 754, 753, 0, + 760, 761, 0, 790, 791, 793, 797, 798, 799, 810, + 857, 858, 866, 868, 869, 867, 870, 871, 872, 875, + 876, 877, 878, 873, 874, 879, 773, 777, 774, 775, + 776, 788, 778, 779, 780, 781, 782, 783, 784, 785, + 786, 787, 789, 928, 929, 930, 931, 932, 933, 803, + 807, 806, 804, 805, 801, 802, 829, 828, 830, 831, + 832, 833, 834, 835, 837, 836, 838, 839, 840, 841, + 842, 843, 811, 812, 815, 816, 814, 813, 817, 826, + 827, 818, 819, 820, 821, 822, 823, 825, 824, 844, + 845, 846, 847, 848, 850, 849, 853, 854, 852, 851, + 856, 855, 752, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 919, 261, 920, 0, 0, 924, + 0, 0, 0, 926, 925, 0, 927, 889, 888, 0, + 0, 921, 922, 0, 923, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 934, + 935, 936, 937, 938, 939, 940, 941, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 959, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 764, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 751, 0, + 0, 0, 269, 756, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 763, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 758, 759, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 1008, 944, 1075, 910, 948, 1009, 961, 962, 963, + 949, 0, 237, 950, 951, 244, 952, 0, 909, 794, + 796, 795, 859, 860, 861, 862, 863, 864, 865, 792, + 957, 964, 965, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, + 0, 0, 0, 0, 0, 0, 748, 0, 762, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 745, + 746, 0, 0, 0, 0, 904, 0, 747, 0, 0, + 755, 966, 967, 968, 969, 970, 971, 972, 973, 974, + 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, + 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, + 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 2082, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 903, 0, 0, 618, 0, 0, 901, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 954, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 955, 956, 255, 641, 800, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 808, 809, 279, 306, 885, 884, 883, 305, 307, + 881, 882, 880, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 891, 913, 902, 768, 769, + 892, 893, 917, 894, 771, 772, 914, 915, 765, 766, + 770, 916, 918, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 905, 754, 753, 0, 760, 761, 0, 790, 791, + 793, 797, 798, 799, 810, 857, 858, 866, 868, 869, + 867, 870, 871, 872, 875, 876, 877, 878, 873, 874, + 879, 773, 777, 774, 775, 776, 788, 778, 779, 780, + 781, 782, 783, 784, 785, 786, 787, 789, 928, 929, + 930, 931, 932, 933, 803, 807, 806, 804, 805, 801, + 802, 829, 828, 830, 831, 832, 833, 834, 835, 837, + 836, 838, 839, 840, 841, 842, 843, 811, 812, 815, + 816, 814, 813, 817, 826, 827, 818, 819, 820, 821, + 822, 823, 825, 824, 844, 845, 846, 847, 848, 850, + 849, 853, 854, 852, 851, 856, 855, 752, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 919, + 261, 920, 0, 0, 924, 0, 0, 0, 926, 925, + 0, 927, 889, 888, 0, 0, 921, 922, 0, 923, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 934, 935, 936, 937, 938, 939, + 940, 941, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 959, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, - 0, 1126, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 1126, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4327,72 +4225,72 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 1125, 618, 0, 0, 0, 0, - 0, 1122, 1123, 362, 1083, 329, 197, 224, 1116, 1120, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 1125, 618, 0, + 0, 0, 0, 0, 1122, 1123, 362, 1083, 329, 197, + 224, 1116, 1120, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 1686, 944, - 0, 0, 1683, 0, 0, 0, 0, 1681, 0, 237, - 1682, 1680, 244, 1685, 0, 909, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 1686, 944, 0, 0, 1683, 0, 0, 0, 0, + 1681, 0, 237, 1682, 1680, 244, 1685, 0, 909, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4400,216 +4298,361 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 86, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 86, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 0, 0, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 94, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, + 0, 0, 2385, 0, 0, 2384, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 1748, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 1750, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 1752, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, + 0, 1457, 0, 1458, 1459, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 0, 0, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 86, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 1725, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 94, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 2386, - 0, 0, 2385, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 1748, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 1750, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 1752, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 1457, 0, - 1458, 1459, 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 94, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 0, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 86, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 1725, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 2385, 0, 0, + 2384, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 2332, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 1931, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4617,144 +4660,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 94, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 2330, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, + 0, 1077, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, - 0, 0, 0, 0, 2386, 0, 0, 2385, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 2334, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 1083, 329, 197, 224, 1081, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 1931, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 2332, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 1931, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4762,434 +4805,434 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 2332, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, - 0, 0, 0, 0, 0, 0, 0, 0, 1077, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 1725, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 1083, - 329, 197, 224, 1081, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 2334, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 1931, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 3656, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 2093, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2094, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 1725, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 2829, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2830, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 3657, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 2093, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 711, 0, 0, + 0, 0, 2814, 0, 0, 0, 0, 237, 0, 0, + 244, 2815, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2094, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 2830, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 1771, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 1770, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2831, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 711, 0, 0, 0, 0, 2816, - 0, 0, 0, 0, 237, 0, 0, 244, 2817, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 713, 714, 715, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5197,144 +5240,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 1771, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 1770, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 3995, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 713, 714, 715, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 1931, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5342,144 +5385,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 3996, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 3656, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 1931, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 95, 0, 0, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5487,144 +5530,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 2386, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 3657, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 95, 0, 0, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 1752, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5632,144 +5675,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 2387, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 2045, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 1752, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 2036, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5777,144 +5820,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 1898, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 2045, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 2036, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 1896, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5922,144 +5965,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 1898, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 1894, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 1896, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 1892, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6067,144 +6110,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 1894, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 1890, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 1892, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 1886, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6212,144 +6255,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 1890, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 1884, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 1886, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 1882, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6357,72 +6400,72 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 1884, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 1857, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6430,143 +6473,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 1882, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 1756, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 95, 0, + 0, 0, 944, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 1857, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6574,144 +6618,144 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 1756, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1436, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 1435, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 95, 0, 0, 0, 944, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6719,588 +6763,485 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1034, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 664, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 711, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1436, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 1435, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 194, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 4055, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 711, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1034, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 393, 0, 373, 570, 571, 315, + 0, 522, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 413, 0, 0, 0, 0, 0, 0, + 0, 0, 269, 0, 0, 0, 0, 363, 266, 0, + 0, 427, 0, 203, 0, 483, 251, 374, 371, 577, + 281, 272, 268, 249, 316, 382, 425, 512, 419, 0, + 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 322, 247, 324, 202, 410, 494, 285, 0, 0, 0, + 0, 0, 944, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 237, 0, 0, 244, 0, 0, 0, 348, + 357, 356, 337, 338, 340, 342, 347, 354, 360, 0, + 0, 0, 0, 0, 264, 320, 271, 263, 574, 0, + 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 664, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 711, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 296, 0, 399, 256, 0, 450, + 0, 0, 0, 618, 0, 0, 0, 0, 0, 0, + 0, 362, 0, 329, 197, 224, 0, 0, 409, 458, + 470, 0, 0, 0, 252, 0, 468, 423, 596, 232, + 283, 455, 429, 466, 437, 286, 0, 0, 467, 369, + 579, 447, 593, 619, 620, 262, 403, 605, 516, 613, + 637, 225, 259, 417, 501, 599, 490, 394, 575, 576, + 328, 489, 294, 201, 366, 625, 223, 476, 368, 241, + 230, 581, 602, 298, 288, 453, 632, 212, 511, 591, + 238, 480, 0, 0, 640, 246, 500, 214, 588, 499, + 390, 325, 326, 213, 0, 454, 267, 292, 0, 0, + 257, 412, 583, 584, 255, 641, 227, 612, 219, 0, + 611, 405, 578, 589, 391, 380, 218, 587, 389, 379, + 333, 352, 353, 279, 306, 444, 372, 445, 305, 307, + 401, 400, 402, 206, 600, 0, 207, 0, 495, 601, + 642, 449, 211, 233, 234, 236, 0, 278, 282, 290, + 293, 302, 303, 312, 364, 416, 443, 439, 448, 0, + 573, 594, 606, 617, 623, 624, 626, 627, 628, 629, + 630, 633, 631, 404, 310, 491, 332, 370, 0, 0, + 422, 469, 239, 598, 492, 199, 0, 0, 0, 0, + 253, 254, 0, 569, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 644, 645, 646, 647, 648, 649, + 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 638, 502, 508, 503, 504, 505, 506, 507, 0, + 509, 0, 0, 0, 0, 0, 395, 0, 585, 586, + 661, 381, 482, 595, 334, 346, 349, 339, 358, 0, + 359, 335, 336, 341, 343, 344, 345, 350, 351, 355, + 361, 248, 209, 387, 396, 572, 311, 215, 216, 217, + 518, 519, 520, 521, 609, 610, 614, 204, 459, 460, + 461, 462, 291, 604, 308, 465, 464, 330, 331, 376, + 446, 534, 536, 547, 551, 553, 555, 561, 564, 535, + 537, 548, 552, 554, 556, 562, 565, 524, 526, 528, + 530, 543, 542, 539, 567, 568, 545, 550, 529, 541, + 546, 559, 566, 563, 523, 527, 531, 540, 558, 557, + 538, 549, 560, 544, 532, 525, 533, 0, 196, 220, + 365, 0, 451, 287, 639, 608, 603, 205, 222, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 198, 200, 208, 221, 231, 235, 242, 260, + 275, 277, 284, 297, 309, 317, 318, 321, 327, 377, + 383, 384, 385, 386, 406, 407, 408, 411, 414, 415, + 418, 420, 421, 424, 428, 432, 433, 434, 436, 438, + 440, 452, 457, 471, 472, 473, 474, 475, 478, 479, + 484, 485, 486, 487, 488, 496, 497, 510, 580, 582, + 597, 615, 621, 477, 300, 301, 441, 442, 313, 314, + 635, 636, 299, 592, 622, 590, 634, 616, 435, 375, + 0, 0, 378, 280, 304, 319, 0, 607, 498, 226, + 463, 289, 250, 0, 0, 210, 245, 229, 258, 273, + 276, 323, 388, 397, 426, 431, 295, 270, 243, 456, + 240, 481, 513, 514, 515, 517, 392, 265, 430, 393, + 0, 373, 570, 571, 315, 0, 522, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 413, 0, + 0, 0, 0, 0, 0, 0, 0, 269, 0, 0, + 0, 0, 363, 266, 0, 0, 427, 0, 203, 0, + 483, 251, 374, 371, 577, 281, 272, 268, 249, 316, + 382, 425, 512, 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, + 0, 0, 0, 0, 0, 322, 247, 324, 202, 410, + 494, 285, 0, 0, 0, 0, 0, 194, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, + 244, 0, 0, 0, 348, 357, 356, 337, 338, 340, + 342, 347, 354, 360, 0, 0, 0, 0, 0, 264, + 320, 271, 263, 574, 0, 0, 0, 0, 0, 0, + 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 4056, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 711, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 296, + 0, 399, 256, 0, 450, 0, 0, 0, 618, 0, + 0, 0, 0, 0, 0, 0, 362, 0, 329, 197, + 224, 0, 0, 409, 458, 470, 0, 0, 0, 252, + 0, 468, 423, 596, 232, 283, 455, 429, 466, 437, + 286, 0, 0, 467, 369, 579, 447, 593, 619, 620, + 262, 403, 605, 516, 613, 637, 225, 259, 417, 501, + 599, 490, 394, 575, 576, 328, 489, 294, 201, 366, + 625, 223, 476, 368, 241, 230, 581, 602, 298, 288, + 453, 632, 212, 511, 591, 238, 480, 0, 0, 640, + 246, 500, 214, 588, 499, 390, 325, 326, 213, 0, + 454, 267, 292, 0, 0, 257, 412, 583, 584, 255, + 641, 227, 612, 219, 0, 611, 405, 578, 589, 391, + 380, 218, 587, 389, 379, 333, 352, 353, 279, 306, + 444, 372, 445, 305, 307, 401, 400, 402, 206, 600, + 0, 207, 0, 495, 601, 642, 449, 211, 233, 234, + 236, 0, 278, 282, 290, 293, 302, 303, 312, 364, + 416, 443, 439, 448, 0, 573, 594, 606, 617, 623, + 624, 626, 627, 628, 629, 630, 633, 631, 404, 310, + 491, 332, 370, 0, 0, 422, 469, 239, 598, 492, + 199, 0, 0, 0, 0, 253, 254, 0, 569, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 643, 644, + 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, + 655, 656, 657, 658, 659, 660, 638, 502, 508, 503, + 504, 505, 506, 507, 0, 509, 0, 0, 0, 0, + 0, 395, 0, 585, 586, 661, 381, 482, 595, 334, + 346, 349, 339, 358, 0, 359, 335, 336, 341, 343, + 344, 345, 350, 351, 355, 361, 248, 209, 387, 396, + 572, 311, 215, 216, 217, 518, 519, 520, 521, 609, + 610, 614, 204, 459, 460, 461, 462, 291, 604, 308, + 465, 464, 330, 331, 376, 446, 534, 536, 547, 551, + 553, 555, 561, 564, 535, 537, 548, 552, 554, 556, + 562, 565, 524, 526, 528, 530, 543, 542, 539, 567, + 568, 545, 550, 529, 541, 546, 559, 566, 563, 523, + 527, 531, 540, 558, 557, 538, 549, 560, 544, 532, + 525, 533, 0, 196, 220, 365, 0, 451, 287, 639, + 608, 603, 205, 222, 0, 261, 3714, 3716, 3715, 3779, + 3780, 3781, 3782, 3783, 3784, 3785, 792, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 208, + 221, 231, 235, 242, 260, 275, 277, 284, 297, 309, + 317, 318, 321, 327, 377, 383, 384, 385, 386, 406, + 407, 408, 411, 414, 415, 418, 420, 421, 424, 428, + 432, 433, 434, 436, 438, 440, 452, 457, 471, 472, + 473, 474, 475, 478, 479, 484, 485, 486, 487, 488, + 496, 497, 510, 580, 582, 597, 615, 621, 477, 300, + 301, 441, 442, 313, 314, 635, 636, 299, 592, 622, + 590, 634, 616, 435, 375, 0, 0, 378, 280, 304, + 319, 0, 607, 498, 226, 463, 289, 250, 0, 0, + 210, 245, 229, 258, 273, 276, 323, 388, 397, 426, + 431, 295, 270, 243, 456, 240, 481, 513, 514, 515, + 517, 392, 265, 430, 0, 0, 373, 570, 571, 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 393, 0, 373, 570, 571, 315, 0, 522, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 413, 0, 0, 0, 0, 0, 0, 0, 0, 269, - 0, 0, 0, 0, 363, 266, 0, 0, 427, 0, - 203, 0, 483, 251, 374, 371, 577, 281, 272, 268, - 249, 316, 382, 425, 512, 419, 0, 367, 0, 0, - 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 322, 247, 324, - 202, 410, 494, 285, 0, 0, 0, 0, 0, 944, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, - 0, 0, 244, 0, 0, 0, 348, 357, 356, 337, - 338, 340, 342, 347, 354, 360, 0, 0, 0, 0, - 0, 264, 320, 271, 263, 574, 0, 0, 0, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3720, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3728, 3729, + 0, 0, 3804, 3803, 3802, 0, 0, 3800, 3801, 3799, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 296, 0, 399, 256, 0, 450, 0, 0, 0, - 618, 0, 0, 0, 0, 0, 0, 0, 362, 0, - 329, 197, 224, 0, 0, 409, 458, 470, 0, 0, - 0, 252, 0, 468, 423, 596, 232, 283, 455, 429, - 466, 437, 286, 0, 0, 467, 369, 579, 447, 593, - 619, 620, 262, 403, 605, 516, 613, 637, 225, 259, - 417, 501, 599, 490, 394, 575, 576, 328, 489, 294, - 201, 366, 625, 223, 476, 368, 241, 230, 581, 602, - 298, 288, 453, 632, 212, 511, 591, 238, 480, 0, - 0, 640, 246, 500, 214, 588, 499, 390, 325, 326, - 213, 0, 454, 267, 292, 0, 0, 257, 412, 583, - 584, 255, 641, 227, 612, 219, 0, 611, 405, 578, - 589, 391, 380, 218, 587, 389, 379, 333, 352, 353, - 279, 306, 444, 372, 445, 305, 307, 401, 400, 402, - 206, 600, 0, 207, 0, 495, 601, 642, 449, 211, - 233, 234, 236, 0, 278, 282, 290, 293, 302, 303, - 312, 364, 416, 443, 439, 448, 0, 573, 594, 606, - 617, 623, 624, 626, 627, 628, 629, 630, 633, 631, - 404, 310, 491, 332, 370, 0, 0, 422, 469, 239, - 598, 492, 199, 0, 0, 0, 0, 253, 254, 0, - 569, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, - 653, 654, 655, 656, 657, 658, 659, 660, 638, 502, - 508, 503, 504, 505, 506, 507, 0, 509, 0, 0, - 0, 0, 0, 395, 0, 585, 586, 661, 381, 482, - 595, 334, 346, 349, 339, 358, 0, 359, 335, 336, - 341, 343, 344, 345, 350, 351, 355, 361, 248, 209, - 387, 396, 572, 311, 215, 216, 217, 518, 519, 520, - 521, 609, 610, 614, 204, 459, 460, 461, 462, 291, - 604, 308, 465, 464, 330, 331, 376, 446, 534, 536, - 547, 551, 553, 555, 561, 564, 535, 537, 548, 552, - 554, 556, 562, 565, 524, 526, 528, 530, 543, 542, - 539, 567, 568, 545, 550, 529, 541, 546, 559, 566, - 563, 523, 527, 531, 540, 558, 557, 538, 549, 560, - 544, 532, 525, 533, 0, 196, 220, 365, 0, 451, - 287, 639, 608, 603, 205, 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 208, 221, 231, 235, 242, 260, 275, 277, 284, - 297, 309, 317, 318, 321, 327, 377, 383, 384, 385, - 386, 406, 407, 408, 411, 414, 415, 418, 420, 421, - 424, 428, 432, 433, 434, 436, 438, 440, 452, 457, - 471, 472, 473, 474, 475, 478, 479, 484, 485, 486, - 487, 488, 496, 497, 510, 580, 582, 597, 615, 621, - 477, 300, 301, 441, 442, 313, 314, 635, 636, 299, - 592, 622, 590, 634, 616, 435, 375, 0, 0, 378, - 280, 304, 319, 0, 607, 498, 226, 463, 289, 250, - 0, 0, 210, 245, 229, 258, 273, 276, 323, 388, - 397, 426, 431, 295, 270, 243, 456, 240, 481, 513, - 514, 515, 517, 392, 265, 430, 393, 0, 373, 570, - 571, 315, 0, 522, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 413, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 363, - 266, 0, 0, 427, 0, 203, 0, 483, 251, 374, - 371, 577, 281, 272, 268, 249, 316, 382, 425, 512, - 419, 0, 367, 0, 0, 493, 398, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 322, 247, 324, 202, 410, 494, 285, 0, - 0, 0, 0, 0, 194, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 0, 0, 244, 0, 0, - 0, 348, 357, 356, 337, 338, 340, 342, 347, 354, - 360, 0, 0, 0, 0, 0, 264, 320, 271, 263, - 574, 0, 0, 0, 0, 0, 0, 0, 0, 228, + 0, 0, 3805, 913, 0, 768, 769, 3806, 3807, 917, + 3808, 771, 772, 914, 915, 0, 766, 770, 916, 918, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3711, 3712, 3713, 3717, 3718, + 3719, 3730, 3777, 3778, 3786, 3788, 869, 3787, 3789, 3790, + 3791, 3794, 3795, 3796, 3797, 3792, 3793, 3798, 3694, 3698, + 3695, 3696, 3697, 3709, 3699, 3700, 3701, 3702, 3703, 3704, + 3705, 3706, 3707, 3708, 3710, 3809, 3810, 3811, 3812, 3813, + 3814, 3723, 3727, 3726, 3724, 3725, 3721, 3722, 3749, 3748, + 3750, 3751, 3752, 3753, 3754, 3755, 3757, 3756, 3758, 3759, + 3760, 3761, 3762, 3763, 3731, 3732, 3735, 3736, 3734, 3733, + 3737, 3746, 3747, 3738, 3739, 3740, 3741, 3742, 3743, 3745, + 3744, 3764, 3765, 3766, 3767, 3768, 3770, 3769, 3773, 3774, + 3772, 3771, 3776, 3775, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 919, 0, 920, 0, + 0, 924, 0, 0, 0, 926, 925, 0, 927, 889, + 888, 0, 0, 921, 922, 0, 923, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 399, 256, - 0, 450, 0, 0, 0, 618, 0, 0, 0, 0, - 0, 0, 0, 362, 0, 329, 197, 224, 0, 0, - 409, 458, 470, 0, 0, 0, 252, 0, 468, 423, - 596, 232, 283, 455, 429, 466, 437, 286, 0, 0, - 467, 369, 579, 447, 593, 619, 620, 262, 403, 605, - 516, 613, 637, 225, 259, 417, 501, 599, 490, 394, - 575, 576, 328, 489, 294, 201, 366, 625, 223, 476, - 368, 241, 230, 581, 602, 298, 288, 453, 632, 212, - 511, 591, 238, 480, 0, 0, 640, 246, 500, 214, - 588, 499, 390, 325, 326, 213, 0, 454, 267, 292, - 0, 0, 257, 412, 583, 584, 255, 641, 227, 612, - 219, 0, 611, 405, 578, 589, 391, 380, 218, 587, - 389, 379, 333, 352, 353, 279, 306, 444, 372, 445, - 305, 307, 401, 400, 402, 206, 600, 0, 207, 0, - 495, 601, 642, 449, 211, 233, 234, 236, 0, 278, - 282, 290, 293, 302, 303, 312, 364, 416, 443, 439, - 448, 0, 573, 594, 606, 617, 623, 624, 626, 627, - 628, 629, 630, 633, 631, 404, 310, 491, 332, 370, - 0, 0, 422, 469, 239, 598, 492, 199, 0, 0, - 0, 0, 253, 254, 0, 569, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 643, 644, 645, 646, 647, - 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, - 658, 659, 660, 638, 502, 508, 503, 504, 505, 506, - 507, 0, 509, 0, 0, 0, 0, 0, 395, 0, - 585, 586, 661, 381, 482, 595, 334, 346, 349, 339, - 358, 0, 359, 335, 336, 341, 343, 344, 345, 350, - 351, 355, 361, 248, 209, 387, 396, 572, 311, 215, - 216, 217, 518, 519, 520, 521, 609, 610, 614, 204, - 459, 460, 461, 462, 291, 604, 308, 465, 464, 330, - 331, 376, 446, 534, 536, 547, 551, 553, 555, 561, - 564, 535, 537, 548, 552, 554, 556, 562, 565, 524, - 526, 528, 530, 543, 542, 539, 567, 568, 545, 550, - 529, 541, 546, 559, 566, 563, 523, 527, 531, 540, - 558, 557, 538, 549, 560, 544, 532, 525, 533, 0, - 196, 220, 365, 0, 451, 287, 639, 608, 603, 205, - 222, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 208, 221, 231, 235, - 242, 260, 275, 277, 284, 297, 309, 317, 318, 321, - 327, 377, 383, 384, 385, 386, 406, 407, 408, 411, - 414, 415, 418, 420, 421, 424, 428, 432, 433, 434, - 436, 438, 440, 452, 457, 471, 472, 473, 474, 475, - 478, 479, 484, 485, 486, 487, 488, 496, 497, 510, - 580, 582, 597, 615, 621, 477, 300, 301, 441, 442, - 313, 314, 635, 636, 299, 592, 622, 590, 634, 616, - 435, 375, 0, 0, 378, 280, 304, 319, 0, 607, - 498, 226, 463, 289, 250, 0, 0, 210, 245, 229, - 258, 273, 276, 323, 388, 397, 426, 431, 295, 270, - 243, 456, 240, 481, 513, 514, 515, 517, 392, 265, - 430, 0, 0, 373, 570, 571, 315, + 0, 3815, 3816, 3817, 3818, 3819, 3820, 3821, 3822, } var yyPact = [...]int{ - -1000, -1000, 1924, -1000, -533, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, 5220, -1000, -536, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 2413, 2785, -1000, -1000, -1000, -1000, 2617, -1000, 975, - 2077, -1000, 2388, 4123, -1000, 55392, 479, -1000, 52492, -438, - 845, 218, 36542, -1000, 219, -1000, 200, 53942, 213, -1000, - -1000, -1000, -1000, -438, 22042, 2308, 81, 70, 55392, -1000, - -1000, -1000, -1000, -354, 2564, 2044, -1000, 387, -1000, -1000, - -1000, -1000, -1000, -1000, 51767, -1000, 1104, -1000, -1000, 2398, - 2370, 2278, 877, 2291, -1000, 2477, 2044, -1000, 22042, 2541, - 2448, 21317, 21317, 455, -1000, -1000, 282, -1000, -1000, 31467, - 55392, 39442, 290, -1000, 2388, -1000, -1000, -1000, 217, -1000, - 379, 1962, -1000, 1961, -1000, 1045, 1076, 397, 875, 858, - 396, 395, 394, 393, 391, 389, 386, 385, 404, -1000, - 909, 909, -205, -221, 1382, 446, 443, 443, 1132, 465, - 2328, 2323, -1000, -1000, 909, 909, 909, 847, 909, 909, - 909, 909, 350, 331, 909, 909, 909, 909, 909, 909, - 909, 909, 909, 909, 909, 909, 909, 909, 909, 909, - 909, 818, 2388, 300, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 2422, 2672, -1000, -1000, -1000, -1000, 2648, -1000, 1005, + 2116, -1000, 2421, 4974, -1000, 54375, 787, -1000, 51475, -438, + 897, 218, 35525, -1000, 183, -1000, 168, 52925, 174, -1000, + -1000, -1000, -1000, -438, 21025, 2330, 49, 44, 54375, -1000, + -1000, -1000, -1000, -361, 2618, 2074, -1000, 389, -1000, -1000, + -1000, -1000, -1000, -1000, 50750, -1000, 1182, -1000, -1000, 2430, + 2401, 2301, 928, 2355, -1000, 2514, 2074, -1000, 21025, 2601, + 2481, 20300, 20300, 461, -1000, -1000, 282, -1000, -1000, 30450, + 54375, 38425, 896, -1000, 2421, -1000, -1000, -1000, 245, -1000, + 371, 1980, -1000, 1975, -1000, 925, 1048, 387, 472, 468, + 386, 384, 382, 380, 379, 377, 376, 374, 398, -1000, + 941, 941, -214, -219, 1382, 451, 450, 450, 1020, 493, + 2379, 2358, -1000, -1000, 941, 941, 941, 333, 941, 941, + 941, 941, 310, 306, 941, 941, 941, 941, 941, 941, + 941, 941, 941, 941, 941, 941, 941, 941, 941, 941, + 941, 921, 2421, 262, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, @@ -7347,67 +7288,67 @@ var yyPact = [...]int{ -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, 55392, 209, 55392, -1000, 532, 478, -1000, -1000, - -443, 1025, 1025, 92, 1025, 1025, 1025, 1025, 199, 948, - 69, -1000, 198, 309, 191, 312, 1028, 263, -1000, -1000, - 286, 1028, 1834, -1000, 895, 297, 183, -1000, 1025, 1025, - -1000, 14768, 265, 14768, 14768, -1000, 2369, -1000, -1000, -1000, - -1000, -1000, 1300, -1000, -1000, -1000, -1000, -19, 464, -1000, - -1000, -1000, -1000, 53942, 51042, 239, -1000, -1000, 41, 1866, - 1631, 22042, 1296, 874, -1000, -1000, 1370, 853, -1000, -1000, - -1000, -1000, -1000, 496, -1000, 24217, 24217, 24217, 24217, -1000, - -1000, 1967, 50317, 1967, 1967, 24217, 1967, 24217, 1967, 1967, - 1967, 1967, 22042, 1967, 1967, 1967, 1967, -1000, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, -1000, -1000, -1000, -1000, 1967, - 526, 1967, 1967, 1967, 1967, 1967, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 1967, 1967, 1967, 1967, 1967, 1967, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, -1000, -1000, -1000, 1641, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 27117, 1537, 1524, 1518, -1000, 19142, 1967, + -1000, -1000, 54375, 231, 54375, -1000, 845, 785, -1000, -1000, + -442, 1092, 1092, 60, 1092, 1092, 1092, 1092, 179, 1007, + 42, -1000, 175, 254, 195, 257, 1095, 776, -1000, -1000, + 263, 1095, 1820, -1000, 935, 251, 157, -1000, 1092, 1092, + -1000, 13751, 259, 13751, 13751, -1000, 2406, -1000, -1000, -1000, + -1000, -1000, 1352, -1000, -1000, -1000, -1000, -27, 492, -1000, + -1000, -1000, -1000, 52925, 50025, 291, -1000, -1000, 252, 1667, + 1197, 21025, 1349, 923, -1000, -1000, 1402, 900, -1000, -1000, + -1000, -1000, -1000, 823, -1000, 23200, 23200, 23200, 23200, -1000, + -1000, 1982, 49300, 1982, 1982, 23200, 1982, 23200, 1982, 1982, + 1982, 1982, 21025, 1982, 1982, 1982, 1982, -1000, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, -1000, -1000, -1000, -1000, 1982, + 844, 1982, 1982, 1982, 1982, 1982, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 1982, 1982, 1982, 1982, 1982, 1982, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, -1000, -1000, -1000, 1739, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, 26100, 1653, 1627, 1621, -1000, 18125, 1982, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 55392, -1000, 1967, 243, 53942, 53942, 375, 1326, -1000, - -1000, 2477, 2044, -1000, 2564, 2536, 387, -1000, 3479, 1777, - 1528, 1499, 2044, 1932, 55392, -1000, 1981, -1000, -1000, -1000, - -322, -327, 2200, 1438, 1833, -1000, -1000, -1000, -1000, 2365, - 22042, -1000, -1000, 2586, -1000, 28567, 525, 2582, 49592, -1000, - 455, 455, 1956, 444, 37, -1000, -1000, -1000, -1000, 958, - 35817, -1000, -1000, -1000, -1000, -1000, 1831, 55392, -1000, -1000, - 4884, 1332, -1000, 2076, -1000, 1825, -1000, 2029, 22042, 2064, - 477, 1332, 472, 471, 470, -1000, -51, -1000, -1000, -1000, - -1000, -1000, -1000, 909, 909, 909, -1000, 392, 2538, 4123, - 5575, -1000, -1000, -1000, 48867, 2069, 1332, -1000, 2063, -1000, - 1019, 866, 870, 870, 1332, -1000, -1000, 54667, 1332, 1018, - 1016, 1332, 1332, 53942, 53942, -1000, 48142, -1000, 47417, 46692, - 1315, 53942, 45967, 45242, 44517, 43792, 43067, -1000, 2246, -1000, - 2024, -1000, -1000, -1000, 54667, 1332, 1332, 54667, 53942, 54667, - 55392, 1332, -1000, -1000, 372, -1000, -1000, 1310, 1309, 1297, - 909, 909, 1295, 1810, 1805, 1796, 909, 909, 1292, 1783, - 37992, 1772, 288, 1290, 1289, 1234, 1319, 1768, 232, 1762, - 1314, 1278, 1230, 53942, 2056, 55392, -1000, 278, 965, 1004, - 953, 2388, 2296, 1946, 463, 475, 1332, 447, 447, 53942, - -1000, 15499, 55392, 256, -1000, 1749, 22042, -1000, 1039, 1028, - 1028, -1000, -1000, -1000, -1000, -1000, -1000, 1025, 55392, 1039, - -1000, -1000, -1000, 1028, 1025, 55392, 1025, 1025, 1025, 1025, - 1028, 1028, 1028, 1025, 55392, 55392, 55392, 55392, 55392, 55392, - 55392, 55392, 55392, 14768, 895, 1025, -444, -1000, 1744, -1000, - -1000, -1000, 2173, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 54375, -1000, 1982, 198, 52925, 52925, 332, 1395, -1000, + -1000, 2514, 2074, -1000, 2618, 2532, 389, -1000, 3343, 1531, + 1607, 1547, 2074, 1945, 54375, -1000, 2010, -1000, -1000, -1000, + -316, -344, 2256, 1488, 1805, -1000, -1000, -1000, -1000, 2547, + 21025, -1000, -1000, 2644, -1000, 27550, 843, 2643, 48575, -1000, + 461, 461, 1965, 414, 21, -1000, -1000, -1000, -1000, 1012, + 34800, -1000, -1000, -1000, -1000, -1000, 1845, 54375, -1000, -1000, + 5812, 1289, -1000, 2112, -1000, 1834, -1000, 2046, 21025, 2072, + 784, 1289, 770, 755, 470, -1000, -63, -1000, -1000, -1000, + -1000, -1000, -1000, 941, 941, 941, -1000, 393, 2593, 4974, + 6316, -1000, -1000, -1000, 47850, 2110, 1289, -1000, 2107, -1000, + 1112, 884, 890, 890, 1289, -1000, -1000, 53650, 1289, 1104, + 1090, 1289, 1289, 52925, 52925, -1000, 47125, -1000, 46400, 45675, + 1392, 52925, 44950, 44225, 43500, 42775, 42050, -1000, 2252, -1000, + 2030, -1000, -1000, -1000, 53650, 1289, 1289, 53650, 52925, 53650, + 54375, 1289, -1000, -1000, 342, -1000, -1000, 1391, 1389, 1388, + 941, 941, 1375, 1804, 1800, 1789, 941, 941, 1374, 1788, + 36975, 1786, 283, 1371, 1357, 1347, 1330, 1785, 207, 1779, + 1314, 1255, 1335, 52925, 2101, 54375, -1000, 243, 1059, 904, + 991, 2421, 2310, 1956, 490, 783, 1289, 454, 454, 52925, + -1000, 14482, 54375, 211, -1000, 1778, 21025, -1000, 1118, 1095, + 1095, -1000, -1000, -1000, -1000, -1000, -1000, 1092, 54375, 1118, + -1000, -1000, -1000, 1095, 1092, 54375, 1092, 1092, 1092, 1092, + 1095, 1095, 1095, 1092, 54375, 54375, 54375, 54375, 54375, 54375, + 54375, 54375, 54375, 13751, 935, 1092, -443, -1000, 1777, -1000, + -1000, -1000, 2217, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, @@ -7423,329 +7364,329 @@ var yyPact = [...]int{ -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 14768, 14768, -1000, -1000, -1000, -1000, -1000, 1944, -1000, 202, - 23, 211, -1000, 42342, 485, 944, -1000, 485, -1000, -1000, - -1000, 1942, 41617, -1000, -445, -446, -450, -454, -1000, -1000, - -1000, -455, -457, -1000, -1000, -1000, 22042, 22042, 22042, 22042, - -272, -1000, 1128, 24217, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 22042, 242, 981, 24217, 24217, 24217, 24217, 24217, 24217, - 24217, 25667, 24942, 24217, 24217, 24217, 24217, 24217, 24217, -1000, - -1000, 33642, 3215, 3215, 853, 853, 853, 853, -1000, -166, - 1941, 54667, -1000, -1000, -1000, 524, 22042, 22042, 853, -1000, - 1332, 1294, 19142, 21317, 21317, 22042, 22042, 970, 1631, 54667, - 22042, -1000, 1499, -1000, -1000, -1000, -1000, 1136, -1000, -1000, - 1014, 2340, 2340, 2340, 2340, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 2340, 22042, 708, 708, 912, - 22042, 22042, 22042, 22042, 22042, 22042, 17692, 22042, 22042, 24217, - 22042, 22042, 22042, 1499, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 1499, 22042, 1307, 22042, 22042, 22042, 22042, - 22042, 22042, 21317, 16961, 21317, 21317, 21317, 21317, 21317, -1000, - -1000, -1000, -1000, -1000, -1000, 22042, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 1499, 22042, 22042, 22042, 22042, 22042, -1000, + 13751, 13751, -1000, -1000, -1000, -1000, -1000, 1954, -1000, 164, + 1, 171, -1000, 41325, 509, 982, -1000, 509, -1000, -1000, + -1000, 1953, 40600, -1000, -445, -448, -451, -454, -1000, -1000, + -1000, -461, -462, -1000, -1000, -1000, 21025, 21025, 21025, 21025, + -246, -1000, 1284, 23200, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 21025, 260, 1043, 23200, 23200, 23200, 23200, 23200, 23200, + 23200, 24650, 23925, 23200, 23200, 23200, 23200, 23200, 23200, -1000, + -1000, 32625, 6888, 6888, 900, 900, 900, 900, -1000, -178, + 1948, 53650, -1000, -1000, -1000, 842, 21025, 21025, 900, -1000, + 1289, 1203, 18125, 21025, 21025, 21025, 21025, 1022, 1197, 53650, + 21025, -1000, 1547, -1000, -1000, -1000, -1000, 1237, -1000, -1000, + 1132, 2405, 2405, 2405, 2405, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 2405, 21025, 107, 107, 271, + 21025, 21025, 21025, 21025, 21025, 21025, 16675, 21025, 21025, 23200, + 21025, 21025, 21025, 1547, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 1547, 21025, 1310, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 15944, 21025, 21025, 21025, 21025, 21025, -1000, + -1000, -1000, -1000, -1000, -1000, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 1547, 21025, 21025, 21025, 21025, 21025, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 1789, 1736, 1391, 22042, -1000, 1934, -1000, -185, 30742, 22042, - 1709, 2581, 2100, 53942, -1000, -1000, -1000, -1000, 2477, -1000, - 2477, 1789, 3299, 2209, 21317, -1000, -1000, 3299, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1476, -1000, 55392, - 1932, 2443, 53942, -1000, -360, -1000, -361, 2196, 1703, 357, - -1000, 22042, 22042, 1931, -1000, 1276, 55392, -1000, -272, -1000, - 40892, -1000, -1000, 14037, 55392, 381, 55392, -1000, 30017, 40167, - 311, -1000, 37, 1898, -1000, 47, 13, 18417, 851, -1000, - -1000, -1000, 1382, 26392, 1853, 851, 133, -1000, -1000, -1000, - 2029, -1000, 2029, 2029, 2029, 2029, 357, 357, 357, 357, - -1000, -1000, -1000, -1000, -1000, 2055, 2051, -1000, 2029, 2029, - 2029, 2029, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2050, - 2050, 2050, 2049, 2049, 2033, 2033, 437, -1000, 22042, 424, - 39442, 2412, 1224, 1701, 278, 453, 2098, 1332, 1332, 1332, - 453, -1000, 1385, 1352, 1349, -1000, -522, 1928, -1000, -1000, - 2533, -1000, -1000, 1153, 1063, 1053, 1078, 53942, 262, 341, - -1000, 427, -1000, 39442, 1332, 1015, 870, 1332, -1000, 1332, - -1000, -1000, -1000, -1000, -1000, 1332, -1000, -1000, 1925, -1000, - 1919, 1090, 1052, 1079, 1035, 1925, -1000, -1000, -171, 1925, - -1000, 1925, -1000, 1925, -1000, 1925, -1000, 1925, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 976, 122, -329, - 53942, 262, 459, -1000, 457, 33642, -1000, -1000, -1000, 33642, - 33642, -1000, -1000, -1000, -1000, 1697, 1675, -1000, -1000, -1000, + 1537, 1517, 1528, 21025, -1000, 1946, -1000, -190, 29725, 21025, + 1776, 2632, 2144, 52925, -1000, -1000, -1000, -1000, 2514, -1000, + 2514, 1537, 3325, 2248, 20300, -1000, -1000, 3325, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1722, -1000, 54375, + 1945, 2473, 52925, -1000, -276, -1000, -305, 2244, 1775, 901, + -1000, 21025, 21025, 1944, -1000, 2222, 54375, -1000, -246, -1000, + 39875, -1000, -1000, 13020, 54375, 341, 54375, -1000, 29000, 39150, + 296, -1000, 21, 1908, -1000, 14, -6, 17400, 867, -1000, + -1000, -1000, 1382, 25375, 1746, 867, 86, -1000, -1000, -1000, + 2046, -1000, 2046, 2046, 2046, 2046, 901, 901, 901, 901, + -1000, -1000, -1000, -1000, -1000, 2094, 2092, -1000, 2046, 2046, + 2046, 2046, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2087, + 2087, 2087, 2086, 2086, 2061, 2061, 440, -1000, 21025, 411, + 38425, 2445, 1334, 1293, 243, 455, 2139, 1289, 1289, 1289, + 455, -1000, 1507, 1500, 1438, -1000, -523, 1939, -1000, -1000, + 2588, -1000, -1000, 891, 1149, 1142, 1072, 52925, 216, 331, + -1000, 431, -1000, 38425, 1289, 1086, 890, 1289, -1000, 1289, + -1000, -1000, -1000, -1000, -1000, 1289, -1000, -1000, 1930, -1000, + 1909, 1174, 1133, 1163, 1127, 1930, -1000, -1000, -185, 1930, + -1000, 1930, -1000, 1930, -1000, 1930, -1000, 1930, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1028, 281, -313, + 52925, 216, 469, -1000, 464, 32625, -1000, -1000, -1000, 32625, + 32625, -1000, -1000, -1000, -1000, 1768, 1754, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -506, 55392, -1000, 277, - 935, 364, 354, 338, 55392, 333, 2470, 2467, 2455, 2451, - 2450, 2446, 294, 323, 55392, 55392, 447, 2139, 55392, 2421, - 55392, -1000, -1000, -1000, -1000, -1000, 1673, 1643, -1000, 1631, - 55392, -1000, -1000, 1025, 1025, -1000, -1000, 55392, 1025, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1025, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -506, 54375, -1000, 230, + 970, 309, 307, 303, 54375, 329, 2512, 2509, 2503, 2497, + 2487, 2476, 287, 304, 54375, 54375, 454, 2187, 54375, 2452, + 54375, -1000, -1000, -1000, -1000, -1000, 1753, 1747, -1000, 1197, + 54375, -1000, -1000, 1092, 1092, -1000, -1000, 54375, 1092, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1092, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 55392, -1000, -1000, -1000, -1000, -19, 193, - -1000, -1000, 53942, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -105, -1000, 281, 32, 412, -1000, -1000, -1000, - -1000, -1000, 2472, -1000, 1631, 995, 982, -1000, 1967, -1000, - -1000, 1257, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 242, 24217, 24217, 24217, 1554, 834, 1496, 1322, 1351, 1167, - 1167, 929, 24217, 929, 24217, 859, 859, 859, 859, 859, - -1000, -1000, -1000, -1000, -1000, -1000, 1641, -1000, 1628, -1000, - 1967, 54667, 1795, 16961, 2037, 1872, 1499, 869, -1000, -1000, + -1000, -1000, -1000, 54375, -1000, -1000, -1000, -1000, -27, 161, + -1000, -1000, 52925, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -105, -1000, 46, 18, 406, -1000, -1000, -1000, + -1000, -1000, 2502, -1000, 1197, 1079, 1044, -1000, 1982, -1000, + -1000, 1264, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 260, 23200, 23200, 23200, 1414, 830, 1226, 1557, 1567, 1290, + 1290, 981, 23200, 981, 23200, 906, 906, 906, 906, 906, + -1000, -1000, -1000, -1000, -1000, -1000, 1739, -1000, 1725, -1000, + 1982, 53650, 1745, 15944, 2228, 2104, 1547, 916, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 4204, 1793, - -1000, 1793, 1441, 4193, 973, -1000, 22042, 1499, 4188, -1000, - -1000, 1499, 1499, 22042, -1000, -1000, 22042, 22042, 22042, 22042, - 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, - 22042, 1701, 1920, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3431, 1547, + 1667, 1547, 1453, 3423, 1034, -1000, 21025, 1547, 3412, -1000, + -1000, 1547, 1547, 21025, -1000, -1000, 21025, 21025, 21025, 21025, + 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, + 21025, 1293, 1927, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 1915, 2574, 1455, 1701, 1701, 1701, 1701, 1701, 22042, - 1426, -1000, -1000, -1000, 1513, 4177, 1485, 4163, 1701, 1701, - -1000, 1701, 4147, 4143, 1499, 1866, 2912, 2834, 1701, 1701, - 1701, 1701, 1701, 2823, 2788, 1701, 1701, 2777, 1701, 3910, - 1701, 2751, 2652, 2646, 2641, 2635, 2631, 2626, 2618, 2602, - 2585, 2559, 2553, 2544, 2539, 2529, 2525, 2519, 2510, 1701, - 1701, 1701, 3876, 1701, 3867, 1701, 3840, 1701, 1701, 3836, - 2503, 2497, 1499, 1904, -1000, 3832, 1701, 3546, 3527, 3485, - 2480, 3467, 3463, 3451, 1701, 1701, 1701, 2431, 3446, 3439, - 3434, 3374, 3365, 3358, 3350, 3301, 3209, 1701, 1391, 1391, - 1391, 1391, 1391, 3152, -277, 1701, 1499, -1000, -1000, -1000, - -1000, -1000, 3061, 2423, 3056, 3025, 3005, 2994, 1499, 1903, - 1967, 523, -1000, -1000, 1793, 1499, 1499, 1793, 1793, 2990, - 2975, 2969, 2961, 2956, 2946, 1701, 1701, -1000, 1701, 2926, - 2897, 2393, 2375, 1499, -1000, 1391, 55392, -1000, -435, -1000, - 4, 952, 1967, -1000, 37992, 1499, -1000, 4983, -1000, 1198, - -1000, -1000, -1000, -1000, -1000, 35092, 1752, -1000, -1000, -1000, - 1967, 1743, -1000, -1000, -1000, -1000, 357, 99, 34367, 842, - 842, 143, 1631, 1631, 22042, -1000, -1000, -1000, -1000, -1000, - -1000, 522, 2551, 434, 1967, -1000, 1908, 3407, -1000, -1000, - -1000, 2440, 27842, -1000, -1000, 1967, 1967, 55392, 1821, 1818, - -1000, 520, -1000, 1345, 1898, 37, 16, -1000, -1000, -1000, - -1000, 1631, -1000, 1342, 382, 369, -1000, 431, -1000, -1000, - -1000, -1000, 2314, 111, -1000, -1000, -1000, 308, 357, -1000, - -1000, -1000, -1000, -1000, -1000, 1621, 1621, -1000, -1000, -1000, - -1000, -1000, 1210, -1000, -1000, -1000, -1000, 1201, -1000, -1000, - 1188, -1000, -1000, 2667, 2105, 424, -1000, -1000, 909, 1613, - -1000, -1000, 2316, 909, 909, 53942, -1000, -1000, 1840, 2412, - 277, 55392, 980, 2138, -1000, 2098, 2098, 2098, 55392, -1000, - -1000, -1000, -1000, -1000, -1000, -512, 187, 573, -1000, -1000, - -1000, 4187, 53942, 1739, -1000, 257, -1000, 1832, -1000, 53942, - -1000, 1734, 2048, 1332, 1332, -1000, -1000, -1000, 53942, 1967, - -1000, -1000, -1000, -1000, 474, 2377, 335, -1000, -1000, -304, - -1000, -1000, 262, 257, 54667, 1332, 851, -1000, -1000, -1000, - -1000, -1000, -503, 1732, 468, 264, 330, 55392, 55392, 55392, - 55392, 55392, 55392, 499, -1000, -1000, 46, -1000, -1000, 229, - -1000, -1000, -1000, -1000, -1000, 229, -1000, -1000, -1000, -1000, - -1000, 310, 448, -1000, 55392, 55392, 928, -1000, -1000, -1000, - -1000, -1000, 1028, -1000, -1000, 1028, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 2354, 55392, 17, -474, - -1000, -470, 22042, -1000, -1000, -1000, -1000, 1405, 829, 1496, - 24217, 24217, 1294, 1294, 24217, -1000, -1000, -1000, 930, 930, - 33642, -1000, 24217, 22042, 21317, -1000, -1000, 22042, 22042, 22042, - 913, -1000, 22042, 1410, -1000, 22042, -1000, -1000, 1391, 1701, - 1701, 1701, 1701, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 1948, -1000, 22042, 22042, 22042, 1499, 334, - -1000, -1000, -1000, -1000, -1000, 2572, -1000, 22042, -1000, 33642, - 22042, 22042, 22042, -1000, -1000, -1000, 22042, 22042, -1000, -1000, - 22042, -1000, 22042, -1000, -1000, -1000, -1000, -1000, -1000, 22042, - -1000, 22042, -1000, -1000, -1000, 22042, -1000, 22042, -1000, -1000, - 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, - 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, - 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, - 22042, -1000, 22042, -1000, 22042, -1000, -1000, -1000, 22042, -1000, - 22042, -1000, 22042, -1000, -1000, 22042, -1000, 22042, -1000, 22042, - -1000, 22042, 22042, -1000, 22042, 22042, 22042, -1000, 22042, 22042, - 22042, 22042, -1000, -1000, -1000, -1000, 22042, 22042, 22042, 22042, - 22042, 22042, 22042, 22042, 22042, 22042, -1000, -1000, -1000, -1000, - -1000, -1000, 22042, -1000, 39442, 14, -277, 1307, 14, 1307, - 23492, 796, 795, 22767, -1000, 21317, 16230, -1000, -1000, -1000, - -1000, -1000, 22042, 22042, 22042, 22042, 22042, 22042, -1000, -1000, - -1000, 22042, 22042, -1000, 22042, -1000, 22042, -1000, -1000, -1000, - -1000, -1000, 952, -1000, 867, 815, 870, 53942, -1000, -1000, - -1000, -1000, 1893, -1000, 2465, -1000, 2225, 2221, 2555, 2551, - -1000, 30017, -1000, -1000, 53942, -426, -1000, 2276, 2282, 842, - 842, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 13306, 2477, - 22042, 2134, 54667, 250, -1000, 29292, 53942, 54667, 30017, 30017, - 30017, 30017, 30017, -1000, 2188, 2182, -1000, 2166, 2157, 2184, - 55392, -1000, 1789, 1727, -1000, 22042, 32192, 1837, 30017, -1000, - -1000, 30017, 55392, 12575, -1000, -1000, 12, 3, -1000, -1000, - -1000, -1000, 1382, -1000, -1000, 969, 2434, 2312, -1000, -1000, - -1000, -1000, -1000, 1723, -1000, 1717, 1890, 1715, 1690, 122, - -1000, 2042, 2347, 909, 909, -1000, 1185, -1000, 1332, 1606, - 1588, -1000, -1000, -1000, 467, -1000, 2419, 55392, 2131, 2128, - 2127, -1000, -520, 1182, 2047, 1992, 22042, 2045, 2532, 1880, - 53942, -1000, -1000, 54667, -1000, 299, -1000, 424, 53942, -1000, - -1000, -1000, 341, 55392, -1000, 5569, -1000, -1000, -1000, 257, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 55392, 276, -1000, - 2036, 1261, -1000, -1000, 2096, -1000, -1000, -1000, -1000, -1000, - 245, 230, 1586, 227, 1546, 227, -1000, 55392, 927, 2105, - 55392, -1000, -1000, -1000, 1025, 1025, -1000, -1000, 2338, -1000, - 1332, 1701, 24217, 24217, -1000, 853, -1000, -1000, 383, -254, - 2029, 2029, -1000, 2029, 2033, -1000, 2029, 189, 2029, 188, - 2029, -1000, -1000, 1499, 1499, -1000, 1391, -1000, 2344, 1929, - 2887, -1000, 1631, 22042, 2880, -1000, -1000, -1000, -1000, -1000, - -63, 2796, 2756, 1701, -1000, 2026, 2023, 22042, 1701, 1499, - 2319, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, - 1701, 1701, 1701, 2309, 2295, 2287, 2281, 2274, 2263, 2249, - 2218, 2206, 2193, 2168, 2159, 2146, 2130, 2080, 2070, 1701, - 1701, 2059, 1701, 2052, 2030, -1000, 1631, 1391, 2436, 1391, - 1701, 1701, 2397, 319, 1701, 1688, 1688, 1688, 1688, 1688, - 1391, 1391, 1391, 1391, 1701, 53942, -1000, -277, -1000, -1000, - -371, -374, -1000, 1499, -277, 1889, 24217, 1701, 24217, 24217, - 24217, 1701, 1499, -1000, 1987, 1972, 2325, 1937, 1701, 2302, - 1701, 1701, 1701, 1905, -1000, 2466, 1967, 2466, 1967, 2466, - 1620, 1198, 55392, -1000, -1000, -1000, -1000, 2551, 2528, 1888, - -1000, 99, 614, -1000, 2273, 2282, -1000, 2531, 2293, 2530, - -1000, -1000, -1000, -1000, -1000, 1631, -1000, 2394, 1860, -1000, - 932, 1867, -1000, -1000, 20592, 1672, 2213, 519, 1620, 1922, - 3407, 2088, 2126, 3490, -1000, -1000, -1000, -1000, 2175, -1000, - 2170, -1000, -1000, 1981, -1000, 1858, 381, 30017, 1851, 1851, - -1000, 516, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1080, - 5569, 2596, -1000, 1543, -1000, 1340, 208, 1178, -1000, -1000, - 909, 909, -1000, 1010, 1007, -1000, 55392, 2019, -1000, 357, - 1541, 357, 1172, -1000, -1000, 1165, -1000, -1000, -1000, -1000, - 2014, 2151, -1000, -1000, -1000, -1000, 55392, -1000, -1000, 55392, - 55392, 55392, 1998, 2514, -1000, 22042, 1994, 914, 2535, 53942, - 53942, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, 808, 909, -485, 318, 314, 909, 909, 909, - -521, -1000, -1000, 1617, 1553, -1000, -215, -1000, 22042, -1000, - -1000, -1000, -1000, -1000, 1286, 1286, 1537, 1524, 1518, -1000, - 1981, -1000, -1000, -1000, 1790, -1000, -1000, -181, 53942, 53942, - 53942, 53942, -1000, -1000, -1000, 1122, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 853, 1499, - 343, -187, 1499, -1000, -1000, 357, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 22042, -1000, 22042, -1000, - 22042, 1631, 22042, 2477, 1509, 22042, 22042, -1000, 1163, 1155, - 1701, -1000, -1000, -1000, 22042, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 22042, -1000, - 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, - 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, - 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, 22042, -1000, - -1000, 22042, -1000, -1000, -1000, 22042, -1000, 22042, -1000, 22042, - -1000, -1000, -1000, 22042, 287, 930, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1499, 377, -1000, - -1000, -1000, -1000, 2534, -1000, 1499, 22042, 1294, -1000, 1294, - 1294, 1294, -1000, -1000, -1000, 22042, -1000, 22042, 22042, -1000, - 22042, -1000, 22042, -1000, -1000, -1000, -1000, 22042, 1967, 2208, - 38717, 1967, 38717, 1967, 32192, -1000, -1000, 2528, 2512, 2509, - 2243, 2256, 2256, 2273, -1000, 2507, 2494, -1000, 1500, 2489, - 1492, 1002, -1000, 54667, 22042, 250, -1000, 414, 53942, 250, - 53942, -1000, 2504, -1000, -1000, 22042, 1991, -1000, 22042, -1000, - -1000, -1000, -1000, 3215, 2551, 1851, -1000, -1000, 863, -1000, - 22042, -1000, 10388, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 1477, 1471, -1000, -1000, 1983, 22042, -1000, -1000, -1000, - 1753, 1740, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 1981, -1000, -1000, -1000, -1000, 341, -516, 2125, 53942, 1147, - -1000, 1532, 1880, 373, 250, 1465, 909, 909, 909, 1125, - 1117, 37992, 1517, -1000, 53942, 418, -1000, 341, -1000, -222, - -224, 1701, -1000, -1000, 2432, -1000, -1000, 16230, -1000, -1000, - 1980, 2097, -1000, -1000, -1000, -1000, 2163, -169, -198, -1000, - -1000, 1701, 1701, 1701, 1255, 1499, -1000, 1701, 1701, 1735, - 1627, -1000, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, - 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, - 1701, 1701, 1391, 1895, -1000, 287, 1499, 2123, -1000, -1000, - 3215, -1000, -1000, 2504, 2483, 14, -1000, -1000, 259, 14, - 1631, 946, 1499, 1499, 946, 1823, 1701, 1788, 1761, 1701, - 1701, 32917, -1000, 2482, 2481, 1498, -1000, -1000, 38717, 1498, - 38717, 952, 2512, -286, 22042, 22042, 2238, 1173, -1000, -1000, - -1000, -1000, 1457, 1444, -1000, 1420, -1000, 2593, -1000, 1631, - -1000, 250, -1000, 504, 1867, -1000, 2477, 1631, 53942, 1631, - 100, 2504, -1000, 1701, -1000, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, 1967, - 1967, 1967, 1967, 1967, -1000, -1000, 53942, 2118, -1000, -1000, - 2429, 1515, 164, -1000, 1505, 1880, -1000, -1000, 220, -1000, - 22042, -1000, 37992, 1418, 1408, -1000, -1000, -1000, -1000, -521, - -1000, -1000, -1000, -1000, -1000, -1000, 387, 1876, -1000, 908, - 53942, 55392, -1000, 2038, -1000, -1000, -1000, -1000, 22042, -1000, + -1000, 1911, 2627, 1312, 1293, 1293, 1293, 1293, 1293, 21025, + 1813, -1000, -1000, -1000, 1514, 3407, 1348, 3402, 1293, 1293, + -1000, 1293, 3389, 3373, 1547, 2536, 2531, 1293, 1293, 1293, + 1293, 1293, 2527, 2523, 1293, 1293, 2506, 1293, 3363, 1293, + 2501, 2456, 2443, 2434, 2428, 2424, 2419, 2414, 2354, 2344, + 2340, 2321, 2307, 2278, 2250, 2246, 2240, 2234, 1293, 1293, + 1293, 3354, 1293, 3349, 1293, 3340, 1293, 1293, 3333, 2216, + 2177, 1547, 1910, -1000, 3326, 1293, 3290, 3060, 3053, 2173, + 3026, 3017, 3000, 1293, 1293, 1293, 2169, 2996, 2988, 2969, + 2951, 2940, 2922, 2918, 2912, 2892, 1293, 1528, 1528, 1528, + 1528, 1528, 2882, -248, 1293, 1547, -1000, -1000, -1000, -1000, + -1000, 2850, 2146, 2836, 2820, 2815, 2789, 1547, 1982, 839, + -1000, -1000, 1528, 1547, 1547, 1528, 1528, 2780, 2720, 2703, + 2698, 2693, 2657, 1293, 1293, -1000, 1293, 2647, 2637, 2140, + 2135, 1547, -1000, 1528, 54375, -1000, -435, -1000, 3, 964, + 1982, -1000, 36975, 1547, -1000, 4191, -1000, 1268, -1000, -1000, + -1000, -1000, -1000, 34075, 1823, -1000, -1000, -1000, -1000, 1982, + 1743, -1000, -1000, -1000, -1000, 901, 76, 33350, 895, 895, + 102, 1197, 1197, 21025, -1000, -1000, -1000, -1000, -1000, -1000, + 837, 2606, 413, 1982, -1000, 1866, 2398, -1000, -1000, -1000, + 2464, 26825, -1000, -1000, 1982, 1982, 54375, 2034, 1942, -1000, + 828, -1000, 1407, 1908, 21, -9, -1000, -1000, -1000, -1000, + 1197, -1000, 1434, 344, 392, -1000, 434, -1000, -1000, -1000, + -1000, 2350, 82, -1000, -1000, -1000, 311, 901, -1000, -1000, + -1000, -1000, -1000, -1000, 1714, 1714, -1000, -1000, -1000, -1000, + -1000, 1327, -1000, -1000, -1000, -1000, 1326, -1000, -1000, 1321, + -1000, -1000, 2633, 2124, 411, -1000, -1000, 941, 1689, -1000, + -1000, 2361, 941, 941, 52925, -1000, -1000, 1737, 2445, 230, + 54375, 1031, 2183, -1000, 2139, 2139, 2139, 54375, -1000, -1000, + -1000, -1000, -1000, -1000, -510, 188, 363, -1000, -1000, -1000, + 5040, 52925, 1736, -1000, 206, -1000, 1711, -1000, 52925, -1000, + 1734, 2076, 1289, 1289, -1000, -1000, -1000, 52925, 1982, -1000, + -1000, -1000, -1000, 510, 2416, 336, -1000, -1000, -266, -1000, + -1000, 216, 206, 53650, 1289, 867, -1000, -1000, -1000, -1000, + -1000, -511, 1731, 507, 220, 325, 54375, 54375, 54375, 54375, + 54375, 54375, 812, -1000, -1000, 32, -1000, -1000, 184, -1000, + -1000, -1000, -1000, -1000, 184, -1000, -1000, -1000, -1000, -1000, + 270, 463, -1000, 54375, 54375, 931, -1000, -1000, -1000, -1000, + -1000, 1095, -1000, -1000, 1095, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 2402, 54375, 10, -477, -1000, + -474, 21025, -1000, -1000, -1000, -1000, 1307, 822, 1226, 23200, + 23200, 1203, 1203, 23200, -1000, -1000, -1000, 971, 971, 32625, + -1000, 23200, 21025, -1000, -1000, 21025, 21025, 21025, 1017, -1000, + 21025, 1192, -1000, 21025, -1000, -1000, 1528, 1293, 1293, 1293, + 1293, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 1947, -1000, 21025, 21025, 21025, 1547, 300, -1000, -1000, + -1000, -1000, -1000, 2624, -1000, 21025, -1000, 32625, 21025, 21025, + 21025, -1000, -1000, -1000, 21025, 21025, -1000, -1000, 21025, -1000, + 21025, -1000, -1000, -1000, -1000, -1000, -1000, 21025, -1000, 21025, + -1000, -1000, -1000, 21025, -1000, 21025, -1000, -1000, 21025, -1000, + 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, + 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, + 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, + 21025, -1000, 21025, -1000, -1000, -1000, 21025, -1000, 21025, -1000, + 21025, -1000, -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, + 21025, -1000, 21025, 21025, 21025, -1000, 21025, 21025, 21025, 21025, + -1000, -1000, -1000, -1000, 21025, 21025, 21025, 21025, 21025, 21025, + 21025, 21025, 21025, 21025, -1000, -1000, -1000, -1000, -1000, -1000, + 21025, -1000, 38425, 13, -248, 1310, 13, 1310, 22475, 851, + 847, 21750, -1000, 21025, 15213, -1000, -1000, -1000, -1000, -1000, + 21025, 21025, 21025, 21025, 21025, 21025, -1000, -1000, -1000, 21025, + 21025, -1000, 21025, -1000, 21025, -1000, -1000, -1000, -1000, -1000, + 964, -1000, 877, 866, 890, 52925, -1000, -1000, -1000, -1000, + 1904, -1000, 2495, -1000, 2269, 2268, 2623, 2606, 20300, -1000, + 29000, -1000, -1000, 52925, -426, -1000, 2299, 2303, 895, 895, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 12289, 2514, 21025, + 2182, 53650, 256, -1000, 28275, 52925, 53650, 29000, 29000, 29000, + 29000, 29000, -1000, 2224, 2212, -1000, 2223, 2200, 2356, 54375, + -1000, 1537, 1729, -1000, 21025, 31175, 1836, 29000, -1000, -1000, + 29000, 54375, 11558, -1000, -1000, 9, -12, -1000, -1000, -1000, + -1000, 1382, -1000, -1000, 933, 2463, 2336, -1000, -1000, -1000, + -1000, -1000, 1721, -1000, 1710, 1903, 1707, 1703, 281, -1000, + 2063, 2400, 941, 941, -1000, 1317, -1000, 1289, 1687, 1677, + -1000, -1000, -1000, 504, -1000, 2435, 54375, 2179, 2178, 2175, + -1000, -520, 1283, 2070, 2052, 21025, 2066, 2585, 1859, 52925, + -1000, -1000, 53650, -1000, 290, -1000, 411, 52925, -1000, -1000, + -1000, 331, 54375, -1000, 9513, -1000, -1000, -1000, 206, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 54375, 233, -1000, 2065, + 1294, -1000, -1000, 2134, -1000, -1000, -1000, -1000, -1000, 205, + 185, 1675, 189, 1673, 189, -1000, 54375, 929, 2124, 54375, + -1000, -1000, -1000, 1092, 1092, -1000, -1000, 2385, -1000, 1289, + 1293, 23200, 23200, -1000, 900, -1000, -1000, 505, -227, 2046, + 2046, -1000, 2046, 2061, -1000, 2046, 153, 2046, 150, 2046, + -1000, -1000, 1547, 1547, -1000, 1528, 2078, 1861, 2628, -1000, + 1197, 21025, 2615, -1000, -1000, -1000, -1000, -1000, -74, 2607, + 2600, 1293, -1000, 2039, 2038, 21025, 1293, 1547, 2071, 1293, + 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, + 1293, 2067, 2062, 2058, 2053, 2047, 2043, 2035, 2028, 2022, + 1987, 1966, 1924, 1917, 1905, 1897, 1879, 1293, 1293, 1874, + 1293, 1837, 1818, -1000, 1197, 1528, 2594, 1528, 1293, 1293, + 2589, 313, 1293, 1697, 1697, 1697, 1697, 1697, 1528, 1528, + 1528, 1528, 1293, 52925, -1000, -248, -1000, -1000, -295, -298, + -1000, 1547, -248, 1882, 23200, 1293, 23200, 23200, 23200, 1293, + 1547, -1000, 1809, 1803, 2557, 1798, 1293, 2265, 1293, 1293, + 1293, 1773, -1000, 2496, 1982, 2496, 1982, 2496, 1671, 1268, + 54375, -1000, -1000, -1000, -1000, 2606, 2597, -1000, 1871, -1000, + 76, 641, -1000, 2313, 2303, -1000, 2584, 2295, 2571, -1000, + -1000, -1000, -1000, -1000, 1197, -1000, 2420, 1854, -1000, 967, + 1848, -1000, -1000, 19575, 1686, 2267, 827, 1671, 1901, 2398, + 2149, 2171, 3029, -1000, -1000, -1000, -1000, 2206, -1000, 2202, + -1000, -1000, 2010, -1000, 2260, 341, 29000, 1877, 1877, -1000, + 824, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1158, 9513, + 2662, -1000, 1666, -1000, 1406, 265, 1270, -1000, -1000, 941, + 941, -1000, 1075, 1069, -1000, 54375, 2033, -1000, 901, 1655, + 901, 1267, -1000, -1000, 1259, -1000, -1000, -1000, -1000, 1994, + 2159, -1000, -1000, -1000, -1000, 54375, -1000, -1000, 54375, 54375, + 54375, 2032, 2568, -1000, 21025, 2014, 957, 2511, 52925, 52925, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 456, 941, -490, 298, 294, 941, 941, 941, -522, + -1000, -1000, 1662, 1660, -1000, -211, -1000, 21025, -1000, -1000, + -1000, -1000, -1000, 1344, 1344, 1653, 1627, 1621, -1000, 2010, + -1000, -1000, -1000, 1704, -1000, -1000, -188, 52925, 52925, 52925, + 52925, -1000, -1000, -1000, 1353, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 900, 1547, 394, + -198, 1547, -1000, -1000, 901, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 21025, -1000, 21025, -1000, 21025, + 1197, 21025, 2514, 1579, 21025, 21025, -1000, 1256, 1249, 1293, + -1000, -1000, -1000, 21025, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 21025, -1000, 21025, + -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, + -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, + -1000, 21025, -1000, 21025, -1000, 21025, -1000, 21025, -1000, -1000, + 21025, -1000, -1000, -1000, 21025, -1000, 21025, -1000, 21025, -1000, + -1000, -1000, 21025, 314, 971, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 1547, 334, -1000, -1000, + -1000, -1000, 2619, -1000, 1547, 21025, 1203, -1000, 1203, 1203, + 1203, -1000, -1000, -1000, 21025, -1000, 21025, 21025, -1000, 21025, + -1000, 21025, -1000, -1000, -1000, -1000, 21025, 1982, 2283, 37700, + 1982, 37700, 1982, 31175, -1000, -1000, 2597, 2591, 2553, 2286, + 2288, 2288, 2313, -1000, 2552, 2543, -1000, 1575, 2538, 1553, + 1056, -1000, 53650, 21025, 256, -1000, 419, 52925, 256, 52925, + -1000, 2533, -1000, -1000, 21025, 2012, -1000, 21025, -1000, -1000, + -1000, -1000, 6888, 2606, 1877, -1000, -1000, 913, -1000, 21025, + -1000, 54857, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 1550, 1548, -1000, -1000, 2011, 21025, -1000, -1000, -1000, 1700, + 1631, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2010, + -1000, -1000, -1000, -1000, 331, -515, 2490, 52925, 1229, -1000, + 1620, 1859, 286, 256, 1541, 941, 941, 941, 1221, 1215, + 36975, 1616, -1000, 52925, 407, -1000, 331, -1000, -220, -224, + 1293, -1000, -1000, 2462, -1000, -1000, 15213, -1000, -1000, 1993, + 2137, -1000, -1000, -1000, -1000, 2236, -183, -202, -1000, -1000, + 1293, 1293, 1293, 1997, 1547, -1000, 1293, 1293, 1617, 1608, + -1000, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, + 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, 1293, + 1293, 1528, 1761, -1000, 314, 1547, 2168, -1000, -1000, 6888, + -1000, -1000, 2533, 2535, 13, -1000, -1000, 212, 13, 1197, + 1001, 1547, 1547, 1001, 1699, 1293, 1665, 1630, 1293, 1293, + 31900, -1000, 2522, 2518, 1584, -1000, -1000, 37700, 1584, 37700, + 964, 2591, -255, 21025, 21025, 2281, 1232, -1000, -1000, -1000, + -1000, 1529, 1515, -1000, 1476, -1000, 2659, -1000, 1197, -1000, + 256, -1000, 819, 1848, -1000, 2514, 1197, 52925, 1197, 68, + 2533, -1000, 1293, -1000, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, 1982, + 1982, 1982, 1982, -1000, -1000, 52925, 2298, -1000, -1000, 2459, + 1586, 187, -1000, 1587, 1859, -1000, -1000, 250, -1000, 21025, + -1000, 36975, 1444, 1440, -1000, -1000, -1000, -1000, -522, -1000, + -1000, -1000, -1000, -1000, -1000, 389, 1856, -1000, 936, 52925, + 54375, -1000, 2233, -1000, -1000, -1000, -1000, 21025, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 22042, -1000, 1499, 2116, - -1000, -362, -1000, -494, 22042, -277, -1000, -1000, -277, -1000, - -1000, -1000, -1000, -1000, 22042, -1000, -1000, 22042, -1000, 22042, - -1000, -1000, 1498, -1000, -1000, -1000, 37267, -1000, 1498, -1000, - 1498, -1000, -286, -1000, 1868, -1000, 53942, 1631, 1866, -1000, - 1145, -1000, -1000, -1000, -1000, -1000, 54667, 1867, 53942, -1000, - 1475, 1499, 1967, 2477, -1000, 1416, -1000, 387, -1000, 1978, - 1992, -1000, -1000, -1000, 19867, -1000, -1000, -1000, -1000, -1000, - 234, -175, 16230, 11844, 1396, -1000, -173, 1701, 1391, -1000, - -462, -1000, -1000, -1000, -1000, 292, -1000, -1000, 1866, -1000, - -1000, 1695, 1646, 1626, -1000, -1000, -1000, -1000, -1000, -1000, - -286, -1000, -1000, 2424, -1000, -1000, 1555, -1000, -1000, 32192, - 53217, -1000, -164, 327, -175, 22042, 1977, 1499, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -41, -1000, -1000, 503, - -1000, -1000, -1000, 2096, -196, -1000, -1000, -1000, 295, -477, - -281, -283, 24217, -1000, 22042, -1000, 22042, -1000, 22042, -1000, - 53942, 1967, -1000, 1389, -1000, 4148, -384, 2104, -1000, -134, - -1000, -1000, -1000, 1047, 1380, -1000, -1000, -1000, -1000, -1000, - -1000, 1899, 53942, -1000, 433, -1000, -1000, 15499, -181, -213, - 974, -1000, -1000, -1000, -1000, -1000, 1294, 1504, 1414, 1701, - -1000, 53942, -1000, 53217, -379, 851, 3215, -1000, 2034, 1982, - 2580, -1000, -1000, -1000, -1000, -1000, -1000, -527, 1384, 279, - -1000, -1000, -1000, 295, -288, -1000, 22042, -1000, 22042, -1000, - 1499, -1000, -1000, 2404, 100, -1000, 2587, -1000, 2588, 1003, - 1003, -1000, 1112, -527, -1000, -1000, -1000, -1000, 1701, 1701, - -1000, -385, -1000, -1000, -1000, -1000, -1000, 432, 1194, -1000, - -1000, -1000, -1000, -1000, 3215, -1000, -1000, -1000, 289, 289, - -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 21025, -1000, 1547, 2165, -1000, + -360, -1000, -495, 21025, -248, -1000, -1000, -248, -1000, -1000, + -1000, -1000, -1000, 21025, -1000, -1000, 21025, -1000, 21025, -1000, + -1000, 1584, -1000, -1000, -1000, 36250, -1000, 1584, -1000, 1584, + -1000, -255, -1000, 1849, -1000, 52925, 1197, 1667, -1000, 1220, + -1000, -1000, -1000, -1000, -1000, 53650, 1848, 52925, -1000, 1546, + 1547, 1982, 2514, -1000, 1539, -1000, 389, -1000, 1986, 2052, + -1000, -1000, -1000, 18850, -1000, -1000, -1000, -1000, -1000, 244, + -187, 15213, 10827, 1533, -1000, -186, 1293, 1528, -1000, -466, + -1000, -1000, -1000, -1000, 288, -1000, -1000, 1667, -1000, -1000, + 1626, 1604, 1524, -1000, -1000, -1000, -1000, -1000, -1000, -255, + -1000, -1000, 2455, -1000, -1000, 1628, -1000, -1000, 31175, 52200, + -1000, -175, 408, -187, 21025, 1984, 1547, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -39, -1000, -1000, 807, -1000, + -1000, -1000, 2134, -199, -1000, -1000, -1000, 308, -481, -271, + -280, 23200, -1000, 21025, -1000, 21025, -1000, 21025, -1000, 52925, + 1982, -1000, 1526, -1000, 4190, -377, 2164, -1000, -129, -1000, + -1000, -1000, 1098, 1420, -1000, -1000, -1000, -1000, -1000, -1000, + 1350, 52925, -1000, 437, -1000, -1000, 14482, -188, -203, 1035, + -1000, -1000, -1000, -1000, -1000, 1203, 1276, 1269, 1293, -1000, + 52925, -1000, 52200, -320, 867, 6888, -1000, 2156, 2153, 2614, + -1000, -1000, -1000, -1000, -1000, -1000, -532, 1512, 234, -1000, + -1000, -1000, 308, -286, -1000, 21025, -1000, 21025, -1000, 1547, + -1000, -1000, 2431, 68, -1000, 2616, -1000, 2638, 1026, 1026, + -1000, 1188, -532, -1000, -1000, -1000, -1000, 1293, 1293, -1000, + -388, -1000, -1000, -1000, -1000, -1000, 433, 1288, -1000, -1000, + -1000, -1000, -1000, 6888, -1000, -1000, -1000, 203, 203, -1000, + -1000, } var yyPgo = [...]int{ - 0, 3336, 3335, 26, 12, 36, 35, 3334, 3333, 3332, - 176, 3331, 3323, 3322, 3319, 3316, 3297, 2690, 2686, 2681, - 3294, 3292, 3285, 3284, 3283, 3227, 3224, 3222, 3218, 45, - 97, 37, 110, 220, 214, 3217, 181, 159, 201, 3215, - 3211, 3198, 114, 189, 78, 82, 193, 3196, 3195, 66, - 3192, 3190, 3189, 188, 180, 179, 1020, 3187, 186, 113, - 55, 3186, 3184, 3182, 3171, 3170, 3167, 3165, 3162, 3161, - 3160, 3157, 3155, 3154, 3152, 3144, 3143, 3142, 3141, 301, - 3139, 3136, 14, 3132, 73, 3130, 3126, 3123, 3122, 3121, - 9, 3120, 3117, 32, 42, 3115, 3109, 44, 3108, 3106, - 3103, 3101, 3098, 79, 3096, 23, 3095, 38, 3093, 3091, - 121, 3088, 3086, 3085, 39, 3084, 3081, 3077, 11, 169, - 3071, 3068, 138, 3063, 3062, 3061, 168, 222, 3054, 2240, - 160, 100, 105, 3049, 3048, 3042, 163, 196, 3037, 117, - 3036, 3032, 3025, 145, 3022, 3825, 3012, 3004, 67, 65, - 203, 3003, 3000, 164, 74, 5, 2999, 20, 8, 2997, - 2996, 70, 64, 2995, 103, 2993, 2992, 98, 89, 2990, - 99, 94, 2988, 2985, 28, 2, 2982, 1, 6, 4, - 102, 2980, 2974, 109, 2963, 2962, 2959, 92, 2955, 2949, - 1068, 2941, 84, 128, 101, 63, 2938, 170, 171, 2935, - 2934, 2933, 2928, 2925, 50, 2922, 2919, 2915, 136, 252, - 166, 2914, 146, 341, 51, 147, 2910, 191, 77, 199, - 192, 2908, 2907, 130, 135, 2905, 2902, 54, 167, 195, - 2898, 91, 129, 116, 177, 90, 132, 2896, 2881, 56, - 61, 2879, 2874, 2870, 2868, 172, 2865, 2858, 68, 2857, - 53, 2854, 173, 2848, 137, 80, 2847, 182, 162, 2843, - 62, 2842, 2839, 93, 95, 60, 27, 2834, 155, 158, - 126, 183, 2833, 2831, 52, 2826, 2824, 2821, 194, 315, - 2820, 2819, 373, 174, 141, 149, 83, 2817, 334, 2814, - 2812, 19, 4982, 7758, 2804, 41, 157, 2803, 2802, 7552, - 22, 43, 15, 2801, 205, 2799, 2797, 2791, 2788, 197, - 204, 108, 156, 58, 2786, 2783, 2780, 72, 2777, 2773, - 2766, 2764, 2763, 2754, 34, 33, 31, 71, 215, 59, - 25, 96, 152, 151, 69, 2753, 2752, 2751, 120, 87, - 2750, 154, 153, 124, 165, 2748, 178, 140, 118, 2747, - 106, 30, 2744, 2740, 2739, 2738, 85, 2737, 2734, 2733, - 2732, 150, 142, 119, 81, 2727, 76, 115, 148, 143, - 57, 2723, 46, 2722, 2719, 29, 190, 24, 2718, 47, - 104, 112, 2717, 6263, 187, 2712, 13, 337, 161, 2711, - 2705, 10, 18, 21, 2704, 2701, 2699, 2698, 131, 2677, - 2667, 2661, 2659, 17, 49, 16, 7, 111, 75, 2652, - 2637, 139, 2636, 2627, 2617, 0, 1021, 127, 2616, 200, + 0, 3315, 3313, 23, 11, 37, 36, 3309, 3297, 3295, + 173, 3291, 3290, 3289, 3225, 3224, 3222, 2705, 2684, 2682, + 3217, 3215, 3214, 3213, 3205, 3199, 3198, 3195, 3193, 40, + 105, 32, 97, 200, 197, 3190, 174, 159, 192, 3188, + 3186, 3185, 113, 183, 82, 85, 191, 3182, 3171, 71, + 3168, 3166, 3165, 188, 187, 180, 1076, 3162, 186, 112, + 50, 3156, 3155, 3154, 3152, 3150, 3148, 3147, 3146, 3136, + 3134, 3133, 3130, 3126, 3123, 3122, 3121, 3120, 3119, 248, + 3118, 3117, 13, 3116, 73, 3114, 3111, 3102, 3096, 3093, + 12, 3091, 3090, 29, 42, 3088, 3087, 48, 3086, 3079, + 3076, 3071, 3070, 76, 3069, 21, 3067, 39, 3054, 3048, + 125, 3047, 3046, 3045, 45, 3043, 3042, 3041, 10, 165, + 3039, 3038, 140, 3037, 3034, 3032, 167, 217, 3031, 2271, + 3028, 100, 3027, 3022, 3020, 163, 189, 3016, 119, 3013, + 3012, 3009, 148, 3006, 3263, 3005, 3003, 65, 79, 203, + 3002, 2999, 164, 74, 8, 2996, 7, 19, 2995, 2990, + 70, 68, 2989, 106, 2988, 2987, 103, 89, 2985, 95, + 99, 2983, 2976, 26, 5, 2975, 1, 6, 4, 67, + 2974, 2972, 115, 2970, 2968, 2967, 93, 2966, 2965, 6222, + 2941, 90, 130, 104, 63, 2940, 168, 160, 2938, 2937, + 2936, 2934, 2931, 51, 2929, 2918, 2917, 138, 1762, 128, + 2915, 144, 341, 53, 146, 2914, 202, 75, 196, 169, + 2908, 2906, 137, 132, 2901, 2899, 56, 166, 194, 2898, + 92, 129, 117, 175, 91, 133, 2897, 2895, 57, 61, + 2894, 2893, 2892, 2889, 171, 2888, 2887, 66, 2876, 55, + 2875, 190, 2873, 136, 84, 2870, 181, 170, 2867, 62, + 2866, 2865, 96, 101, 60, 38, 2862, 157, 161, 126, + 172, 2838, 2835, 54, 2829, 2827, 2825, 195, 314, 2823, + 2822, 299, 178, 142, 147, 83, 2820, 332, 2818, 2817, + 18, 4363, 6742, 2814, 41, 162, 2813, 2812, 6402, 25, + 47, 24, 2811, 205, 2810, 2808, 2806, 2804, 223, 204, + 109, 158, 58, 2803, 2802, 2799, 69, 2796, 2795, 2794, + 2789, 2786, 2785, 34, 33, 31, 72, 211, 59, 22, + 98, 152, 153, 64, 2783, 2779, 2775, 124, 78, 2773, + 156, 155, 123, 108, 2768, 179, 143, 114, 2766, 94, + 30, 2765, 2764, 2762, 2761, 87, 2760, 2754, 2753, 2752, + 154, 145, 121, 80, 2747, 81, 116, 150, 149, 52, + 2745, 46, 2742, 2740, 28, 184, 27, 2739, 44, 102, + 110, 2734, 6202, 182, 2731, 14, 325, 151, 2729, 2728, + 9, 17, 20, 2727, 2725, 2722, 2720, 131, 2719, 2718, + 2715, 2712, 16, 49, 15, 2, 111, 77, 2711, 2710, + 141, 2706, 2699, 2693, 0, 1021, 127, 2686, 198, } -//line sql.y:8625 +//line sql.y:8616 type yySymType struct { union any empty struct{} @@ -8435,59 +8376,59 @@ func (st *yySymType) withUnion() *With { } var yyR1 = [...]int{ - 0, 413, 414, 414, 7, 7, 7, 7, 7, 7, + 0, 412, 413, 413, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 260, 383, 384, 384, 258, 258, 28, 74, 36, + 7, 259, 382, 383, 383, 257, 257, 28, 74, 36, 36, 35, 35, 38, 38, 37, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 29, 29, 29, 29, 30, 30, 30, 30, 30, 15, 16, 34, 34, 17, 17, 108, 108, 18, - 19, 19, 19, 19, 417, 417, 185, 185, 183, 183, - 184, 184, 263, 263, 20, 267, 267, 269, 269, 269, - 269, 259, 259, 259, 21, 21, 268, 268, 270, 270, - 270, 273, 273, 273, 273, 312, 312, 312, 22, 22, - 22, 22, 22, 128, 128, 386, 386, 385, 379, 379, - 378, 378, 377, 382, 382, 381, 381, 380, 40, 41, - 50, 50, 50, 50, 51, 52, 387, 387, 352, 57, + 19, 19, 19, 19, 416, 416, 184, 184, 182, 182, + 183, 183, 262, 262, 20, 266, 266, 268, 268, 268, + 268, 258, 258, 258, 21, 21, 267, 267, 269, 269, + 269, 272, 272, 272, 272, 311, 311, 311, 22, 22, + 22, 22, 22, 128, 128, 385, 385, 384, 378, 378, + 377, 377, 376, 381, 381, 380, 380, 379, 40, 41, + 50, 50, 50, 50, 51, 52, 386, 386, 351, 57, 57, 56, 56, 56, 56, 56, 56, 58, 58, 54, - 54, 53, 53, 55, 55, 354, 354, 340, 340, 353, - 353, 353, 353, 353, 353, 353, 339, 339, 140, 140, - 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, - 237, 237, 237, 237, 237, 237, 237, 402, 402, 402, - 401, 401, 238, 238, 238, 238, 238, 238, 238, 238, - 149, 149, 161, 161, 161, 161, 161, 161, 147, 147, - 148, 146, 146, 146, 154, 154, 154, 154, 154, 154, - 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, - 154, 406, 406, 406, 406, 406, 406, 406, 406, 406, - 406, 406, 406, 406, 406, 406, 406, 406, 406, 406, - 406, 406, 406, 406, 406, 406, 406, 406, 406, 406, - 406, 406, 406, 406, 406, 406, 406, 406, 406, 406, - 406, 406, 406, 160, 160, 155, 155, 155, 157, 157, - 156, 156, 156, 158, 158, 403, 403, 403, 403, 317, - 317, 317, 317, 320, 320, 318, 318, 318, 318, 318, - 318, 318, 318, 318, 319, 319, 319, 319, 319, 319, - 319, 321, 321, 321, 321, 321, 322, 322, 322, 322, - 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, - 322, 322, 323, 323, 323, 323, 323, 323, 323, 323, - 338, 338, 327, 327, 332, 332, 333, 333, 334, 334, - 334, 335, 335, 335, 336, 336, 329, 329, 329, 329, - 329, 329, 329, 329, 329, 331, 331, 330, 330, 330, - 341, 366, 366, 365, 365, 363, 363, 363, 363, 363, - 363, 363, 363, 350, 350, 360, 360, 360, 360, 360, - 349, 349, 345, 345, 345, 346, 346, 347, 347, 344, - 344, 348, 348, 362, 362, 361, 361, 342, 342, 343, - 343, 368, 404, 404, 404, 404, 404, 405, 405, 369, - 394, 396, 396, 396, 395, 395, 392, 393, 391, 391, - 391, 391, 391, 84, 84, 84, 286, 286, 287, 287, - 358, 358, 357, 357, 357, 359, 359, 356, 356, 356, - 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - 356, 356, 356, 356, 356, 356, 356, 356, 356, 356, - 356, 356, 356, 356, 356, 356, 356, 356, 281, 281, - 281, 390, 390, 390, 390, 390, 390, 389, 389, 389, - 355, 355, 355, 355, 388, 388, 59, 59, 218, 218, - 407, 407, 408, 408, 408, 47, 47, 47, 47, 47, + 54, 53, 53, 55, 55, 353, 353, 339, 339, 352, + 352, 352, 352, 352, 352, 352, 338, 338, 139, 139, + 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, + 236, 236, 236, 236, 236, 236, 236, 401, 401, 401, + 400, 400, 237, 237, 237, 237, 237, 237, 237, 237, + 148, 148, 160, 160, 160, 160, 160, 160, 146, 146, + 147, 145, 145, 145, 153, 153, 153, 153, 153, 153, + 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, + 153, 405, 405, 405, 405, 405, 405, 405, 405, 405, + 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, + 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, + 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, + 405, 405, 405, 159, 159, 154, 154, 154, 156, 156, + 155, 155, 155, 157, 157, 402, 402, 402, 402, 316, + 316, 316, 316, 319, 319, 317, 317, 317, 317, 317, + 317, 317, 317, 317, 318, 318, 318, 318, 318, 318, + 318, 320, 320, 320, 320, 320, 321, 321, 321, 321, + 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, + 321, 321, 322, 322, 322, 322, 322, 322, 322, 322, + 337, 337, 326, 326, 331, 331, 332, 332, 333, 333, + 333, 334, 334, 334, 335, 335, 328, 328, 328, 328, + 328, 328, 328, 328, 328, 330, 330, 329, 329, 329, + 340, 365, 365, 364, 364, 362, 362, 362, 362, 362, + 362, 362, 362, 349, 349, 359, 359, 359, 359, 359, + 348, 348, 344, 344, 344, 345, 345, 346, 346, 343, + 343, 347, 347, 361, 361, 360, 360, 341, 341, 342, + 342, 367, 403, 403, 403, 403, 403, 404, 404, 368, + 393, 395, 395, 395, 394, 394, 391, 392, 390, 390, + 390, 390, 390, 84, 84, 84, 285, 285, 286, 286, + 357, 357, 356, 356, 356, 358, 358, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 355, 355, + 355, 355, 355, 355, 355, 355, 355, 355, 280, 280, + 280, 389, 389, 389, 389, 389, 389, 388, 388, 388, + 354, 354, 354, 354, 387, 387, 59, 59, 217, 217, + 406, 406, 407, 407, 407, 47, 47, 47, 47, 47, 47, 46, 46, 46, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, @@ -8496,108 +8437,152 @@ var yyR1 = [...]int{ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 110, - 110, 111, 111, 111, 111, 113, 113, 113, 371, 371, - 60, 60, 3, 3, 173, 175, 176, 176, 174, 174, - 174, 174, 174, 174, 62, 62, 61, 61, 178, 177, - 179, 179, 179, 1, 1, 2, 2, 4, 4, 376, - 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, - 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, - 376, 337, 337, 337, 370, 370, 372, 112, 112, 112, + 110, 111, 111, 111, 111, 113, 113, 113, 370, 370, + 60, 60, 3, 3, 172, 174, 175, 175, 173, 173, + 173, 173, 173, 173, 62, 62, 61, 61, 177, 176, + 178, 178, 178, 1, 1, 2, 2, 4, 4, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 375, 375, 375, 375, 375, 375, 375, 375, 375, + 375, 336, 336, 336, 369, 369, 371, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 116, 115, 115, - 114, 117, 117, 117, 117, 117, 117, 117, 117, 374, - 374, 374, 63, 63, 375, 324, 325, 326, 5, 6, - 351, 373, 124, 124, 24, 39, 39, 25, 25, 25, + 114, 117, 117, 117, 117, 117, 117, 117, 117, 373, + 373, 373, 63, 63, 374, 323, 324, 325, 5, 6, + 350, 372, 124, 124, 24, 39, 39, 25, 25, 25, 25, 26, 26, 64, 67, 67, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 65, 65, 65, 65, 65, 65, 65, 65, 280, - 280, 289, 289, 279, 279, 304, 304, 304, 282, 282, - 282, 283, 283, 400, 400, 400, 276, 276, 66, 66, - 66, 305, 305, 305, 305, 69, 69, 409, 409, 410, - 410, 411, 411, 411, 70, 71, 71, 307, 307, 308, - 308, 72, 73, 85, 85, 85, 85, 85, 86, 86, + 65, 65, 65, 65, 65, 65, 65, 65, 65, 279, + 279, 288, 288, 278, 278, 303, 303, 303, 281, 281, + 281, 282, 282, 399, 399, 399, 275, 275, 66, 66, + 66, 304, 304, 304, 304, 69, 69, 408, 408, 409, + 409, 410, 410, 410, 70, 71, 71, 306, 306, 307, + 307, 72, 73, 85, 85, 85, 85, 85, 86, 86, 86, 86, 109, 109, 109, 10, 10, 10, 10, 81, - 81, 81, 9, 9, 11, 68, 68, 75, 397, 397, - 398, 399, 399, 399, 399, 76, 78, 27, 27, 27, - 27, 27, 27, 135, 135, 122, 122, 122, 122, 122, + 81, 81, 9, 9, 11, 68, 68, 75, 396, 396, + 397, 398, 398, 398, 398, 76, 78, 27, 27, 27, + 27, 27, 27, 134, 134, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 129, 129, 129, - 123, 123, 418, 79, 80, 80, 127, 127, 127, 120, - 120, 120, 126, 126, 126, 12, 12, 13, 262, 262, - 14, 14, 131, 131, 134, 134, 133, 133, 136, 136, - 136, 136, 136, 136, 136, 130, 130, 132, 132, 132, - 132, 297, 297, 297, 296, 296, 167, 167, 169, 168, - 168, 170, 170, 171, 171, 171, 171, 216, 216, 193, - 193, 255, 255, 256, 256, 254, 254, 261, 261, 257, - 257, 257, 257, 264, 264, 172, 172, 172, 172, 180, - 180, 181, 181, 182, 182, 306, 306, 302, 302, 302, - 301, 301, 186, 186, 186, 188, 187, 187, 187, 187, - 189, 189, 191, 191, 190, 190, 192, 197, 197, 196, - 196, 194, 194, 194, 194, 194, 194, 195, 195, 195, - 195, 198, 198, 145, 145, 145, 145, 145, 145, 145, - 145, 159, 159, 159, 159, 162, 162, 162, 162, 162, - 162, 162, 162, 162, 162, 162, 245, 245, 150, 150, - 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 153, 153, 153, 153, 153, 153, 153, - 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, - 153, 153, 153, 153, 153, 153, 153, 153, 221, 221, - 220, 220, 87, 87, 87, 88, 88, 89, 89, 89, - 89, 89, 90, 90, 90, 90, 90, 90, 90, 92, - 92, 91, 91, 211, 211, 294, 294, 93, 94, 94, - 97, 97, 96, 95, 95, 101, 101, 98, 98, 100, - 100, 99, 102, 102, 103, 104, 104, 277, 277, 199, - 199, 207, 207, 207, 207, 200, 200, 200, 200, 200, - 200, 200, 208, 208, 208, 215, 209, 209, 205, 205, + 123, 123, 417, 79, 80, 80, 127, 127, 127, 120, + 120, 120, 126, 126, 126, 12, 12, 13, 261, 261, + 14, 14, 133, 133, 132, 132, 135, 135, 135, 135, + 135, 135, 135, 130, 130, 131, 131, 131, 131, 296, + 296, 296, 295, 295, 166, 166, 168, 167, 167, 169, + 169, 170, 170, 170, 170, 215, 215, 192, 192, 254, + 254, 255, 255, 253, 253, 260, 260, 256, 256, 256, + 256, 263, 263, 171, 171, 171, 171, 179, 179, 180, + 180, 181, 181, 305, 305, 301, 301, 301, 300, 300, + 185, 185, 185, 187, 186, 186, 186, 186, 188, 188, + 190, 190, 189, 189, 191, 196, 196, 195, 195, 193, + 193, 193, 193, 193, 193, 194, 194, 194, 194, 197, + 197, 144, 144, 144, 144, 144, 144, 144, 144, 158, + 158, 158, 158, 161, 161, 161, 161, 161, 161, 161, + 161, 161, 161, 161, 244, 244, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 152, 152, 152, 152, 152, 152, 152, 152, 152, + 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, + 152, 152, 152, 152, 152, 152, 220, 220, 219, 219, + 87, 87, 87, 88, 88, 89, 89, 89, 89, 89, + 90, 90, 90, 90, 90, 90, 90, 92, 92, 91, + 91, 210, 210, 293, 293, 93, 94, 94, 97, 97, + 96, 95, 95, 101, 101, 98, 98, 100, 100, 99, + 102, 102, 103, 104, 104, 276, 276, 198, 198, 206, + 206, 206, 206, 199, 199, 199, 199, 199, 199, 199, + 207, 207, 207, 214, 208, 208, 204, 204, 202, 202, + 202, 202, 202, 202, 202, 202, 202, 202, 202, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, - 203, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, - 204, 204, 164, 164, 164, 164, 226, 226, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 152, 152, 165, 165, 165, 165, 166, - 166, 166, 166, 166, 166, 166, 314, 314, 118, 118, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, + 163, 163, 163, 163, 225, 225, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 151, 151, 164, 164, 164, 164, 165, 165, 165, + 165, 165, 165, 165, 313, 313, 118, 118, 118, 118, 118, 118, 118, 118, 118, 118, 118, 118, 118, 118, - 118, 118, 118, 118, 118, 118, 118, 118, 119, 119, + 118, 118, 118, 118, 118, 118, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, - 119, 119, 119, 119, 119, 119, 419, 419, 328, 328, - 328, 206, 206, 206, 206, 206, 125, 125, 125, 125, - 125, 311, 311, 311, 315, 315, 315, 313, 313, 313, - 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, - 313, 313, 316, 316, 224, 224, 121, 121, 222, 222, - 223, 225, 225, 217, 217, 217, 217, 219, 219, 202, - 202, 202, 227, 227, 228, 228, 105, 106, 106, 107, - 107, 229, 229, 231, 230, 230, 232, 233, 233, 233, - 234, 234, 235, 235, 235, 49, 49, 49, 49, 49, - 44, 44, 44, 44, 45, 45, 45, 45, 137, 137, - 137, 137, 139, 139, 138, 138, 82, 82, 83, 83, - 83, 143, 143, 144, 144, 144, 141, 141, 142, 142, - 252, 252, 252, 252, 252, 252, 252, 236, 236, 236, - 243, 243, 243, 239, 239, 241, 241, 241, 242, 242, - 242, 240, 249, 249, 251, 251, 250, 250, 246, 246, - 247, 247, 248, 248, 248, 244, 244, 201, 201, 201, - 201, 201, 253, 253, 253, 253, 265, 265, 212, 212, - 214, 214, 213, 213, 163, 266, 266, 274, 271, 271, - 272, 272, 298, 298, 298, 275, 275, 288, 288, 284, - 284, 285, 285, 278, 278, 290, 290, 290, 77, 210, - 210, 367, 367, 364, 293, 293, 295, 295, 299, 299, - 303, 303, 300, 300, 8, 412, 412, 412, 291, 291, + 119, 119, 119, 119, 418, 418, 327, 327, 327, 205, + 205, 205, 205, 205, 125, 125, 125, 125, 125, 310, + 310, 310, 314, 314, 314, 312, 312, 312, 312, 312, + 312, 312, 312, 312, 312, 312, 312, 312, 312, 312, + 315, 315, 223, 223, 121, 121, 221, 221, 222, 224, + 224, 216, 216, 216, 216, 218, 218, 201, 201, 201, + 226, 226, 227, 227, 105, 106, 106, 107, 107, 228, + 228, 230, 229, 229, 231, 232, 232, 232, 233, 233, + 234, 234, 234, 49, 49, 49, 49, 49, 44, 44, + 44, 44, 45, 45, 45, 45, 136, 136, 136, 136, + 138, 138, 137, 137, 82, 82, 83, 83, 83, 142, + 142, 143, 143, 143, 140, 140, 141, 141, 251, 251, + 251, 251, 251, 251, 251, 235, 235, 235, 242, 242, + 242, 238, 238, 240, 240, 240, 241, 241, 241, 239, + 248, 248, 250, 250, 249, 249, 245, 245, 246, 246, + 247, 247, 247, 243, 243, 200, 200, 200, 200, 200, + 252, 252, 252, 252, 264, 264, 211, 211, 213, 213, + 212, 212, 162, 265, 265, 273, 270, 270, 271, 271, + 297, 297, 297, 274, 274, 287, 287, 283, 283, 284, + 284, 277, 277, 289, 289, 289, 77, 209, 209, 366, + 366, 363, 292, 292, 294, 294, 298, 298, 302, 302, + 299, 299, 8, 411, 411, 411, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, @@ -8612,54 +8597,10 @@ var yyR1 = [...]int{ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, - 291, 291, 291, 291, 291, 291, 291, 291, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, - 292, 292, 292, 292, 415, 416, 309, 310, 310, 310, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 291, 291, 291, 291, 291, 291, 291, 291, + 291, 291, 414, 415, 308, 309, 309, 309, } var yyR2 = [...]int{ @@ -8753,79 +8694,79 @@ var yyR2 = [...]int{ 1, 1, 3, 2, 1, 1, 1, 0, 1, 1, 0, 3, 0, 2, 0, 2, 1, 2, 2, 0, 1, 1, 0, 1, 1, 5, 5, 4, 0, 2, - 4, 4, 0, 1, 0, 1, 1, 2, 1, 1, - 1, 1, 1, 1, 1, 1, 3, 1, 2, 3, - 5, 0, 1, 2, 1, 1, 0, 1, 2, 1, - 3, 1, 1, 1, 4, 3, 1, 1, 2, 3, - 7, 0, 3, 0, 1, 1, 3, 1, 3, 1, - 1, 3, 3, 1, 3, 4, 4, 4, 3, 2, - 4, 0, 1, 0, 2, 0, 1, 0, 1, 2, - 1, 1, 1, 2, 2, 1, 2, 3, 2, 3, - 2, 2, 2, 1, 1, 3, 3, 0, 1, 1, - 2, 6, 5, 6, 6, 5, 5, 0, 2, 3, - 3, 0, 2, 3, 3, 3, 2, 3, 1, 3, - 6, 3, 4, 3, 1, 3, 4, 5, 6, 3, - 4, 5, 6, 3, 4, 1, 1, 1, 3, 3, - 3, 3, 3, 3, 5, 5, 3, 3, 3, 3, - 3, 3, 1, 1, 1, 1, 1, 3, 1, 1, - 1, 2, 2, 2, 2, 1, 1, 2, 7, 7, - 6, 6, 2, 2, 5, 6, 3, 3, 1, 3, - 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 2, 2, 2, 2, 4, 2, 4, 0, - 1, 2, 5, 0, 3, 0, 1, 4, 4, 2, - 0, 1, 1, 2, 2, 1, 1, 2, 2, 0, - 1, 1, 1, 1, 5, 1, 3, 0, 3, 1, - 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 3, 4, 6, - 4, 4, 8, 8, 6, 8, 6, 5, 4, 10, - 2, 2, 1, 2, 2, 2, 2, 2, 4, 5, - 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 8, 4, 8, 8, 6, 5, - 4, 4, 4, 4, 4, 7, 4, 4, 6, 6, - 6, 8, 6, 6, 4, 4, 3, 4, 6, 6, - 4, 4, 6, 4, 6, 4, 4, 4, 4, 4, - 4, 6, 4, 6, 4, 4, 4, 6, 4, 6, - 4, 4, 6, 4, 6, 4, 6, 8, 4, 6, + 4, 4, 0, 1, 1, 2, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 1, 2, 3, 5, 0, + 1, 2, 1, 1, 0, 1, 2, 1, 3, 1, + 1, 1, 4, 3, 1, 1, 2, 3, 7, 0, + 3, 0, 1, 1, 3, 1, 3, 1, 1, 3, + 3, 1, 3, 4, 4, 4, 3, 2, 4, 0, + 1, 0, 2, 0, 1, 0, 1, 2, 1, 1, + 1, 2, 2, 1, 2, 3, 2, 3, 2, 2, + 2, 1, 1, 3, 3, 0, 1, 1, 2, 6, + 5, 6, 6, 5, 5, 0, 2, 3, 3, 0, + 2, 3, 3, 3, 2, 3, 1, 3, 6, 3, + 4, 3, 1, 3, 4, 5, 6, 3, 4, 5, + 6, 3, 4, 1, 1, 1, 3, 3, 3, 3, + 3, 3, 5, 5, 3, 3, 3, 3, 3, 3, + 1, 1, 1, 1, 1, 3, 1, 1, 1, 2, + 2, 2, 2, 1, 1, 2, 7, 7, 6, 6, + 2, 2, 5, 6, 3, 3, 1, 3, 1, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 4, 2, 4, 0, 1, 2, + 5, 0, 3, 0, 1, 4, 4, 2, 0, 1, + 1, 2, 2, 1, 1, 2, 2, 0, 1, 1, + 1, 1, 5, 1, 3, 0, 3, 1, 1, 1, + 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 4, 6, 4, 4, + 8, 8, 6, 8, 6, 5, 4, 10, 2, 2, + 1, 2, 2, 2, 2, 2, 4, 5, 5, 5, + 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 8, 4, 8, 8, 6, 5, 4, 4, + 4, 4, 4, 7, 4, 4, 6, 6, 6, 8, + 6, 6, 4, 4, 3, 4, 6, 6, 4, 4, + 6, 4, 6, 4, 4, 4, 4, 4, 4, 6, + 4, 6, 4, 4, 4, 6, 4, 6, 4, 4, + 6, 4, 6, 4, 6, 8, 4, 6, 8, 4, + 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, - 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, - 4, 6, 8, 4, 4, 4, 6, 4, 6, 4, - 8, 6, 4, 4, 6, 4, 6, 8, 4, 6, - 8, 4, 4, 6, 8, 6, 4, 6, 6, 8, - 10, 7, 8, 8, 9, 4, 4, 4, 4, 6, - 6, 6, 6, 6, 6, 6, 6, 6, 6, 4, - 4, 4, 4, 4, 4, 6, 4, 6, 5, 9, - 6, 9, 8, 6, 8, 8, 8, 6, 1, 1, - 1, 1, 1, 1, 1, 1, 0, 2, 6, 8, - 10, 12, 14, 6, 8, 8, 10, 12, 14, 6, - 8, 10, 12, 6, 8, 4, 4, 3, 4, 6, - 6, 4, 6, 4, 6, 8, 0, 2, 1, 1, + 8, 4, 4, 4, 6, 4, 6, 4, 8, 6, + 4, 4, 6, 4, 6, 8, 4, 6, 8, 4, + 4, 6, 8, 6, 4, 6, 6, 8, 10, 7, + 8, 8, 9, 4, 4, 4, 4, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 4, 4, 4, + 4, 4, 4, 6, 4, 6, 5, 9, 6, 9, + 8, 6, 8, 8, 8, 6, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 2, 6, 8, 10, 12, + 14, 6, 8, 8, 10, 12, 14, 6, 8, 10, + 12, 6, 8, 4, 4, 3, 4, 6, 6, 4, + 6, 4, 6, 8, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 0, 2, 0, 2, - 3, 4, 4, 4, 4, 4, 0, 3, 4, 7, - 3, 1, 1, 1, 0, 5, 5, 2, 3, 1, - 2, 2, 1, 2, 1, 2, 2, 1, 2, 2, - 1, 1, 0, 1, 0, 1, 0, 2, 1, 2, - 4, 0, 2, 1, 1, 3, 5, 1, 1, 1, - 2, 2, 0, 3, 0, 2, 2, 1, 3, 0, - 1, 0, 1, 3, 1, 3, 2, 0, 1, 1, - 0, 1, 2, 4, 4, 0, 2, 2, 1, 1, - 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, - 3, 3, 0, 3, 1, 1, 0, 4, 0, 1, - 1, 0, 3, 1, 3, 2, 1, 1, 0, 1, - 2, 3, 4, 2, 3, 4, 4, 9, 3, 5, - 0, 3, 3, 0, 1, 0, 2, 2, 0, 2, - 2, 2, 0, 2, 1, 2, 3, 3, 0, 2, - 1, 2, 3, 4, 3, 0, 1, 2, 1, 5, - 4, 4, 1, 3, 3, 5, 0, 5, 1, 3, - 1, 2, 3, 4, 1, 1, 3, 3, 1, 2, - 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, - 2, 0, 3, 0, 1, 0, 1, 1, 5, 0, - 1, 0, 1, 2, 1, 1, 1, 1, 1, 1, - 0, 1, 1, 1, 3, 0, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 2, 0, 2, 3, 4, + 4, 4, 4, 4, 0, 3, 4, 7, 3, 1, + 1, 1, 0, 5, 5, 2, 3, 1, 2, 2, + 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, + 0, 1, 0, 1, 0, 2, 1, 2, 4, 0, + 2, 1, 1, 3, 5, 1, 1, 1, 2, 2, + 0, 3, 0, 2, 2, 1, 3, 0, 1, 0, + 1, 3, 1, 3, 2, 0, 1, 1, 0, 1, + 2, 4, 4, 0, 2, 2, 1, 1, 3, 3, + 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, + 0, 3, 1, 1, 0, 4, 0, 1, 1, 0, + 3, 1, 3, 2, 1, 1, 0, 1, 2, 3, + 4, 2, 3, 4, 4, 9, 3, 5, 0, 3, + 3, 0, 1, 0, 2, 2, 0, 2, 2, 2, + 0, 2, 1, 2, 3, 3, 0, 2, 1, 2, + 3, 4, 3, 0, 1, 2, 1, 5, 4, 4, + 1, 3, 3, 5, 0, 5, 1, 3, 1, 2, + 3, 4, 1, 1, 3, 3, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 0, 1, 0, 2, 0, + 3, 0, 1, 0, 1, 1, 5, 0, 1, 0, + 1, 2, 1, 1, 1, 1, 1, 1, 0, 1, + 1, 1, 3, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -8887,11 +8828,11 @@ var yyR2 = [...]int{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, + 1, 1, 1, 1, 0, 0, 1, 1, } var yyChk = [...]int{ - -1000, -413, -79, -418, -7, -29, -15, -16, -17, -18, + -1000, -412, -79, -417, -7, -29, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -64, -67, -65, -66, -69, -70, -71, -72, -73, -9, -11, -68, -27, -28, -74, -75, -76, -77, -78, -12, -13, -14, @@ -8899,18 +8840,18 @@ var yyChk = [...]int{ -50, 228, -51, -41, 229, -52, 231, 230, 268, 232, 381, 261, 76, 317, 318, 320, 321, 322, 323, -109, 687, 266, 267, 234, 38, 47, 35, 36, 39, 238, - 274, 275, 237, 134, -33, -36, 10, -415, 13, 471, - 263, 262, 30, -34, 581, 88, -80, -414, 735, -252, - -236, 24, 35, 31, -235, -231, -127, -236, 22, 20, - 9, -79, -79, -79, 14, 15, -79, -352, -354, 88, + 274, 275, 237, 134, -33, -36, 10, -414, 13, 471, + 263, 262, 30, -34, 581, 88, -80, -413, 735, -251, + -235, 24, 35, 31, -234, -230, -127, -235, 22, 20, + 9, -79, -79, -79, 14, 15, -79, -351, -353, 88, 161, 88, -79, -57, -56, -54, -53, -55, -58, 33, - -47, -48, -376, -46, -43, 233, 230, 278, 124, 125, + -47, -48, -375, -46, -43, 233, 230, 278, 124, 125, 268, 269, 270, 232, 252, 267, 271, 266, 287, -42, - 83, 35, 581, 584, -359, 229, 235, 236, 231, 472, - 127, 126, 77, -356, 376, 614, 705, -58, 707, 102, + 83, 35, 581, 584, -358, 229, 235, 236, 231, 472, + 127, 126, 77, -355, 376, 614, 705, -58, 707, 102, 105, 706, 46, 242, 708, 709, 710, 621, 711, 251, 712, 713, 714, 715, 721, 662, 722, 723, 724, 128, - 9, -79, -303, -299, 92, -292, 578, 254, 612, 425, + 9, -79, -302, -298, 92, -291, 578, 254, 612, 425, 613, 303, 83, 43, 517, 587, 373, 376, 614, 502, 705, 382, 317, 333, 327, 507, 508, 509, 356, 348, 579, 615, 588, 306, 255, 291, 699, 346, 137, 707, @@ -8957,17 +8898,17 @@ var yyChk = [...]int{ 410, 412, 316, 411, 686, 680, 681, 290, 461, 584, 324, 345, 380, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 480, 241, -79, 241, -190, -299, -129, 689, 691, - 180, -271, 384, -289, 386, 399, 394, 404, 392, -280, - 395, 397, 281, -400, 414, 241, 401, 228, 387, 396, + 460, 480, 241, -79, 241, -189, -298, -129, 689, 691, + 180, -270, 384, -288, 386, 399, 394, 404, 392, -279, + 395, 397, 281, -399, 414, 241, 401, 228, 387, 396, 405, 406, 305, 412, 407, 316, 411, 290, 408, 409, - 410, -383, 180, 710, 725, 137, 349, 391, 389, 415, - 689, 92, -305, 92, 93, 94, -292, 319, -307, 324, - -293, -383, -292, 322, -79, -79, -309, -309, -129, -209, - -145, 145, -159, -260, -162, 93, -150, -153, -203, -204, - -205, -206, -160, -219, -258, 169, 170, 177, 146, -215, - -163, 28, 577, 473, 472, 180, 33, 223, 70, 71, - 475, 476, 148, 59, 13, 438, 439, -161, 428, 429, + 410, -382, 180, 710, 725, 137, 349, 391, 389, 415, + 689, 92, -304, 92, 93, 94, -291, 319, -306, 324, + -292, -382, -291, 322, -79, -79, -308, -308, -129, -208, + -144, 145, -158, -259, -161, 93, -149, -152, -202, -203, + -204, -205, -159, -218, -257, 169, 170, 177, 146, -214, + -162, 28, 577, 473, 472, 180, 33, 223, 70, 71, + 475, 476, 148, 59, 13, 438, 439, -160, 428, 429, 440, 434, 435, 501, 503, 504, 505, 502, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 506, 517, 478, 479, 119, 480, 109, 111, 110, 481, 482, 483, @@ -8980,44 +8921,44 @@ var yyChk = [...]int{ 113, 114, 115, 116, 117, 118, 487, 490, 488, 489, 491, 492, 493, 498, 499, 494, 495, 496, 497, 500, 372, 370, 371, 367, 366, 365, -89, -101, 603, 602, - -102, 425, 430, 431, 433, -151, -152, -165, -166, -293, - -299, 246, 427, 240, 175, 471, -154, -148, -217, 108, - 94, -31, -213, 426, 436, 437, 441, 432, 442, 589, + -102, 425, 430, 431, 433, -150, -151, -164, -165, -292, + -298, 246, 427, 240, 175, 471, -153, -147, -216, 108, + 94, -31, -212, 426, 436, 437, 441, 432, 442, 589, 591, 606, 607, 609, 594, 599, 598, 601, 518, 519, 520, 521, 522, 523, 674, 675, 676, 677, 678, 679, - 680, 681, -383, -292, 92, -157, -155, -199, 95, 100, - 103, 104, 106, -406, 264, 342, 343, 120, -415, 703, - -156, 97, 98, 99, 121, 122, 181, 182, 183, 184, + 680, 681, -382, -291, 92, -156, -154, -198, 95, 100, + 103, 104, 106, -405, 264, 342, 343, 120, -414, 703, + -155, 97, 98, 99, 121, 122, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 91, 96, - 46, 400, 400, -190, -79, -79, -79, -79, -412, 706, - 582, -229, -127, -231, -33, -31, -415, 10, -79, -31, - -32, -30, -36, -38, 608, -37, -299, 101, -236, -252, - 14, 63, 164, 44, 52, -234, -235, -34, -31, -145, - 21, 25, 26, -132, 171, -145, -299, -132, -278, 245, - -79, -79, -267, -312, 319, -269, 415, 689, 414, -259, - -272, 92, -258, -271, 413, 93, -353, 161, -339, -343, - -293, 256, -369, 252, -190, -362, -361, -293, -415, -128, - -288, 242, 250, 249, 138, -387, 141, 298, 427, 240, - -53, -54, -55, -271, 179, 709, -110, 273, 277, 89, - 89, -343, -342, -341, -388, 277, 256, -368, -360, 248, - 257, -349, 249, 250, -344, 242, 139, -388, -344, 247, + 46, 400, 400, -189, -79, -79, -79, -79, -411, 706, + 582, -228, -127, -230, -33, -31, -414, 10, -79, -31, + -32, -30, -36, -38, 608, -37, -298, 101, -235, -251, + 14, 63, 164, 44, 52, -233, -234, -34, -31, -144, + 21, 25, 26, -131, 171, -144, -298, -131, -277, 245, + -79, -79, -266, -311, 319, -268, 415, 689, 414, -258, + -271, 92, -257, -270, 413, 93, -352, 161, -338, -342, + -292, 256, -368, 252, -189, -361, -360, -292, -414, -128, + -287, 242, 250, 249, 138, -386, 141, 298, 427, 240, + -53, -54, -55, -270, 179, 709, -110, 273, 277, 89, + 89, -342, -341, -340, -387, 277, 256, -367, -359, 248, + 257, -348, 249, 250, -343, 242, 139, -387, -343, 247, 257, 252, 256, 277, 277, 128, 277, 128, 277, 277, - 277, 277, 277, 277, 277, 277, 277, 272, -350, 153, - -350, 585, 585, -356, -388, 252, 242, -388, -388, 248, - -290, -344, 244, 27, 244, 37, 37, -350, -350, -350, - -271, 179, -350, -350, -350, -350, 285, 285, -350, -350, - -350, -350, -350, -350, -350, -350, -350, -350, -350, -350, - -350, -350, -350, -350, -350, 241, -387, -137, 411, 305, - 83, -56, 287, -39, -190, -288, 242, 243, -387, 274, - -190, 224, 241, 692, -282, 161, 17, -282, -279, 400, - 398, 385, 390, -282, -282, -282, -282, 288, 383, -345, + 277, 277, 277, 277, 277, 277, 277, 272, -349, 153, + -349, 585, 585, -355, -387, 252, 242, -387, -387, 248, + -289, -343, 244, 27, 244, 37, 37, -349, -349, -349, + -270, 179, -349, -349, -349, -349, 285, 285, -349, -349, + -349, -349, -349, -349, -349, -349, -349, -349, -349, -349, + -349, -349, -349, -349, -349, 241, -386, -136, 411, 305, + 83, -56, 287, -39, -189, -287, 242, 243, -386, 274, + -189, 224, 241, 692, -281, 161, 17, -281, -278, 400, + 398, 385, 390, -281, -281, -281, -281, 288, 383, -344, 242, 37, 253, 400, 288, 383, 288, 289, 288, 289, - 393, 403, 288, -304, 16, 164, 427, 388, 392, 281, - 241, 282, 243, 402, 289, -304, 91, -283, 161, 288, - 400, 394, 284, -282, -282, -310, -415, -295, -293, -291, + 393, 403, 288, -303, 16, 164, 427, 388, 392, 281, + 241, 282, 243, 402, 289, -303, 91, -282, 161, 288, + 400, 394, 284, -281, -281, -309, -414, -294, -292, -290, 233, 25, 144, 27, 29, 147, 180, 131, 21, 148, 39, 235, 349, 252, 179, 248, 472, 228, 74, 589, 428, 435, 426, 434, 438, 474, 475, 427, 386, 33, @@ -9033,281 +8974,281 @@ var yyChk = [...]int{ 477, 34, 261, 249, 130, 69, 442, 610, 241, 150, 244, 133, 121, 9, 138, 36, 14, 76, 79, 439, 440, 441, 59, 129, 581, 149, 17, 611, 419, 143, - -383, 692, -310, -310, 34, 93, -409, -410, -411, 581, - 418, 244, -293, -190, -85, 682, 232, -86, 688, 25, - 239, -135, 400, -122, 180, 710, 693, 694, 695, 692, + -382, 692, -309, -309, 34, 93, -408, -409, -410, 581, + 418, 244, -292, -189, -85, 682, 232, -86, 688, 25, + 239, -134, 400, -122, 180, 710, 693, 694, 695, 692, 397, 700, 698, 696, 288, 697, 89, 141, 143, 144, - 4, -145, 160, -200, 153, 154, 155, 156, 157, 158, - 159, 165, 164, 145, 147, 161, -245, 142, 166, 167, + 4, -144, 160, -199, 153, 154, 155, 156, 157, 158, + 159, 165, 164, 145, 147, 161, -244, 142, 166, 167, 168, 169, 170, 171, 172, 174, 173, 175, 176, 162, - 163, 179, 226, 227, -153, -153, -153, -153, -215, -221, - -220, -415, -217, -383, -292, -299, -415, -415, -153, -277, - -415, -150, -415, -415, -415, -415, -415, -224, -145, -415, - -415, -419, -415, -419, -419, -419, -328, -415, -328, -328, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, - -415, -415, -415, 224, -415, -415, -415, -415, -415, -328, - -328, -328, -328, -328, -328, -415, -415, -415, -415, -415, - -415, -415, -415, -415, -415, -415, -415, -415, -415, 91, - 104, 100, 103, 95, -219, 106, 91, 91, 91, 91, - -31, -32, -209, -415, -309, -397, -398, -193, -190, -415, - 305, -293, -293, 274, 97, -234, -34, -31, -229, -235, - -231, -31, -79, -120, -134, 65, 66, -133, -136, 26, - 40, 69, 67, 25, -416, 90, -416, -252, -416, 89, - -38, -255, 88, 636, 666, 636, 666, 63, 45, 91, - 91, 89, 23, -230, -232, -145, 16, -297, 4, -296, - 27, -293, 91, 224, 16, -191, 31, -190, -278, -278, - 89, 92, 319, -268, -270, 416, 418, 153, -298, -293, - 91, 33, 90, 89, -190, -317, -320, -322, -321, -323, - -318, -319, 346, 347, 180, 350, 352, 353, 354, 355, + 163, 179, 226, 227, -152, -152, -152, -152, -214, -220, + -219, -414, -216, -382, -291, -298, -414, -414, -152, -276, + -414, -149, -414, -414, -414, -414, -414, -223, -144, -414, + -414, -418, -414, -418, -418, -418, -327, -414, -327, -327, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, -414, + -414, -414, -414, 224, -414, -414, -414, -414, -414, -327, + -327, -327, -327, -327, -327, -414, -414, -414, -414, -414, + -414, -414, -414, -414, -414, -414, -414, -414, -414, 91, + 104, 100, 103, 95, -218, 106, 91, 91, 91, 91, + -31, -32, -208, -414, -308, -396, -397, -192, -189, -414, + 305, -292, -292, 274, 97, -233, -34, -31, -228, -234, + -230, -31, -79, -120, -133, 65, 66, -132, -135, 26, + 40, 69, 67, 25, -415, 90, -415, -251, -415, 89, + -38, -254, 88, 636, 666, 636, 666, 63, 45, 91, + 91, 89, 23, -229, -231, -144, 16, -296, 4, -295, + 27, -292, 91, 224, 16, -190, 31, -189, -277, -277, + 89, 92, 319, -267, -269, 416, 418, 153, -297, -292, + 91, 33, 90, 89, -189, -316, -319, -321, -320, -322, + -317, -318, 346, 347, 180, 350, 352, 353, 354, 355, 356, 357, 358, 359, 360, 363, 34, 264, 342, 343, 344, 345, 364, 365, 366, 367, 369, 370, 371, 372, 327, 348, 579, 328, 329, 330, 331, 332, 333, 335, - 336, 339, 337, 338, 340, 341, -384, -383, 88, 90, - 89, -327, 88, -145, -137, 241, -383, 242, 242, 242, - -79, 471, -350, -350, -350, 272, 21, -46, -43, -376, - 20, -42, -43, 233, 124, 125, 230, 88, -339, 88, - -348, -384, -383, 88, 139, 247, 138, -347, -344, -347, - -348, -383, -217, -383, 139, 139, -383, -383, -264, -293, - -264, -264, 25, -264, 25, -264, 25, 97, -293, -264, - 25, -264, 25, -264, 25, -264, 25, -264, 25, 33, - 80, 81, 82, 33, 84, 85, 86, -217, -383, -383, - -217, -339, -217, -190, -383, -271, 97, 97, 97, -350, - -350, 97, 91, 91, 91, -350, -350, 97, 91, -301, - -299, 91, 91, -389, 258, 302, 304, 97, 97, 97, - 97, 33, 91, -390, 33, 717, 716, 718, 719, 720, - 91, 97, 33, 97, 33, 97, -293, 88, -190, -143, + 336, 339, 337, 338, 340, 341, -383, -382, 88, 90, + 89, -326, 88, -144, -136, 241, -382, 242, 242, 242, + -79, 471, -349, -349, -349, 272, 21, -46, -43, -375, + 20, -42, -43, 233, 124, 125, 230, 88, -338, 88, + -347, -383, -382, 88, 139, 247, 138, -346, -343, -346, + -347, -382, -216, -382, 139, 139, -382, -382, -263, -292, + -263, -263, 25, -263, 25, -263, 25, 97, -292, -263, + 25, -263, 25, -263, 25, -263, 25, -263, 25, 33, + 80, 81, 82, 33, 84, 85, 86, -216, -382, -382, + -216, -338, -216, -189, -382, -270, 97, 97, 97, -349, + -349, 97, 91, 91, 91, -349, -349, 97, 91, -300, + -298, 91, 91, -388, 258, 302, 304, 97, 97, 97, + 97, 33, 91, -389, 33, 717, 716, 718, 719, 720, + 91, 97, 33, 97, 33, 97, -292, 88, -189, -142, 292, 228, 230, 233, 78, 91, 308, 309, 306, 311, - 312, 313, 153, 46, 89, 244, 241, -383, -284, 246, - -284, -293, -300, -299, -291, -190, 244, 382, 91, -145, - -346, 16, 164, -304, -304, -282, -190, -346, -304, -282, - -190, -282, -282, -282, -282, -304, -304, -304, -282, -299, - -299, -190, -190, -190, -190, -190, -190, -190, -310, -283, - -282, 692, 91, -276, 16, 78, -310, -310, 89, 325, - 419, 420, -308, 322, -81, -293, 91, -10, -29, -18, - -17, -19, 153, -10, 89, 581, -183, -190, 692, 692, - 692, 692, 692, 692, -145, -145, -145, -145, 604, -207, - 120, 145, 121, 122, -162, -145, -208, -213, -215, 107, - 164, 147, 161, -245, -150, -153, -150, -150, -150, -150, - -150, -150, 223, -150, 223, -150, -150, -150, -150, -150, - -150, -311, -293, 91, 180, -158, -157, 106, -406, -158, - 578, 89, -220, 224, -145, -145, -383, -118, 444, 445, + 312, 313, 153, 46, 89, 244, 241, -382, -283, 246, + -283, -292, -299, -298, -290, -189, 244, 382, 91, -144, + -345, 16, 164, -303, -303, -281, -189, -345, -303, -281, + -189, -281, -281, -281, -281, -303, -303, -303, -281, -298, + -298, -189, -189, -189, -189, -189, -189, -189, -309, -282, + -281, 692, 91, -275, 16, 78, -309, -309, 89, 325, + 419, 420, -307, 322, -81, -292, 91, -10, -29, -18, + -17, -19, 153, -10, 89, 581, -182, -189, 692, 692, + 692, 692, 692, 692, -144, -144, -144, -144, 604, -206, + 120, 145, 121, 122, -161, -144, -207, -212, -214, 107, + 164, 147, 161, -244, -149, -152, -149, -149, -149, -149, + -149, -149, 223, -149, 223, -149, -149, -149, -149, -149, + -149, -310, -292, 91, 180, -157, -156, 106, -405, -157, + 578, 89, -219, 224, -144, -144, -382, -118, 444, 445, 446, 447, 449, 450, 451, 454, 455, 459, 460, 443, - 461, 448, 453, 456, 457, 458, 452, 345, -145, -130, - -132, -130, -145, -145, -222, -223, 149, -217, -145, -416, - -416, 97, 171, -126, 26, 40, -126, -126, -126, -126, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -126, -145, -119, 443, 461, 448, 453, 456, 457, 458, + 461, 448, 453, 456, 457, 458, 452, 345, -144, -209, + -208, -209, -144, -144, -221, -222, 149, -216, -144, -415, + -415, 97, 171, -126, 26, 40, -126, -126, -126, -126, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -126, -144, -119, 443, 461, 448, 453, 456, 457, 458, 452, 345, 462, 463, 464, 465, 466, 467, 468, 469, - 470, -119, -118, -145, -145, -145, -145, -145, -145, -87, - -145, 131, 132, 133, -209, -145, -150, -145, -145, -145, - -416, -145, -145, -145, -210, -209, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -382, -381, -380, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -209, -209, - -209, -209, -209, -145, -416, -145, -164, -148, 97, -260, - 106, 93, -145, -145, -145, -145, -145, -145, -131, -130, - -295, -300, -291, -292, -130, -131, -131, -130, -130, -145, - -145, -145, -145, -145, -145, -145, -145, -416, -145, -145, - -145, -145, -145, -252, -416, -209, 89, -399, 418, 419, - 690, -302, 277, -301, 27, -210, 91, 16, -262, 79, - -293, -234, -234, 65, 66, 61, -130, -136, -416, -37, - 27, -254, -293, 629, 629, 64, 91, -329, -271, 373, - 374, 180, -145, -145, 89, -233, 29, 30, -190, -296, - 171, -300, -190, -263, 277, -190, -168, -170, -171, -172, - -193, -216, -415, -173, -31, 600, 597, 16, -183, -184, - -192, -299, -269, -312, -268, 89, 417, 419, 420, 78, - 123, -145, -330, 179, -358, -357, -356, -339, -341, -342, - -343, 90, -330, -335, 379, 378, -327, -327, -327, -327, - -327, -329, -329, -329, -329, 88, 88, -327, -327, -327, - -327, -332, 88, -332, -332, -333, -332, 88, -333, -334, - 88, -334, -369, -145, -366, -365, -363, -364, 251, 102, - 672, 628, 581, 621, 662, 79, -361, -233, 97, -416, - -143, -285, 246, -367, -364, -383, -383, -383, -285, 92, - 91, 92, 91, 92, 91, -111, -60, -1, 729, 730, - 731, 89, 21, -340, -339, -59, 302, -372, -373, 277, - -368, -362, -348, 139, -347, -348, -348, -383, 89, 31, - 128, 128, 128, 128, 581, 230, 34, -286, 620, 145, - 672, 628, -339, -59, 244, 244, -311, -311, -311, 91, - 91, -281, 725, -183, -139, 294, 153, 283, 283, 241, - 296, 241, 296, -190, 307, 310, 308, 309, 306, 311, - 312, 313, 25, 25, 25, 25, 25, 25, 295, 297, - 299, 285, -190, -190, -284, 78, -185, -190, 28, -299, - 91, 91, -190, -282, -282, -190, -282, -282, -190, -411, - 326, -293, 360, 683, 685, -122, 418, 89, 581, 24, - -123, 24, -415, 120, 121, 122, -208, -150, -153, -150, - 144, 265, -150, -150, -415, -217, -416, -295, 27, 89, - 79, -416, 169, 89, 89, -416, -416, 89, 16, 89, - -225, -223, 151, -145, -416, 89, -416, -416, -209, -145, - -145, -145, -145, -416, -416, -416, -416, -416, -416, -416, - -416, -416, -416, -209, -416, 89, 89, 16, -315, 27, - -416, -416, -416, -416, -416, -224, -416, 16, -416, 79, - 89, 164, 89, -416, -416, -416, 89, 89, -416, -416, - 89, -416, 89, -416, -416, -416, -416, -416, -416, 89, - -416, 89, -416, -416, -416, 89, -416, 89, -416, -416, - 89, -416, 89, -416, 89, -416, 89, -416, 89, -416, - 89, -416, 89, -416, 89, -416, 89, -416, 89, -416, - 89, -416, 89, -416, 89, -416, 89, -416, 89, -416, - 89, -416, 89, -416, 89, -416, -416, -416, 89, -416, - 89, -416, 89, -416, -416, 89, -416, 89, -416, 89, - -416, 89, 89, -416, 89, 89, 89, -416, 89, 89, - 89, 89, -416, -416, -416, -416, 89, 89, 89, 89, - 89, 89, 89, 89, 89, 89, -416, -416, -416, -416, - -416, -416, 89, -94, 605, -416, -416, 89, -416, 89, - 89, 89, 89, 89, -416, -415, 224, -416, -416, -416, - -416, -416, 89, 89, 89, 89, 89, 89, -416, -416, - -416, 89, 89, -416, 89, -416, 89, -416, -398, 689, - 419, -197, -196, -194, 76, 245, 77, -415, -301, -416, - -158, -260, -261, -260, -202, -293, 97, 106, -236, -167, - -169, 16, -215, 90, 89, -329, -240, -246, -279, -293, - 91, 180, -331, 180, -331, 373, 374, -232, 224, -198, - 17, -201, 34, 59, -29, -415, -415, 34, 89, -186, - -188, -187, -189, 68, 72, 74, 69, 70, 71, 75, - -306, 27, -31, -168, -31, -415, -190, -183, -417, 16, - 79, -417, 89, 224, -270, -273, 421, 418, 424, -383, - 91, -110, 89, -356, -343, -237, -140, 42, -336, 380, - -329, 588, -329, -338, 91, -338, 97, 97, 97, 90, - -49, -44, -45, 35, 83, -363, -350, 91, 41, -350, - -350, -293, 90, -233, -139, -190, 145, 78, -367, -367, - -367, -299, -2, 728, 734, 139, 88, 385, 20, -254, - 89, 90, -218, 303, 90, -112, -293, 90, 88, -348, - -348, -293, -415, 241, 33, 33, 672, 628, 620, -59, - -218, -217, -383, -330, 727, 726, 90, 243, 301, -144, - 438, -141, 91, 92, -190, -190, -190, -190, -190, -190, - 233, 230, 408, -407, 314, -407, 286, 244, -183, -190, - 89, -84, 260, 255, -304, -304, 35, -190, 418, 701, - 699, -145, 144, 265, -162, -153, -118, -118, -150, -313, - 180, 346, 264, 344, 340, 360, 351, 378, 342, 379, - 337, 336, 335, -313, -311, -150, -209, -132, -145, -145, - -145, 152, -145, 150, -145, -416, -416, -416, -416, -416, - -229, -145, -145, -145, -416, 180, 346, 16, -145, -311, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -380, -145, -209, -145, -209, - -145, -145, -145, -145, -145, -381, -381, -381, -381, -381, - -209, -209, -209, -209, -145, -415, -293, -97, -96, -95, - 655, 245, -94, -164, -97, -164, 223, -145, 223, 223, - 223, -145, -131, -295, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -194, -344, 283, -344, 283, -344, - -264, 89, -275, 24, 16, 59, 59, -167, -198, -168, - -293, -243, 682, -249, 48, -247, -248, 49, -244, 50, - 58, -331, -331, 171, -234, -145, -265, 78, -266, -274, - -217, -212, -214, -213, -415, -253, -416, -293, -264, -266, - -170, -171, -171, -170, -171, 68, 68, 68, 73, 68, - 73, 68, -187, -299, -416, -145, -302, 79, -168, -168, - -192, -299, 171, 418, 422, 423, -356, -405, 120, 145, - 33, 78, 376, 102, -403, 179, 617, 667, 672, 628, - 621, 662, -404, 247, 138, 139, 259, 27, 43, 90, - 89, 90, 89, 90, 90, 89, -287, -286, -45, -44, - -350, -350, 97, -383, 91, 91, 243, 28, -190, 78, - 78, 78, -113, 732, 97, 88, -3, 83, -145, 88, - 21, -339, -217, -374, -324, -375, -325, -326, -5, -6, - -351, -116, 59, 102, -63, 46, 242, 712, 713, 128, - -415, 725, -366, -254, -370, -372, -190, -149, -415, -161, - -147, -146, -148, -154, 169, 170, 264, 342, 343, -218, - -190, -138, 292, 300, 88, -142, 93, -386, 79, 283, - 376, 283, 376, 91, -408, 315, 91, -408, -190, -84, - -49, -190, -282, -282, 35, -383, -416, -162, -153, -125, - 164, 581, -316, 587, -327, -327, -327, -334, -327, 332, - -327, 332, -327, -416, -416, -416, 89, -416, 24, -416, - 89, -145, 89, -121, 477, 89, 89, -416, 88, 88, - -145, -416, -416, -416, 89, -416, -416, -416, -416, -416, - -416, -416, -416, -416, -416, -416, -416, -416, 89, -416, - 89, -416, 89, -416, 89, -416, 89, -416, 89, -416, - 89, -416, 89, -416, 89, -416, 89, -416, 89, -416, - 89, -416, 89, -416, 89, -416, 89, -416, 89, -416, - -416, 89, -416, -416, -416, 89, -416, 89, -416, 89, - -416, -416, -416, 89, -314, 673, -416, -416, -416, -416, - -416, -416, -416, -416, -416, -416, -416, -93, -294, -293, - -94, 637, 637, -416, -94, -226, 89, -150, -416, -150, - -150, -150, -416, -416, -416, 89, -416, 89, 89, -416, - 89, -416, 89, -416, -416, -416, -416, 89, -195, 24, - -415, -195, -415, -195, -416, -260, -190, -198, -227, 18, - -240, 53, 352, -251, -250, 57, 49, -248, 21, 51, - 21, 32, -265, 89, 153, 89, -416, -416, 89, 59, - 224, -416, -198, -181, -180, 78, 79, -182, 78, -180, - 68, 68, -255, 89, -263, -168, -198, -198, 224, 120, - -415, -149, 14, 91, 91, -383, -402, 716, 717, 33, - 97, -350, -350, 139, 139, -190, 88, -329, 91, -329, - 97, 97, 33, 84, 85, 86, 33, 80, 81, 82, - -190, -190, -190, -190, -371, 88, 21, -145, 88, 153, - 90, -254, -254, 279, 164, -350, 710, 285, 285, -350, - -350, -350, -115, -114, 732, 90, -416, 89, -337, 581, - 584, -145, -155, -155, -255, 90, -379, 581, -385, -293, - -293, -293, -293, 97, 99, -416, 579, 75, 582, -416, - -329, -145, -145, -145, -145, -234, 91, -145, -145, 97, - 97, -416, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -209, -145, -416, -178, -177, -179, 693, 120, - 33, -313, -416, -211, 277, -100, -99, -98, 16, -416, - -145, -118, -118, -118, -118, -145, -145, -145, -145, -145, - -145, -415, 68, 20, 18, -257, -293, 247, -415, -257, - -415, -302, -227, -228, 19, 21, -241, 55, -239, 54, - -239, -250, 21, 21, 91, 21, 91, 139, -274, -145, - -214, 59, -29, -293, -212, -293, -229, -145, 88, -145, - -158, -198, -198, -145, -204, 501, 503, 504, 505, 502, - 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 506, 517, 478, 479, 480, 109, 111, 110, 481, 482, - 483, 346, 529, 530, 524, 527, 528, 526, 525, 361, - 362, 484, 547, 548, 552, 551, 549, 550, 553, 556, - 557, 558, 559, 560, 561, 563, 562, 554, 555, 532, - 531, 533, 534, 535, 536, 537, 538, 540, 539, 541, - 542, 543, 544, 545, 546, 564, 565, 566, 567, 568, - 570, 569, 574, 573, 571, 572, 576, 575, 485, 486, - 112, 113, 114, 115, 116, 117, 118, 487, 490, 488, - 491, 492, 493, 498, 499, 494, 495, 496, 497, 500, - 372, 370, 371, 367, 366, 365, 425, 430, 431, 433, - 518, 519, 520, 521, 522, 523, 674, 675, 676, 677, - 678, 679, 680, 681, 91, 91, 88, -145, 90, 90, - -255, -370, -60, 90, -256, -254, 97, 90, 280, -213, - -415, 91, -350, -350, -350, 97, 97, -301, -416, 89, - -293, -404, -372, 585, 585, -416, 27, -378, -377, -295, - 88, 79, 64, 580, 583, -416, -416, -416, 89, -416, - -416, -416, 90, 90, -416, -416, -416, -416, -416, -416, - -416, -416, -416, -416, -416, -416, -416, -416, -416, -416, - -416, -416, -416, -416, -416, -416, 89, -416, -177, -179, - -416, 78, -158, -229, 21, -97, 302, 304, -97, -416, - -416, -416, -416, -416, 89, -416, -416, 89, -416, 89, - -416, -416, -257, -416, 21, 21, 89, -416, -257, -416, - -257, -197, -228, -107, -106, -105, 611, -145, -209, -242, - 56, 78, 123, 91, 91, 91, 14, -212, 224, -234, - -254, -175, 385, -229, -416, -254, 90, 27, 90, 734, - 139, 90, -213, -124, -415, 276, -301, 91, 91, -114, - -117, -29, 89, 153, -254, -190, 64, -145, -209, -416, - 78, 592, 693, -92, -91, -88, 704, 730, -209, -94, - -94, -145, -145, -145, -416, -293, 247, -416, -416, -107, - 89, -104, -103, -293, 78, 123, -266, -293, 90, -416, - -415, -234, 90, -238, -29, 88, -3, 276, -324, -375, - -325, -326, -5, -6, -351, -82, 581, -377, -355, -299, - -295, 91, 97, 90, 581, -416, -416, -90, 147, 702, - 670, -155, 223, -416, 89, -416, 89, -416, 89, -105, - 89, 27, -302, -176, -174, -293, 634, -395, -394, 577, - -405, -401, 120, 145, 102, -403, 672, 628, 129, 130, - -82, -145, 88, -416, -83, 291, 689, 224, -386, 582, - -90, 703, 648, 623, 648, 623, -150, -145, -145, -145, - -103, -415, -416, 89, 24, -317, -62, 645, -392, -393, - 78, -396, 391, 644, 665, 120, 91, 90, -254, 252, - -300, -379, 583, 144, -118, -416, 89, -416, 89, -416, - -93, -174, 641, -330, -158, -393, 78, -392, 78, 15, - 14, -4, 733, 90, 293, -90, 648, 623, -145, -145, - -416, -61, 28, -175, -391, 260, 255, 258, 34, -391, - 97, -4, -416, -416, 645, 254, 33, 120, -158, -178, - -177, -177, + 470, -119, -118, -144, -144, -144, -144, -144, -144, -87, + -144, 131, 132, 133, -208, -144, -149, -144, -144, -144, + -415, -144, -144, -144, -209, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -381, -380, -379, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -208, -208, -208, + -208, -208, -144, -415, -144, -163, -147, 97, -259, 106, + 93, -144, -144, -144, -144, -144, -144, -209, -294, -299, + -290, -291, -208, -209, -209, -208, -208, -144, -144, -144, + -144, -144, -144, -144, -144, -415, -144, -144, -144, -144, + -144, -251, -415, -208, 89, -398, 418, 419, 690, -301, + 277, -300, 27, -209, 91, 16, -261, 79, -292, -233, + -233, 65, 66, 61, -130, -131, -135, -415, -37, 27, + -253, -292, 629, 629, 64, 91, -328, -270, 373, 374, + 180, -144, -144, 89, -232, 29, 30, -189, -295, 171, + -299, -189, -262, 277, -189, -167, -169, -170, -171, -192, + -215, -414, -172, -31, 600, 597, 16, -182, -183, -191, + -298, -268, -311, -267, 89, 417, 419, 420, 78, 123, + -144, -329, 179, -357, -356, -355, -338, -340, -341, -342, + 90, -329, -334, 379, 378, -326, -326, -326, -326, -326, + -328, -328, -328, -328, 88, 88, -326, -326, -326, -326, + -331, 88, -331, -331, -332, -331, 88, -332, -333, 88, + -333, -368, -144, -365, -364, -362, -363, 251, 102, 672, + 628, 581, 621, 662, 79, -360, -232, 97, -415, -142, + -284, 246, -366, -363, -382, -382, -382, -284, 92, 91, + 92, 91, 92, 91, -111, -60, -1, 729, 730, 731, + 89, 21, -339, -338, -59, 302, -371, -372, 277, -367, + -361, -347, 139, -346, -347, -347, -382, 89, 31, 128, + 128, 128, 128, 581, 230, 34, -285, 620, 145, 672, + 628, -338, -59, 244, 244, -310, -310, -310, 91, 91, + -280, 725, -182, -138, 294, 153, 283, 283, 241, 296, + 241, 296, -189, 307, 310, 308, 309, 306, 311, 312, + 313, 25, 25, 25, 25, 25, 25, 295, 297, 299, + 285, -189, -189, -283, 78, -184, -189, 28, -298, 91, + 91, -189, -281, -281, -189, -281, -281, -189, -410, 326, + -292, 360, 683, 685, -122, 418, 89, 581, 24, -123, + 24, -414, 120, 121, 122, -207, -149, -152, -149, 144, + 265, -149, -149, -414, -216, -415, -294, 27, 89, 79, + -415, 169, 89, -415, -415, 89, 16, 89, -224, -222, + 151, -144, -415, 89, -415, -415, -208, -144, -144, -144, + -144, -415, -415, -415, -415, -415, -415, -415, -415, -415, + -415, -208, -415, 89, 89, 16, -314, 27, -415, -415, + -415, -415, -415, -223, -415, 16, -415, 79, 89, 164, + 89, -415, -415, -415, 89, 89, -415, -415, 89, -415, + 89, -415, -415, -415, -415, -415, -415, 89, -415, 89, + -415, -415, -415, 89, -415, 89, -415, -415, 89, -415, + 89, -415, 89, -415, 89, -415, 89, -415, 89, -415, + 89, -415, 89, -415, 89, -415, 89, -415, 89, -415, + 89, -415, 89, -415, 89, -415, 89, -415, 89, -415, + 89, -415, 89, -415, -415, -415, 89, -415, 89, -415, + 89, -415, -415, 89, -415, 89, -415, 89, -415, 89, + 89, -415, 89, 89, 89, -415, 89, 89, 89, 89, + -415, -415, -415, -415, 89, 89, 89, 89, 89, 89, + 89, 89, 89, 89, -415, -415, -415, -415, -415, -415, + 89, -94, 605, -415, -415, 89, -415, 89, 89, 89, + 89, 89, -415, -414, 224, -415, -415, -415, -415, -415, + 89, 89, 89, 89, 89, 89, -415, -415, -415, 89, + 89, -415, 89, -415, 89, -415, -397, 689, 419, -196, + -195, -193, 76, 245, 77, -414, -300, -415, -157, -259, + -260, -259, -201, -292, 97, 106, -235, -166, 89, -168, + 16, -214, 90, 89, -328, -239, -245, -278, -292, 91, + 180, -330, 180, -330, 373, 374, -231, 224, -197, 17, + -200, 34, 59, -29, -414, -414, 34, 89, -185, -187, + -186, -188, 68, 72, 74, 69, 70, 71, 75, -305, + 27, -31, -167, -31, -414, -189, -182, -416, 16, 79, + -416, 89, 224, -269, -272, 421, 418, 424, -382, 91, + -110, 89, -355, -342, -236, -139, 42, -335, 380, -328, + 588, -328, -337, 91, -337, 97, 97, 97, 90, -49, + -44, -45, 35, 83, -362, -349, 91, 41, -349, -349, + -292, 90, -232, -138, -189, 145, 78, -366, -366, -366, + -298, -2, 728, 734, 139, 88, 385, 20, -253, 89, + 90, -217, 303, 90, -112, -292, 90, 88, -347, -347, + -292, -414, 241, 33, 33, 672, 628, 620, -59, -217, + -216, -382, -329, 727, 726, 90, 243, 301, -143, 438, + -140, 91, 92, -189, -189, -189, -189, -189, -189, 233, + 230, 408, -406, 314, -406, 286, 244, -182, -189, 89, + -84, 260, 255, -303, -303, 35, -189, 418, 701, 699, + -144, 144, 265, -161, -152, -118, -118, -149, -312, 180, + 346, 264, 344, 340, 360, 351, 378, 342, 379, 337, + 336, 335, -312, -310, -149, -208, -144, -144, -144, 152, + -144, 150, -144, -415, -415, -415, -415, -415, -228, -144, + -144, -144, -415, 180, 346, 16, -144, -310, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -379, -144, -208, -144, -208, -144, -144, + -144, -144, -144, -380, -380, -380, -380, -380, -208, -208, + -208, -208, -144, -414, -292, -97, -96, -95, 655, 245, + -94, -163, -97, -163, 223, -144, 223, 223, 223, -144, + -209, -294, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -193, -343, 283, -343, 283, -343, -263, 89, + -274, 24, 16, 59, 59, -166, -197, -131, -167, -292, + -242, 682, -248, 48, -246, -247, 49, -243, 50, 58, + -330, -330, 171, -233, -144, -264, 78, -265, -273, -216, + -211, -213, -212, -414, -252, -415, -292, -263, -265, -169, + -170, -170, -169, -170, 68, 68, 68, 73, 68, 73, + 68, -186, -298, -415, -144, -301, 79, -167, -167, -191, + -298, 171, 418, 422, 423, -355, -404, 120, 145, 33, + 78, 376, 102, -402, 179, 617, 667, 672, 628, 621, + 662, -403, 247, 138, 139, 259, 27, 43, 90, 89, + 90, 89, 90, 90, 89, -286, -285, -45, -44, -349, + -349, 97, -382, 91, 91, 243, 28, -189, 78, 78, + 78, -113, 732, 97, 88, -3, 83, -144, 88, 21, + -338, -216, -373, -323, -374, -324, -325, -5, -6, -350, + -116, 59, 102, -63, 46, 242, 712, 713, 128, -414, + 725, -365, -253, -369, -371, -189, -148, -414, -160, -146, + -145, -147, -153, 169, 170, 264, 342, 343, -217, -189, + -137, 292, 300, 88, -141, 93, -385, 79, 283, 376, + 283, 376, 91, -407, 315, 91, -407, -189, -84, -49, + -189, -281, -281, 35, -382, -415, -161, -152, -125, 164, + 581, -315, 587, -326, -326, -326, -333, -326, 332, -326, + 332, -326, -415, -415, -415, 89, -415, 24, -415, 89, + -144, 89, -121, 477, 89, 89, -415, 88, 88, -144, + -415, -415, -415, 89, -415, -415, -415, -415, -415, -415, + -415, -415, -415, -415, -415, -415, -415, 89, -415, 89, + -415, 89, -415, 89, -415, 89, -415, 89, -415, 89, + -415, 89, -415, 89, -415, 89, -415, 89, -415, 89, + -415, 89, -415, 89, -415, 89, -415, 89, -415, -415, + 89, -415, -415, -415, 89, -415, 89, -415, 89, -415, + -415, -415, 89, -313, 673, -415, -415, -415, -415, -415, + -415, -415, -415, -415, -415, -415, -93, -293, -292, -94, + 637, 637, -415, -94, -225, 89, -149, -415, -149, -149, + -149, -415, -415, -415, 89, -415, 89, 89, -415, 89, + -415, 89, -415, -415, -415, -415, 89, -194, 24, -414, + -194, -414, -194, -415, -259, -189, -197, -226, 18, -239, + 53, 352, -250, -249, 57, 49, -247, 21, 51, 21, + 32, -264, 89, 153, 89, -415, -415, 89, 59, 224, + -415, -197, -180, -179, 78, 79, -181, 78, -179, 68, + 68, -254, 89, -262, -167, -197, -197, 224, 120, -414, + -148, 14, 91, 91, -382, -401, 716, 717, 33, 97, + -349, -349, 139, 139, -189, 88, -328, 91, -328, 97, + 97, 33, 84, 85, 86, 33, 80, 81, 82, -189, + -189, -189, -189, -370, 88, 21, -144, 88, 153, 90, + -253, -253, 279, 164, -349, 710, 285, 285, -349, -349, + -349, -115, -114, 732, 90, -415, 89, -336, 581, 584, + -144, -154, -154, -254, 90, -378, 581, -384, -292, -292, + -292, -292, 97, 99, -415, 579, 75, 582, -415, -328, + -144, -144, -144, -144, -233, 91, -144, -144, 97, 97, + -415, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, + -144, -208, -144, -415, -177, -176, -178, 693, 120, 33, + -312, -415, -210, 277, -100, -99, -98, 16, -415, -144, + -118, -118, -118, -118, -144, -144, -144, -144, -144, -144, + -414, 68, 20, 18, -256, -292, 247, -414, -256, -414, + -301, -226, -227, 19, 21, -240, 55, -238, 54, -238, + -249, 21, 21, 91, 21, 91, 139, -273, -144, -213, + 59, -29, -292, -211, -292, -228, -144, 88, -144, -157, + -197, -197, -144, -203, 501, 503, 504, 505, 502, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 516, 506, + 517, 478, 479, 480, 109, 111, 110, 481, 482, 483, + 346, 529, 530, 524, 527, 528, 526, 525, 361, 362, + 484, 547, 548, 552, 551, 549, 550, 553, 556, 557, + 558, 559, 560, 561, 563, 562, 554, 555, 532, 531, + 533, 534, 535, 536, 537, 538, 540, 539, 541, 542, + 543, 544, 545, 546, 564, 565, 566, 567, 568, 570, + 569, 574, 573, 571, 572, 576, 575, 485, 486, 112, + 113, 114, 115, 116, 117, 118, 487, 490, 488, 491, + 492, 493, 498, 499, 494, 495, 496, 497, 500, 372, + 370, 371, 367, 366, 365, 425, 430, 431, 433, 518, + 519, 520, 521, 522, 523, 674, 675, 676, 677, 678, + 679, 680, 681, 91, 91, 88, -144, 90, 90, -254, + -369, -60, 90, -255, -253, 97, 90, 280, -212, -414, + 91, -349, -349, -349, 97, 97, -300, -415, 89, -292, + -403, -371, 585, 585, -415, 27, -377, -376, -294, 88, + 79, 64, 580, 583, -415, -415, -415, 89, -415, -415, + -415, 90, 90, -415, -415, -415, -415, -415, -415, -415, + -415, -415, -415, -415, -415, -415, -415, -415, -415, -415, + -415, -415, -415, -415, -415, 89, -415, -176, -178, -415, + 78, -157, -228, 21, -97, 302, 304, -97, -415, -415, + -415, -415, -415, 89, -415, -415, 89, -415, 89, -415, + -415, -256, -415, 21, 21, 89, -415, -256, -415, -256, + -196, -227, -107, -106, -105, 611, -144, -208, -241, 56, + 78, 123, 91, 91, 91, 14, -211, 224, -233, -253, + -174, 385, -228, -415, -253, 90, 27, 90, 734, 139, + 90, -212, -124, -414, 276, -300, 91, 91, -114, -117, + -29, 89, 153, -253, -189, 64, -144, -208, -415, 78, + 592, 693, -92, -91, -88, 704, 730, -208, -94, -94, + -144, -144, -144, -415, -292, 247, -415, -415, -107, 89, + -104, -103, -292, 78, 123, -265, -292, 90, -415, -414, + -233, 90, -237, -29, 88, -3, 276, -323, -374, -324, + -325, -5, -6, -350, -82, 581, -376, -354, -298, -294, + 91, 97, 90, 581, -415, -415, -90, 147, 702, 670, + -154, 223, -415, 89, -415, 89, -415, 89, -105, 89, + 27, -301, -175, -173, -292, 634, -394, -393, 577, -404, + -400, 120, 145, 102, -402, 672, 628, 129, 130, -82, + -144, 88, -415, -83, 291, 689, 224, -385, 582, -90, + 703, 648, 623, 648, 623, -149, -144, -144, -144, -103, + -414, -415, 89, 24, -316, -62, 645, -391, -392, 78, + -395, 391, 644, 665, 120, 91, 90, -253, 252, -299, + -378, 583, 144, -118, -415, 89, -415, 89, -415, -93, + -173, 641, -329, -157, -392, 78, -391, 78, 15, 14, + -4, 733, 90, 293, -90, 648, 623, -144, -144, -415, + -61, 28, -174, -390, 260, 255, 258, 34, -390, 97, + -4, -415, -415, 645, 254, 33, 120, -157, -177, -176, + -176, } var yyDef = [...]int{ @@ -9316,158 +9257,158 @@ var yyDef = [...]int{ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 72, 74, 75, 882, 882, 882, 0, 882, 0, - 0, 882, -2, -2, 882, 1620, 0, 882, 0, 877, + 0, 882, -2, -2, 882, 1618, 0, 882, 0, 877, 0, -2, 799, 805, 0, 814, -2, 0, 0, 882, - 882, 2246, 2246, 877, 0, 0, 0, 0, 0, 882, - 882, 882, 882, 1625, 1481, 52, 882, 0, 87, 88, - 832, 833, 834, 67, 0, 2244, 883, 1, 3, 73, - 77, 0, 0, 0, 60, 1490, 0, 80, 0, 0, - 886, 0, 0, 1603, 882, 882, 0, 128, 129, 0, + 882, 2244, 2244, 877, 0, 0, 0, 0, 0, 882, + 882, 882, 882, 1623, 1479, 52, 882, 0, 87, 88, + 832, 833, 834, 67, 0, 2242, 883, 1, 3, 73, + 77, 0, 0, 0, 60, 1488, 0, 80, 0, 0, + 886, 0, 0, 1601, 882, 882, 0, 128, 129, 0, 0, 0, -2, 132, -2, 161, 162, 163, 0, 168, 609, 528, 580, 526, 565, -2, 514, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 531, - 403, 403, 0, 0, -2, 514, 514, 514, 1605, 0, + 403, 403, 0, 0, -2, 514, 514, 514, 1603, 0, 0, 0, 562, 465, 403, 403, 403, 0, 403, 403, 403, 403, 0, 0, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403, - 403, 1508, 167, 1621, 1618, 1619, 1778, 1779, 1780, 1781, - 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1791, - 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, - 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, - 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, - 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, - 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, - 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, - 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, - 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, - 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, - 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, - 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, - 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, - 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, - 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, - 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, - 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, - 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, - 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, - 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, - 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, - 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, - 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, - 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, - 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, - 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, - 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, - 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, - 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, - 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, - 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, - 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, - 2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, - 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, - 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, - 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, - 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, - 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, - 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, - 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, - 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, - 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, - 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, - 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, - 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, - 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, - 2242, 2243, 0, 1597, 0, 722, 984, 0, 878, 879, + 403, 1506, 167, 1619, 1616, 1617, 1776, 1777, 1778, 1779, + 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, + 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, + 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, + 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, + 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, + 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, + 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, + 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, + 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, + 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, + 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, + 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, + 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, + 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, + 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, + 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, + 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, + 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, + 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, + 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, + 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, + 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, + 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, + 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, + 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, + 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, + 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, + 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, + 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, + 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, + 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, + 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, + 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, + 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, + 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, + 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, + 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, + 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, + 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, + 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, + 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, + 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, + 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, + 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, + 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, + 2240, 2241, 0, 1595, 0, 722, 982, 0, 878, 879, 0, 788, 788, 0, 788, 788, 788, 788, 0, 0, 0, 736, 0, 0, 0, 0, 785, 0, 752, 753, 0, 785, 0, 759, 791, 0, 0, 766, 788, 788, - 769, 2247, 0, 2247, 2247, 1588, 0, 782, 780, 794, + 769, 2245, 0, 2245, 2245, 1586, 0, 782, 780, 794, 795, 42, 798, 801, 802, 803, 804, 807, 0, 818, - 821, 1614, 1615, 0, 823, 828, 845, 846, 0, 47, - 1136, 0, 1008, 0, 1014, -2, 1025, 1042, 1043, 1044, - 1045, 1046, 1048, 1049, 1050, 0, 0, 0, 0, 1055, - 1056, 0, 0, 0, 0, 0, 1117, 0, 0, 0, - 0, 1977, 1454, 0, 0, 1416, 1416, 1152, 1416, 1416, - 1418, 1418, 1418, 1830, 1969, 1978, 2154, 1791, 1797, 1798, - 1799, 2100, 2101, 2102, 2103, 2191, 2192, 2196, 1893, 1786, - 2167, 2168, 0, 2243, 1930, 1938, 1939, 1963, 2064, 2177, - 1809, 1958, 2028, 1890, 1912, 1913, 2046, 2047, 1934, 1935, - 1916, 2106, 2108, 2124, 2125, 2110, 2112, 2121, 2127, 2132, - 2111, 2123, 2128, 2141, 2145, 2148, 2149, 2150, 2118, 2116, - 2129, 2133, 2135, 2137, 2143, 2146, 2119, 2117, 2130, 2134, - 2136, 2138, 2144, 2147, 2105, 2109, 2113, 2122, 2140, 2120, - 2139, 2114, 2126, 2131, 2142, 2115, 2107, 1928, 1931, 1919, - 1920, 1922, 1924, 1929, 1936, 1942, 1921, 1941, 1940, 0, - 1917, 1918, 1923, 1933, 1937, 1925, 1926, 1927, 1932, 1943, - 1984, 1983, 1982, 2027, 1954, 2026, 0, 0, 0, 0, - 0, 1781, 1835, 1836, 2151, 1338, 1339, 1340, 1341, 0, - 0, 0, 0, 0, 0, 0, 293, 294, 1467, 1468, - 46, 1135, 1584, 1418, 1418, 1418, 1418, 1418, 1418, 1077, - 1078, 1079, 1080, 1081, 1105, 1106, 1112, 1113, 2041, 2042, - 2043, 2044, 1873, 2186, 1882, 1883, 2023, 2024, 1895, 1896, - 2217, 2218, -2, -2, -2, 234, 235, 236, 237, 238, - 239, 240, 241, 0, 1834, 2165, 2166, 230, 0, 0, - 298, 295, 296, 297, 1119, 1120, 251, 252, 253, 254, + 821, 1612, 1613, 0, 823, 828, 845, 846, 0, 47, + 1134, 0, 1006, 0, 1012, -2, 1023, 1040, 1041, 1042, + 1043, 1044, 1046, 1047, 1048, 0, 0, 0, 0, 1053, + 1054, 0, 0, 0, 0, 0, 1115, 0, 0, 0, + 0, 1975, 1452, 0, 0, 1414, 1414, 1150, 1414, 1414, + 1416, 1416, 1416, 1828, 1967, 1976, 2152, 1789, 1795, 1796, + 1797, 2098, 2099, 2100, 2101, 2189, 2190, 2194, 1891, 1784, + 2165, 2166, 0, 2241, 1928, 1936, 1937, 1961, 2062, 2175, + 1807, 1956, 2026, 1888, 1910, 1911, 2044, 2045, 1932, 1933, + 1914, 2104, 2106, 2122, 2123, 2108, 2110, 2119, 2125, 2130, + 2109, 2121, 2126, 2139, 2143, 2146, 2147, 2148, 2116, 2114, + 2127, 2131, 2133, 2135, 2141, 2144, 2117, 2115, 2128, 2132, + 2134, 2136, 2142, 2145, 2103, 2107, 2111, 2120, 2138, 2118, + 2137, 2112, 2124, 2129, 2140, 2113, 2105, 1926, 1929, 1917, + 1918, 1920, 1922, 1927, 1934, 1940, 1919, 1939, 1938, 0, + 1915, 1916, 1921, 1931, 1935, 1923, 1924, 1925, 1930, 1941, + 1982, 1981, 1980, 2025, 1952, 2024, 0, 0, 0, 0, + 0, 1779, 1833, 1834, 2149, 1336, 1337, 1338, 1339, 0, + 0, 0, 0, 0, 0, 0, 293, 294, 1465, 1466, + 46, 1133, 1582, 1416, 1416, 1416, 1416, 1416, 1416, 1075, + 1076, 1077, 1078, 1079, 1103, 1104, 1110, 1111, 2039, 2040, + 2041, 2042, 1871, 2184, 1880, 1881, 2021, 2022, 1893, 1894, + 2215, 2216, -2, -2, -2, 234, 235, 236, 237, 238, + 239, 240, 241, 0, 1832, 2163, 2164, 230, 0, 0, + 298, 295, 296, 297, 1117, 1118, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 300, 301, - 2246, 0, 855, 0, 0, 0, 0, 0, 0, 1626, - 1627, 1490, 0, 1482, 1481, 65, 0, 882, -2, 0, - 0, 0, 0, 49, 0, 54, 941, 885, 79, 78, - 1530, 1533, 0, 0, 0, 61, 1491, 69, 71, 1492, - 0, 887, 888, 0, 917, 921, 0, 0, 0, 1604, - 1603, 1603, 104, 0, 0, 105, 125, 126, 127, 0, - 0, 111, 112, 1590, 1591, 45, 0, 0, 179, 180, - 0, 43, 430, 0, 175, 0, 423, 362, 0, 1508, - 0, 0, 0, 0, 0, 882, 0, 1598, 156, 157, + 2244, 0, 855, 0, 0, 0, 0, 0, 0, 1624, + 1625, 1488, 0, 1480, 1479, 65, 0, 882, -2, 0, + 0, 0, 0, 49, 0, 54, 939, 885, 79, 78, + 1528, 1531, 0, 0, 0, 61, 1489, 69, 71, 1490, + 0, 887, 888, 0, 915, 919, 0, 0, 0, 1602, + 1601, 1601, 104, 0, 0, 105, 125, 126, 127, 0, + 0, 111, 112, 1588, 1589, 45, 0, 0, 179, 180, + 0, 43, 430, 0, 175, 0, 423, 362, 0, 1506, + 0, 0, 0, 0, 0, 882, 0, 1596, 156, 157, 164, 165, 166, 403, 403, 403, 577, 0, 0, 167, 167, 535, 536, 537, 0, 0, -2, 428, 0, 515, 0, 0, 417, 417, 421, 419, 420, 0, 0, 0, 0, 0, 0, 0, 0, 554, 0, 555, 0, 0, 0, 0, 0, 0, 0, 0, 0, 670, 0, 404, 0, 575, 576, 466, 0, 0, 0, 0, 0, 0, - 0, 0, 1606, 1607, 0, 552, 553, 0, 0, 0, + 0, 0, 1604, 1605, 0, 552, 553, 0, 0, 0, 403, 403, 0, 0, 0, 0, 403, 403, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 155, 1521, 0, 0, - 0, -2, 0, 714, 0, 0, 0, 1599, 1599, 0, + 0, 0, 0, 0, 0, 0, 155, 1519, 0, 0, + 0, -2, 0, 714, 0, 0, 0, 1597, 1597, 0, 721, 0, 0, 0, 726, 0, 0, 727, 0, 785, 785, 783, 784, 729, 730, 731, 732, 788, 0, 0, 412, 413, 414, 785, 788, 0, 788, 788, 788, 788, 785, 785, 785, 788, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2247, 791, 788, 0, 760, 0, 761, - 762, 763, 764, 767, 768, 770, 2248, 2249, 1616, 1617, - 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, - 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, - 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, - 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, - 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, - 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, - 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, - 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, - 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, - 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, - 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, - 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, - 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, - 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, - 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, - 2247, 2247, 774, 778, 1589, 800, 806, 808, 809, 0, - 0, 819, 822, 839, 51, 1881, 827, 51, 829, 830, + 0, 0, 0, 2245, 791, 788, 0, 760, 0, 761, + 762, 763, 764, 767, 768, 770, 2246, 2247, 1614, 1615, + 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, + 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, + 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, + 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, + 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, + 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, + 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, + 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, + 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, + 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, + 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, + 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, + 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, + 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, + 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, + 2245, 2245, 774, 778, 1587, 800, 806, 808, 809, 0, + 0, 819, 822, 839, 51, 1879, 827, 51, 829, 830, 831, 857, 858, 863, 0, 0, 0, 0, 869, 870, 871, 0, 0, 874, 875, 876, 0, 0, 0, 0, - 0, 1006, 0, 0, 1125, 1126, 1127, 1128, 1129, 1130, - 1131, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1026, - 1027, 0, 0, 0, 1051, 1052, 1053, 1054, 1057, 0, - 1068, 0, 1070, 1463, -2, 0, 0, 0, 1062, 1063, - 0, 0, 0, 0, 0, 0, 0, 0, 1455, 0, - 0, 1150, 0, 1151, 1153, 1154, 1155, 0, 1156, 1157, + 0, 1004, 0, 0, 1123, 1124, 1125, 1126, 1127, 1128, + 1129, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1024, + 1025, 0, 0, 0, 1049, 1050, 1051, 1052, 1055, 0, + 1066, 0, 1068, 1461, -2, 0, 0, 0, 1060, 1061, + 0, 0, 0, 1607, 1607, 0, 0, 0, 1453, 0, + 0, 1148, 0, 1149, 1151, 1152, 1153, 0, 1154, 1155, 892, 892, 892, 892, 892, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 892, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1609, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1607, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -9476,258 +9417,258 @@ var yyDef = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 902, 0, 0, 902, 902, 0, 0, 222, + 0, 0, 1607, 0, 0, 1607, 1607, 0, 0, 222, 223, 224, 225, 226, 227, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 299, 242, 243, 244, 245, 246, 247, 302, 248, 249, 250, - 1135, 0, 0, 0, 48, 847, 848, 0, 967, 1609, - 0, 0, 898, 0, 1624, 59, 68, 70, 1490, 63, - 1490, 0, 904, 0, 0, -2, -2, 905, 906, 910, - 911, 912, 913, 914, 56, 2245, 57, 0, 76, 0, - 50, 0, 0, 1531, 0, 1534, 0, 0, 0, 376, - 1538, 0, 0, 1483, 1484, 1487, 0, 918, 1975, 922, - 0, 924, 925, 0, 0, 102, 0, 983, 0, 0, - 0, 113, 0, 115, 116, 0, 0, 0, 387, 1592, - 1593, 1594, -2, 410, 0, 387, 371, 310, 311, 312, + 1133, 0, 0, 0, 48, 847, 848, 0, 965, 1607, + 0, 0, 898, 0, 1622, 59, 68, 70, 1488, 63, + 1488, 0, 902, 0, 0, -2, -2, 903, 904, 908, + 909, 910, 911, 912, 56, 2243, 57, 0, 76, 0, + 50, 0, 0, 1529, 0, 1532, 0, 0, 0, 376, + 1536, 0, 0, 1481, 1482, 1485, 0, 916, 1973, 920, + 0, 922, 923, 0, 0, 102, 0, 981, 0, 0, + 0, 113, 0, 115, 116, 0, 0, 0, 387, 1590, + 1591, 1592, -2, 410, 0, 387, 371, 310, 311, 312, 362, 314, 362, 362, 362, 362, 376, 376, 376, 376, 345, 346, 347, 348, 349, 0, 0, 331, 362, 362, 362, 362, 352, 353, 354, 355, 356, 357, 358, 359, 315, 316, 317, 318, 319, 320, 321, 322, 323, 364, 364, 364, 364, 364, 368, 368, 0, 44, 0, 391, - 0, 1487, 0, 0, 1521, 1601, 1611, 0, 0, 0, - 1601, 134, 0, 0, 0, 578, 620, 529, 566, 579, + 0, 1485, 0, 0, 1519, 1599, 1609, 0, 0, 0, + 1599, 134, 0, 0, 0, 578, 620, 529, 566, 579, 0, 532, 533, -2, 0, 0, 514, 0, 516, 0, 411, 0, -2, 0, 421, 0, 417, 421, 418, 421, - 409, 422, 556, 557, 558, 0, 560, 561, 650, 953, + 409, 422, 556, 557, 558, 0, 560, 561, 650, 951, 0, 0, 0, 0, 0, 656, 657, 658, 0, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 567, 568, 569, 570, 571, 572, 573, 574, 0, 0, 0, 0, 516, 0, 563, 0, 0, 467, 468, 469, 0, 0, 472, 473, 474, 475, 0, 0, 478, 479, 480, - 970, 971, 481, 482, 507, 508, 509, 483, 484, 485, + 968, 969, 481, 482, 507, 508, 509, 483, 484, 485, 486, 487, 488, 489, 501, 502, 503, 504, 505, 506, - 490, 491, 492, 493, 494, 495, 498, 0, 149, 1512, + 490, 491, 492, 493, 494, 495, 498, 0, 149, 1510, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1599, 0, 0, 0, - 0, 901, 985, 1622, 1623, 723, 0, 0, 789, 790, + 0, 0, 0, 0, 0, 0, 1597, 0, 0, 0, + 0, 901, 983, 1620, 1621, 723, 0, 0, 789, 790, 0, 415, 416, 788, 788, 733, 775, 0, 788, 737, 776, 738, 740, 739, 741, 754, 755, 788, 744, 786, 787, 745, 746, 747, 748, 749, 750, 751, 771, 756, 757, 758, 792, 0, 796, 797, 772, 773, 0, 0, 812, 813, 0, 820, 842, 840, 841, 843, 835, 836, 837, 838, 0, 844, 0, 0, 860, 98, 865, 866, - 867, 868, 880, 873, 1137, 1003, 1004, 1005, 0, 1007, - 1011, 0, 1121, 1123, 1013, 1009, 1015, 1132, 1133, 1134, - 0, 0, 0, 0, 0, 1019, 1023, 1028, 1029, 1030, - 1031, 1032, 0, 1033, 0, 1036, 1037, 1038, 1039, 1040, - 1041, 1047, 1431, 1432, 1433, 1066, 303, 304, 0, 1067, - 0, 0, 0, 0, 0, 0, 0, 0, 1378, 1379, - 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, - 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1136, 0, - 915, 0, 0, 0, 1461, 1458, 0, 0, 0, 1417, - 1419, 0, 0, 0, 893, 894, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1398, 1399, 1400, 1401, 1402, 1403, 1404, - 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, - 1415, 0, 0, 1434, 0, 0, 0, 0, 0, 1454, - 0, 1072, 1073, 1074, 0, 0, 0, 0, 0, 0, - 1196, 0, 0, 0, 0, 1610, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 144, 145, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1342, 1343, 1344, - 1345, 41, 0, 0, 0, 0, 0, 0, 0, 903, - 1465, 0, -2, -2, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1367, 0, 0, - 0, 0, 0, 0, 1582, 0, 0, 850, 851, 853, - 0, 987, 0, 968, 0, 0, 856, 0, 897, 0, - 900, 62, 64, 908, 909, 0, 926, 907, 58, 53, - 0, 0, 945, 1532, 1535, 1536, 376, 1558, 0, 385, - 385, 382, 1493, 1494, 0, 1486, 1488, 1489, 81, 923, - 919, 0, 1001, 0, 0, 982, 0, 929, 931, 932, - 933, 965, 0, 936, 937, 0, 0, 0, 0, 0, - 100, 984, 106, 0, 114, 0, 0, 119, 120, 107, - 108, 109, 110, 0, 609, -2, 462, 181, 183, 184, - 185, 176, -2, 374, 372, 373, 313, 376, 376, 339, - 340, 341, 342, 343, 344, 0, 0, 332, 333, 334, - 335, 324, 0, 325, 326, 327, 366, 0, 328, 329, - 0, 330, 429, 0, 1495, 392, 393, 395, 403, 0, - 398, 399, 0, 403, 403, 0, 424, 425, 0, 1487, - 1512, 0, 0, 0, 1612, 1611, 1611, 1611, 0, 169, - 170, 171, 172, 173, 174, 645, 0, 0, 621, 643, - 644, 167, 0, 0, 177, 518, 517, 0, 677, 0, - 427, 0, 0, 421, 421, 406, 407, 559, 0, 0, - 652, 653, 654, 655, 0, 0, 0, 545, 456, 0, - 546, 547, 516, 518, 0, 0, 387, 470, 471, 476, - 477, 496, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 594, 595, 596, 599, 601, 520, - 605, 607, 598, 600, 602, 520, 606, 608, 1509, 1510, - 1511, 0, 0, 715, 0, 0, 453, 96, 1600, 720, - 724, 725, 785, 743, 777, 785, 735, 742, 765, 810, - 811, 816, 824, 825, 826, 864, 0, 0, 0, 0, - 872, 0, 0, 1012, 1122, 1124, 1016, 0, 1020, 1024, - 0, 0, 0, 0, 0, 1071, 1069, 1465, 0, 0, - 0, 1118, 0, 0, 0, 1140, 1141, 0, 0, 0, - 0, 1459, 0, 0, 1148, 0, 1420, 1158, 0, 0, - 0, 0, 0, 1164, 1165, 1166, 1167, 1168, 1169, 1170, - 1171, 1172, 1173, 1481, 1175, 0, 0, 0, 0, 0, - 1180, 1181, 1182, 1183, 1184, 0, 1186, 0, 1187, 0, - 0, 0, 0, 1194, 1195, 1197, 0, 0, 1200, 1201, - 0, 1203, 0, 1205, 1206, 1207, 1208, 1209, 1210, 0, - 1212, 0, 1214, 1215, 1216, 0, 1218, 0, 1220, 1221, - 0, 1223, 0, 1225, 0, 1228, 0, 1231, 0, 1234, - 0, 1237, 0, 1240, 0, 1243, 0, 1246, 0, 1249, - 0, 1252, 0, 1255, 0, 1258, 0, 1261, 0, 1264, - 0, 1267, 0, 1270, 0, 1273, 1274, 1275, 0, 1277, - 0, 1279, 0, 1282, 1283, 0, 1285, 0, 1288, 0, - 1291, 0, 0, 1292, 0, 0, 0, 1296, 0, 0, - 0, 0, 1305, 1306, 1307, 1308, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1319, 1320, 1321, 1322, - 1323, 1324, 0, 1326, 0, 1100, 0, 0, 1100, 0, - 0, 0, 0, 0, 1138, 902, 0, 1421, 1422, 1423, - 1424, 1425, 0, 0, 0, 0, 0, 0, 1365, 1366, - 1368, 0, 0, 1371, 0, 1373, 0, 1583, 849, 852, - 854, 939, 988, 989, 0, 0, 0, 0, 969, 1608, - 895, 896, 899, 947, 0, 1469, 0, 0, 926, 1001, - 927, 0, 55, 942, 0, 1540, 1539, 1552, 1565, 385, - 385, 379, 380, 386, 381, 383, 384, 1485, 0, 1490, - 0, 1576, 0, 0, 1568, 0, 0, 0, 0, 0, - 0, 0, 0, 972, 0, 0, 975, 0, 0, 0, - 0, 966, 937, 0, 938, 0, -2, 0, 0, 94, - 95, 0, 0, 0, 117, 118, 0, 0, 124, 388, - 389, 158, 167, 464, 182, 437, 0, 0, 309, 375, - 336, 337, 338, 0, 360, 0, 0, 0, 0, 458, - 130, 1499, 1498, 403, 403, 394, 0, 397, 0, 0, - 0, 1613, 363, 426, 0, 148, 0, 0, 0, 0, - 0, 154, 615, 0, 0, 622, 0, 0, 0, 527, - 0, 538, 539, 0, 649, -2, 711, 391, 0, 405, - 408, 954, 0, 0, 540, 0, 543, 544, 457, 518, - 549, 550, 564, 551, 499, 500, 497, 0, 0, 1522, - 1523, 1528, 1526, 1527, 135, 585, 587, 591, 586, 590, - 0, 0, 0, 522, 0, 522, 583, 0, 453, 1495, - 0, 719, 454, 455, 788, 788, 859, 99, 0, 862, - 0, 0, 0, 0, 1017, 1021, 1034, 1035, 1426, 1452, - 362, 362, 1439, 362, 368, 1442, 362, 1444, 362, 1447, - 362, 1450, 1451, 0, 0, 1064, 0, 916, 0, 0, - 0, 1147, 1462, 0, 0, 1159, 1160, 1161, 1162, 1163, - 1456, 0, 0, 0, 1179, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 146, 147, 0, 0, 0, - 0, 0, 0, 1376, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1095, 1099, 0, 1101, 1102, - 0, 0, 1328, 0, 0, 1346, 0, 0, 0, 0, - 0, 0, 0, 1466, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 990, 997, 0, 997, 0, 997, - 0, 0, 0, 1595, 1596, 1470, 1471, 1001, 1472, 928, - 946, 1558, 0, 1551, 0, -2, 1560, 0, 0, 0, - 1566, 377, 378, 920, 82, 1002, 85, 0, 1576, 1585, - 0, 1567, 1578, 1580, 0, 0, 0, 1572, 0, 1001, - 930, 961, 963, 0, 958, 973, 974, 976, 0, 978, - 0, 980, 981, 941, 935, 0, 102, 0, 1001, 1001, - 101, 0, 986, 121, 122, 123, 463, 186, 191, 0, - 0, 0, 196, 0, 198, 0, 0, 0, 203, 204, - 403, 403, 438, 0, 306, 308, 0, 0, 189, 376, - 0, 376, 0, 367, 369, 0, 439, 459, 1496, 1497, - 0, 0, 396, 400, 401, 402, 0, 1602, 150, 0, - 0, 0, 618, 0, 646, 0, 0, 0, 0, 0, - 0, 178, 519, 678, 679, 680, 681, 682, 683, 684, - 685, 686, 0, 403, 0, 0, 0, 403, 403, 403, - 0, 703, 390, 0, 0, 674, 671, 541, 0, 220, - 221, 228, 229, 231, 0, 0, 0, 0, 0, 548, - 941, 1513, 1514, 1515, 0, 1525, 1529, 138, 0, 0, - 0, 0, 593, 597, 603, 0, 521, 604, 716, 717, - 718, 97, 728, 734, 861, 881, 1010, 1018, 1022, 0, - 0, 0, 0, 1453, 1437, 376, 1440, 1441, 1443, 1445, - 1446, 1448, 1449, 1060, 1061, 1065, 0, 1144, 0, 1146, - 0, 1460, 0, 1490, 0, 0, 0, 1178, 0, 0, - 0, 1189, 1188, 1190, 0, 1192, 1193, 1198, 1199, 1202, - 1204, 1211, 1213, 1217, 1219, 1222, 1224, 1226, 0, 1229, - 0, 1232, 0, 1235, 0, 1238, 0, 1241, 0, 1244, - 0, 1247, 0, 1250, 0, 1253, 0, 1256, 0, 1259, - 0, 1262, 0, 1265, 0, 1268, 0, 1271, 0, 1276, - 1278, 0, 1281, 1284, 1286, 0, 1289, 0, 1293, 0, - 1295, 1297, 1298, 0, 0, 0, 1309, 1310, 1311, 1312, - 1313, 1314, 1315, 1316, 1317, 1318, 1325, 0, 1093, 1096, - 1327, 1103, 1104, 1109, 1330, 0, 0, 0, 1333, 0, - 0, 0, 1337, 1139, 1348, 0, 1353, 0, 0, 1359, - 0, 1363, 0, 1369, 1370, 1372, 1374, 0, 0, 0, - 0, 0, 0, 0, 967, 948, 66, 1472, 1474, 0, - 1545, 1543, 1543, 1553, 1554, 0, 0, 1561, 0, 0, - 0, 0, 86, 0, 0, 0, 1581, 0, 0, 0, - 0, 103, 1481, 955, 962, 0, 0, 956, 0, 957, - 977, 979, 934, 0, 1001, 1001, 92, 93, 0, 192, - 0, 194, 0, 197, 199, 200, 201, 207, 208, 209, - 202, 0, 0, 305, 307, 0, 0, 350, 361, 351, - 0, 0, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, - 941, 151, 152, 153, 610, 0, 620, 0, 943, 0, - 613, 0, 530, 0, 0, 0, 403, 403, 403, 0, - 0, 0, 0, 688, 0, 0, 651, 0, 659, 0, - 0, 0, 232, 233, 0, 1524, 584, 0, 136, 137, - 0, 0, 589, 523, 524, 1058, 0, 0, 0, 1059, - 1438, 0, 0, 0, 0, 0, 1457, 0, 0, 0, - 0, 1185, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1301, 0, 0, 0, 640, 641, - 0, 1377, 1098, 1481, 0, 1100, 1110, 1111, 0, 1100, - 1347, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 998, 0, 0, 0, 949, 950, 0, 0, - 0, 987, 1474, 1479, 0, 0, 1548, 0, 1541, 1544, - 1542, 1555, 0, 0, 1562, 0, 1564, 0, 1586, 1587, - 1579, 0, 1571, 1574, 1570, 1573, 1490, 959, 0, 964, - 0, 1481, 91, 0, 195, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 205, 206, 0, 0, 365, 370, - 0, 0, 0, 611, 0, 944, 623, 614, 0, 701, - 0, 705, 0, 0, 0, 708, 709, 710, 687, 0, - 691, 431, 675, 672, 673, 542, 0, 139, 140, 0, - 0, 0, 1427, 0, 1430, 1142, 1145, 1143, 0, 1174, - 1176, 1177, 1435, 1436, 1191, 1227, 1230, 1233, 1236, 1239, - 1242, 1245, 1248, 1251, 1254, 1257, 1260, 1263, 1266, 1269, - 1272, 1280, 1287, 1290, 1294, 1299, 0, 1302, 0, 0, - 1303, 0, 642, 1089, 0, 0, 1107, 1108, 0, 1332, - 1334, 1335, 1336, 1349, 0, 1354, 1355, 0, 1360, 0, - 1364, 1375, 0, 992, 999, 1000, 0, 995, 0, 996, - 0, 940, 1479, 84, 1480, 1477, 0, 1475, 1473, 1537, - 0, 1546, 1547, 1556, 1557, 1563, 0, 1569, 0, 89, - 0, 0, 0, 1490, 193, 0, 212, 0, 619, 0, - 622, 612, 699, 700, 0, 712, 704, 706, 707, 689, - -2, 1516, 0, 0, 0, 592, 1428, 0, 0, 1304, - 0, 638, 639, 1097, 1090, 0, 1075, 1076, 1094, 1329, - 1331, 0, 0, 0, 991, 951, 952, 993, 994, 83, - 0, 1476, 1115, 0, 1549, 1550, 1577, 1575, 960, 967, - 0, 90, 444, 437, 1516, 0, 0, 0, 692, 693, - 694, 695, 696, 697, 698, 581, 1518, 141, 142, 0, - 511, 512, 513, 135, 0, 1149, 1300, 1091, 0, 0, - 0, 0, 0, 1350, 0, 1356, 0, 1361, 0, 1478, - 0, 0, 624, 0, 626, 0, -2, 432, 445, 0, - 187, 213, 214, 0, 0, 217, 218, 219, 210, 211, - 131, 0, 0, 713, 0, 1519, 1520, 0, 138, 0, - 0, 1082, 1083, 1084, 1085, 1087, 0, 0, 0, 0, - 1116, 1095, 625, 0, 0, 387, 0, 635, 433, 434, - 0, 440, 441, 442, 443, 215, 216, 647, 0, 0, - 510, 588, 1429, 0, 0, 1351, 0, 1357, 0, 1362, - 0, 627, 628, 636, 0, 435, 0, 436, 0, 0, - 0, 616, 0, 647, 1517, 1092, 1086, 1088, 0, 0, - 1114, 0, 637, 633, 446, 448, 449, 0, 0, 447, - 648, 617, 1352, 1358, 0, 450, 451, 452, 629, 630, - 631, 632, + 867, 868, 880, 873, 1135, 1001, 1002, 1003, 0, 1005, + 1009, 0, 1119, 1121, 1011, 1007, 1013, 1130, 1131, 1132, + 0, 0, 0, 0, 0, 1017, 1021, 1026, 1027, 1028, + 1029, 1030, 0, 1031, 0, 1034, 1035, 1036, 1037, 1038, + 1039, 1045, 1429, 1430, 1431, 1064, 303, 304, 0, 1065, + 0, 0, 0, 0, 0, 0, 0, 0, 1376, 1377, + 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, + 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1134, 0, + 1608, 0, 0, 0, 1459, 1456, 0, 0, 0, 1415, + 1417, 0, 0, 0, 893, 894, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1396, 1397, 1398, 1399, 1400, 1401, 1402, + 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, + 1413, 0, 0, 1432, 0, 0, 0, 0, 0, 1452, + 0, 1070, 1071, 1072, 0, 0, 0, 0, 0, 0, + 1194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 144, 145, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1340, 1341, 1342, 1343, + 41, 0, 0, 0, 0, 0, 0, 0, 1463, 0, + -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1365, 0, 0, 0, 0, + 0, 0, 1580, 0, 0, 850, 851, 853, 0, 985, + 0, 966, 0, 0, 856, 0, 897, 0, 900, 62, + 64, 906, 907, 0, 924, 913, 905, 58, 53, 0, + 0, 943, 1530, 1533, 1534, 376, 1556, 0, 385, 385, + 382, 1491, 1492, 0, 1484, 1486, 1487, 81, 921, 917, + 0, 999, 0, 0, 980, 0, 927, 929, 930, 931, + 963, 0, 934, 935, 0, 0, 0, 0, 0, 100, + 982, 106, 0, 114, 0, 0, 119, 120, 107, 108, + 109, 110, 0, 609, -2, 462, 181, 183, 184, 185, + 176, -2, 374, 372, 373, 313, 376, 376, 339, 340, + 341, 342, 343, 344, 0, 0, 332, 333, 334, 335, + 324, 0, 325, 326, 327, 366, 0, 328, 329, 0, + 330, 429, 0, 1493, 392, 393, 395, 403, 0, 398, + 399, 0, 403, 403, 0, 424, 425, 0, 1485, 1510, + 0, 0, 0, 1610, 1609, 1609, 1609, 0, 169, 170, + 171, 172, 173, 174, 645, 0, 0, 621, 643, 644, + 167, 0, 0, 177, 518, 517, 0, 677, 0, 427, + 0, 0, 421, 421, 406, 407, 559, 0, 0, 652, + 653, 654, 655, 0, 0, 0, 545, 456, 0, 546, + 547, 516, 518, 0, 0, 387, 470, 471, 476, 477, + 496, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 594, 595, 596, 599, 601, 520, 605, + 607, 598, 600, 602, 520, 606, 608, 1507, 1508, 1509, + 0, 0, 715, 0, 0, 453, 96, 1598, 720, 724, + 725, 785, 743, 777, 785, 735, 742, 765, 810, 811, + 816, 824, 825, 826, 864, 0, 0, 0, 0, 872, + 0, 0, 1010, 1120, 1122, 1014, 0, 1018, 1022, 0, + 0, 0, 0, 0, 1069, 1067, 1463, 0, 0, 0, + 1116, 0, 0, 1138, 1139, 0, 0, 0, 0, 1457, + 0, 0, 1146, 0, 1418, 1156, 0, 0, 0, 0, + 0, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, + 1171, 1479, 1173, 0, 0, 0, 0, 0, 1178, 1179, + 1180, 1181, 1182, 0, 1184, 0, 1185, 0, 0, 0, + 0, 1192, 1193, 1195, 0, 0, 1198, 1199, 0, 1201, + 0, 1203, 1204, 1205, 1206, 1207, 1208, 0, 1210, 0, + 1212, 1213, 1214, 0, 1216, 0, 1218, 1219, 0, 1221, + 0, 1223, 0, 1226, 0, 1229, 0, 1232, 0, 1235, + 0, 1238, 0, 1241, 0, 1244, 0, 1247, 0, 1250, + 0, 1253, 0, 1256, 0, 1259, 0, 1262, 0, 1265, + 0, 1268, 0, 1271, 1272, 1273, 0, 1275, 0, 1277, + 0, 1280, 1281, 0, 1283, 0, 1286, 0, 1289, 0, + 0, 1290, 0, 0, 0, 1294, 0, 0, 0, 0, + 1303, 1304, 1305, 1306, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1317, 1318, 1319, 1320, 1321, 1322, + 0, 1324, 0, 1098, 0, 0, 1098, 0, 0, 0, + 0, 0, 1136, 1607, 0, 1419, 1420, 1421, 1422, 1423, + 0, 0, 0, 0, 0, 0, 1363, 1364, 1366, 0, + 0, 1369, 0, 1371, 0, 1581, 849, 852, 854, 937, + 986, 987, 0, 0, 0, 0, 967, 1606, 895, 896, + 899, 945, 0, 1467, 0, 0, 924, 999, 0, 925, + 0, 55, 940, 0, 1538, 1537, 1550, 1563, 385, 385, + 379, 380, 386, 381, 383, 384, 1483, 0, 1488, 0, + 1574, 0, 0, 1566, 0, 0, 0, 0, 0, 0, + 0, 0, 970, 0, 0, 973, 0, 0, 0, 0, + 964, 935, 0, 936, 0, -2, 0, 0, 94, 95, + 0, 0, 0, 117, 118, 0, 0, 124, 388, 389, + 158, 167, 464, 182, 437, 0, 0, 309, 375, 336, + 337, 338, 0, 360, 0, 0, 0, 0, 458, 130, + 1497, 1496, 403, 403, 394, 0, 397, 0, 0, 0, + 1611, 363, 426, 0, 148, 0, 0, 0, 0, 0, + 154, 615, 0, 0, 622, 0, 0, 0, 527, 0, + 538, 539, 0, 649, -2, 711, 391, 0, 405, 408, + 952, 0, 0, 540, 0, 543, 544, 457, 518, 549, + 550, 564, 551, 499, 500, 497, 0, 0, 1520, 1521, + 1526, 1524, 1525, 135, 585, 587, 591, 586, 590, 0, + 0, 0, 522, 0, 522, 583, 0, 453, 1493, 0, + 719, 454, 455, 788, 788, 859, 99, 0, 862, 0, + 0, 0, 0, 1015, 1019, 1032, 1033, 1424, 1450, 362, + 362, 1437, 362, 368, 1440, 362, 1442, 362, 1445, 362, + 1448, 1449, 0, 0, 1062, 0, 0, 0, 0, 1145, + 1460, 0, 0, 1157, 1158, 1159, 1160, 1161, 1454, 0, + 0, 0, 1177, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 146, 147, 0, 0, 0, 0, 0, + 0, 1374, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1093, 1097, 0, 1099, 1100, 0, 0, + 1326, 0, 0, 1344, 0, 0, 0, 0, 0, 0, + 0, 1464, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 988, 995, 0, 995, 0, 995, 0, 0, + 0, 1593, 1594, 1468, 1469, 999, 1470, 914, 926, 944, + 1556, 0, 1549, 0, -2, 1558, 0, 0, 0, 1564, + 377, 378, 918, 82, 1000, 85, 0, 1574, 1583, 0, + 1565, 1576, 1578, 0, 0, 0, 1570, 0, 999, 928, + 959, 961, 0, 956, 971, 972, 974, 0, 976, 0, + 978, 979, 939, 933, 0, 102, 0, 999, 999, 101, + 0, 984, 121, 122, 123, 463, 186, 191, 0, 0, + 0, 196, 0, 198, 0, 0, 0, 203, 204, 403, + 403, 438, 0, 306, 308, 0, 0, 189, 376, 0, + 376, 0, 367, 369, 0, 439, 459, 1494, 1495, 0, + 0, 396, 400, 401, 402, 0, 1600, 150, 0, 0, + 0, 618, 0, 646, 0, 0, 0, 0, 0, 0, + 178, 519, 678, 679, 680, 681, 682, 683, 684, 685, + 686, 0, 403, 0, 0, 0, 403, 403, 403, 0, + 703, 390, 0, 0, 674, 671, 541, 0, 220, 221, + 228, 229, 231, 0, 0, 0, 0, 0, 548, 939, + 1511, 1512, 1513, 0, 1523, 1527, 138, 0, 0, 0, + 0, 593, 597, 603, 0, 521, 604, 716, 717, 718, + 97, 728, 734, 861, 881, 1008, 1016, 1020, 0, 0, + 0, 0, 1451, 1435, 376, 1438, 1439, 1441, 1443, 1444, + 1446, 1447, 1058, 1059, 1063, 0, 1142, 0, 1144, 0, + 1458, 0, 1488, 0, 0, 0, 1176, 0, 0, 0, + 1187, 1186, 1188, 0, 1190, 1191, 1196, 1197, 1200, 1202, + 1209, 1211, 1215, 1217, 1220, 1222, 1224, 0, 1227, 0, + 1230, 0, 1233, 0, 1236, 0, 1239, 0, 1242, 0, + 1245, 0, 1248, 0, 1251, 0, 1254, 0, 1257, 0, + 1260, 0, 1263, 0, 1266, 0, 1269, 0, 1274, 1276, + 0, 1279, 1282, 1284, 0, 1287, 0, 1291, 0, 1293, + 1295, 1296, 0, 0, 0, 1307, 1308, 1309, 1310, 1311, + 1312, 1313, 1314, 1315, 1316, 1323, 0, 1091, 1094, 1325, + 1101, 1102, 1107, 1328, 0, 0, 0, 1331, 0, 0, + 0, 1335, 1137, 1346, 0, 1351, 0, 0, 1357, 0, + 1361, 0, 1367, 1368, 1370, 1372, 0, 0, 0, 0, + 0, 0, 0, 965, 946, 66, 1470, 1472, 0, 1543, + 1541, 1541, 1551, 1552, 0, 0, 1559, 0, 0, 0, + 0, 86, 0, 0, 0, 1579, 0, 0, 0, 0, + 103, 1479, 953, 960, 0, 0, 954, 0, 955, 975, + 977, 932, 0, 999, 999, 92, 93, 0, 192, 0, + 194, 0, 197, 199, 200, 201, 207, 208, 209, 202, + 0, 0, 305, 307, 0, 0, 350, 361, 351, 0, + 0, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 939, + 151, 152, 153, 610, 0, 620, 0, 941, 0, 613, + 0, 530, 0, 0, 0, 403, 403, 403, 0, 0, + 0, 0, 688, 0, 0, 651, 0, 659, 0, 0, + 0, 232, 233, 0, 1522, 584, 0, 136, 137, 0, + 0, 589, 523, 524, 1056, 0, 0, 0, 1057, 1436, + 0, 0, 0, 0, 0, 1455, 0, 0, 0, 0, + 1183, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1299, 0, 0, 0, 640, 641, 0, + 1375, 1096, 1479, 0, 1098, 1108, 1109, 0, 1098, 1345, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 996, 0, 0, 0, 947, 948, 0, 0, 0, + 985, 1472, 1477, 0, 0, 1546, 0, 1539, 1542, 1540, + 1553, 0, 0, 1560, 0, 1562, 0, 1584, 1585, 1577, + 0, 1569, 1572, 1568, 1571, 1488, 957, 0, 962, 0, + 1479, 91, 0, 195, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 205, 206, 0, 0, 365, 370, 0, + 0, 0, 611, 0, 942, 623, 614, 0, 701, 0, + 705, 0, 0, 0, 708, 709, 710, 687, 0, 691, + 431, 675, 672, 673, 542, 0, 139, 140, 0, 0, + 0, 1425, 0, 1428, 1140, 1143, 1141, 0, 1172, 1174, + 1175, 1433, 1434, 1189, 1225, 1228, 1231, 1234, 1237, 1240, + 1243, 1246, 1249, 1252, 1255, 1258, 1261, 1264, 1267, 1270, + 1278, 1285, 1288, 1292, 1297, 0, 1300, 0, 0, 1301, + 0, 642, 1087, 0, 0, 1105, 1106, 0, 1330, 1332, + 1333, 1334, 1347, 0, 1352, 1353, 0, 1358, 0, 1362, + 1373, 0, 990, 997, 998, 0, 993, 0, 994, 0, + 938, 1477, 84, 1478, 1475, 0, 1473, 1471, 1535, 0, + 1544, 1545, 1554, 1555, 1561, 0, 1567, 0, 89, 0, + 0, 0, 1488, 193, 0, 212, 0, 619, 0, 622, + 612, 699, 700, 0, 712, 704, 706, 707, 689, -2, + 1514, 0, 0, 0, 592, 1426, 0, 0, 1302, 0, + 638, 639, 1095, 1088, 0, 1073, 1074, 1092, 1327, 1329, + 0, 0, 0, 989, 949, 950, 991, 992, 83, 0, + 1474, 1113, 0, 1547, 1548, 1575, 1573, 958, 965, 0, + 90, 444, 437, 1514, 0, 0, 0, 692, 693, 694, + 695, 696, 697, 698, 581, 1516, 141, 142, 0, 511, + 512, 513, 135, 0, 1147, 1298, 1089, 0, 0, 0, + 0, 0, 1348, 0, 1354, 0, 1359, 0, 1476, 0, + 0, 624, 0, 626, 0, -2, 432, 445, 0, 187, + 213, 214, 0, 0, 217, 218, 219, 210, 211, 131, + 0, 0, 713, 0, 1517, 1518, 0, 138, 0, 0, + 1080, 1081, 1082, 1083, 1085, 0, 0, 0, 0, 1114, + 1093, 625, 0, 0, 387, 0, 635, 433, 434, 0, + 440, 441, 442, 443, 215, 216, 647, 0, 0, 510, + 588, 1427, 0, 0, 1349, 0, 1355, 0, 1360, 0, + 627, 628, 636, 0, 435, 0, 436, 0, 0, 0, + 616, 0, 647, 1515, 1090, 1084, 1086, 0, 0, 1112, + 0, 637, 633, 446, 448, 449, 0, 0, 447, 648, + 617, 1350, 1356, 0, 450, 451, 452, 629, 630, 631, + 632, } var yyTok1 = [...]int{ @@ -16799,547 +16740,531 @@ yydefault: yyVAL.union = yyLOCAL case 902: yyDollar = yyS[yypt-0 : yypt+1] - var yyLOCAL SelectExprs //line sql.y:4797 { - yyLOCAL = nil + yyVAL.strs = nil } - yyVAL.union = yyLOCAL case 903: yyDollar = yyS[yypt-1 : yypt+1] - var yyLOCAL SelectExprs //line sql.y:4801 - { - yyLOCAL = yyDollar[1].selectExprsUnion() - } - yyVAL.union = yyLOCAL - case 904: - yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4806 - { - yyVAL.strs = nil - } - case 905: - yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4810 { yyVAL.strs = yyDollar[1].strs } - case 906: + case 904: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4816 +//line sql.y:4807 { yyVAL.strs = []string{yyDollar[1].str} } - case 907: + case 905: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4820 +//line sql.y:4811 { yyVAL.strs = append(yyDollar[1].strs, yyDollar[2].str) } - case 908: + case 906: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4826 +//line sql.y:4817 { yyVAL.str = SQLNoCacheStr } - case 909: + case 907: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4830 +//line sql.y:4821 { yyVAL.str = SQLCacheStr } - case 910: + case 908: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4834 +//line sql.y:4825 { yyVAL.str = DistinctStr } - case 911: + case 909: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4838 +//line sql.y:4829 { yyVAL.str = DistinctStr } - case 912: + case 910: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4842 +//line sql.y:4833 { yyVAL.str = StraightJoinHint } - case 913: + case 911: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4846 +//line sql.y:4837 { yyVAL.str = SQLCalcFoundRowsStr } - case 914: + case 912: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4850 +//line sql.y:4841 { yyVAL.str = AllStr // These are not picked up by NewSelect, and so ALL will be dropped. But this is OK, since it's redundant anyway } - case 915: + case 913: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectExprs -//line sql.y:4856 +//line sql.y:4847 { yyLOCAL = SelectExprs{yyDollar[1].selectExprUnion()} } yyVAL.union = yyLOCAL - case 916: + case 914: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4860 +//line sql.y:4851 { yySLICE := (*SelectExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].selectExprUnion()) } - case 917: + case 915: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4866 +//line sql.y:4857 { yyLOCAL = &StarExpr{} } yyVAL.union = yyLOCAL - case 918: + case 916: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4870 +//line sql.y:4861 { yyLOCAL = &AliasedExpr{Expr: yyDollar[1].exprUnion(), As: yyDollar[2].identifierCI} } yyVAL.union = yyLOCAL - case 919: + case 917: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4874 +//line sql.y:4865 { yyLOCAL = &StarExpr{TableName: TableName{Name: yyDollar[1].identifierCS}} } yyVAL.union = yyLOCAL - case 920: + case 918: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4878 +//line sql.y:4869 { yyLOCAL = &StarExpr{TableName: TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS}} } yyVAL.union = yyLOCAL - case 921: + case 919: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4883 +//line sql.y:4874 { yyVAL.identifierCI = IdentifierCI{} } - case 922: + case 920: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4887 +//line sql.y:4878 { yyVAL.identifierCI = yyDollar[1].identifierCI } - case 923: + case 921: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4891 +//line sql.y:4882 { yyVAL.identifierCI = yyDollar[2].identifierCI } - case 925: + case 923: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4898 +//line sql.y:4889 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } - case 926: + case 924: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4903 +//line sql.y:4894 { yyLOCAL = TableExprs{&AliasedTableExpr{Expr: TableName{Name: NewIdentifierCS("dual")}}} } yyVAL.union = yyLOCAL - case 927: + case 925: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4907 +//line sql.y:4898 { yyLOCAL = yyDollar[1].tableExprsUnion() } yyVAL.union = yyLOCAL - case 928: + case 926: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4913 +//line sql.y:4904 { yyLOCAL = yyDollar[2].tableExprsUnion() } yyVAL.union = yyLOCAL - case 929: + case 927: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4919 +//line sql.y:4910 { yyLOCAL = TableExprs{yyDollar[1].tableExprUnion()} } yyVAL.union = yyLOCAL - case 930: + case 928: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4923 +//line sql.y:4914 { yySLICE := (*TableExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableExprUnion()) } - case 933: + case 931: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4933 +//line sql.y:4924 { yyLOCAL = yyDollar[1].aliasedTableNameUnion() } yyVAL.union = yyLOCAL - case 934: + case 932: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4937 +//line sql.y:4928 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].derivedTableUnion(), As: yyDollar[3].identifierCS, Columns: yyDollar[4].columnsUnion()} } yyVAL.union = yyLOCAL - case 935: + case 933: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4941 +//line sql.y:4932 { yyLOCAL = &ParenTableExpr{Exprs: yyDollar[2].tableExprsUnion()} } yyVAL.union = yyLOCAL - case 936: + case 934: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4945 +//line sql.y:4936 { yyLOCAL = yyDollar[1].tableExprUnion() } yyVAL.union = yyLOCAL - case 937: + case 935: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *DerivedTable -//line sql.y:4951 +//line sql.y:4942 { yyLOCAL = &DerivedTable{Lateral: false, Select: yyDollar[1].selStmtUnion()} } yyVAL.union = yyLOCAL - case 938: + case 936: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *DerivedTable -//line sql.y:4955 +//line sql.y:4946 { yyLOCAL = &DerivedTable{Lateral: true, Select: yyDollar[2].selStmtUnion()} } yyVAL.union = yyLOCAL - case 939: + case 937: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *AliasedTableExpr -//line sql.y:4961 +//line sql.y:4952 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].tableName, As: yyDollar[2].identifierCS, Hints: yyDollar[3].indexHintsUnion()} } yyVAL.union = yyLOCAL - case 940: + case 938: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *AliasedTableExpr -//line sql.y:4965 +//line sql.y:4956 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].tableName, Partitions: yyDollar[4].partitionsUnion(), As: yyDollar[6].identifierCS, Hints: yyDollar[7].indexHintsUnion()} } yyVAL.union = yyLOCAL - case 941: + case 939: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Columns -//line sql.y:4970 +//line sql.y:4961 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 942: + case 940: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Columns -//line sql.y:4974 +//line sql.y:4965 { yyLOCAL = yyDollar[2].columnsUnion() } yyVAL.union = yyLOCAL - case 943: + case 941: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Columns -//line sql.y:4979 +//line sql.y:4970 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 944: + case 942: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:4983 +//line sql.y:4974 { yyLOCAL = yyDollar[1].columnsUnion() } yyVAL.union = yyLOCAL - case 945: + case 943: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:4989 +//line sql.y:4980 { yyLOCAL = Columns{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 946: + case 944: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4993 +//line sql.y:4984 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 947: + case 945: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*Variable -//line sql.y:4999 +//line sql.y:4990 { yyLOCAL = []*Variable{yyDollar[1].variableUnion()} } yyVAL.union = yyLOCAL - case 948: + case 946: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5003 +//line sql.y:4994 { yySLICE := (*[]*Variable)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].variableUnion()) } - case 949: + case 947: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5009 +//line sql.y:5000 { yyLOCAL = Columns{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 950: + case 948: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5013 +//line sql.y:5004 { yyLOCAL = Columns{NewIdentifierCI(string(yyDollar[1].str))} } yyVAL.union = yyLOCAL - case 951: + case 949: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5017 +//line sql.y:5008 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 952: + case 950: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5021 +//line sql.y:5012 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, NewIdentifierCI(string(yyDollar[3].str))) } - case 953: + case 951: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Partitions -//line sql.y:5027 +//line sql.y:5018 { yyLOCAL = Partitions{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 954: + case 952: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5031 +//line sql.y:5022 { yySLICE := (*Partitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 955: + case 953: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5044 +//line sql.y:5035 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } yyVAL.union = yyLOCAL - case 956: + case 954: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5048 +//line sql.y:5039 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } yyVAL.union = yyLOCAL - case 957: + case 955: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5052 +//line sql.y:5043 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } yyVAL.union = yyLOCAL - case 958: + case 956: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5056 +//line sql.y:5047 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion()} } yyVAL.union = yyLOCAL - case 959: + case 957: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5062 +//line sql.y:5053 { yyVAL.joinCondition = &JoinCondition{On: yyDollar[2].exprUnion()} } - case 960: + case 958: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5064 +//line sql.y:5055 { yyVAL.joinCondition = &JoinCondition{Using: yyDollar[3].columnsUnion()} } - case 961: + case 959: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5068 +//line sql.y:5059 { yyVAL.joinCondition = &JoinCondition{} } - case 962: + case 960: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5070 +//line sql.y:5061 { yyVAL.joinCondition = yyDollar[1].joinCondition } - case 963: + case 961: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5074 +//line sql.y:5065 { yyVAL.joinCondition = &JoinCondition{} } - case 964: + case 962: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5076 +//line sql.y:5067 { yyVAL.joinCondition = &JoinCondition{On: yyDollar[2].exprUnion()} } - case 965: + case 963: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5079 +//line sql.y:5070 { yyVAL.empty = struct{}{} } - case 966: + case 964: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5081 +//line sql.y:5072 { yyVAL.empty = struct{}{} } - case 967: + case 965: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5084 +//line sql.y:5075 { yyVAL.identifierCS = NewIdentifierCS("") } - case 968: + case 966: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5088 +//line sql.y:5079 { yyVAL.identifierCS = yyDollar[1].identifierCS } - case 969: + case 967: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5092 +//line sql.y:5083 { yyVAL.identifierCS = yyDollar[2].identifierCS } - case 971: + case 969: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5099 +//line sql.y:5090 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 972: + case 970: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL JoinType -//line sql.y:5105 +//line sql.y:5096 { yyLOCAL = NormalJoinType } yyVAL.union = yyLOCAL - case 973: + case 971: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5109 +//line sql.y:5100 { yyLOCAL = NormalJoinType } yyVAL.union = yyLOCAL - case 974: + case 972: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5113 +//line sql.y:5104 { yyLOCAL = NormalJoinType } yyVAL.union = yyLOCAL - case 975: + case 973: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL JoinType -//line sql.y:5119 +//line sql.y:5110 { yyLOCAL = StraightJoinType } yyVAL.union = yyLOCAL - case 976: + case 974: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5125 +//line sql.y:5116 { yyLOCAL = LeftJoinType } yyVAL.union = yyLOCAL - case 977: + case 975: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL JoinType -//line sql.y:5129 +//line sql.y:5120 { yyLOCAL = LeftJoinType } yyVAL.union = yyLOCAL - case 978: + case 976: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5133 +//line sql.y:5124 { yyLOCAL = RightJoinType } yyVAL.union = yyLOCAL - case 979: + case 977: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL JoinType -//line sql.y:5137 +//line sql.y:5128 { yyLOCAL = RightJoinType } yyVAL.union = yyLOCAL - case 980: + case 978: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5143 +//line sql.y:5134 { yyLOCAL = NaturalJoinType } yyVAL.union = yyLOCAL - case 981: + case 979: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5147 +//line sql.y:5138 { if yyDollar[2].joinTypeUnion() == LeftJoinType { yyLOCAL = NaturalLeftJoinType @@ -17348,633 +17273,633 @@ yydefault: } } yyVAL.union = yyLOCAL - case 982: + case 980: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5157 +//line sql.y:5148 { yyVAL.tableName = yyDollar[2].tableName } - case 983: + case 981: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5161 +//line sql.y:5152 { yyVAL.tableName = yyDollar[1].tableName } - case 984: + case 982: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5167 +//line sql.y:5158 { yyVAL.tableName = TableName{Name: yyDollar[1].identifierCS} } - case 985: + case 983: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5171 +//line sql.y:5162 { yyVAL.tableName = TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS} } - case 986: + case 984: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5177 +//line sql.y:5168 { yyVAL.tableName = TableName{Name: yyDollar[1].identifierCS} } - case 987: + case 985: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5182 +//line sql.y:5173 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 988: + case 986: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5186 +//line sql.y:5177 { yyLOCAL = yyDollar[1].indexHintsUnion() } yyVAL.union = yyLOCAL - case 989: + case 987: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5192 +//line sql.y:5183 { yyLOCAL = IndexHints{yyDollar[1].indexHintUnion()} } yyVAL.union = yyLOCAL - case 990: + case 988: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5196 +//line sql.y:5187 { yySLICE := (*IndexHints)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].indexHintUnion()) } - case 991: + case 989: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5202 +//line sql.y:5193 { yyLOCAL = &IndexHint{Type: UseOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } yyVAL.union = yyLOCAL - case 992: + case 990: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5206 +//line sql.y:5197 { yyLOCAL = &IndexHint{Type: UseOp, ForType: yyDollar[3].indexHintForTypeUnion()} } yyVAL.union = yyLOCAL - case 993: + case 991: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5210 +//line sql.y:5201 { yyLOCAL = &IndexHint{Type: IgnoreOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } yyVAL.union = yyLOCAL - case 994: + case 992: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5214 +//line sql.y:5205 { yyLOCAL = &IndexHint{Type: ForceOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } yyVAL.union = yyLOCAL - case 995: + case 993: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5218 +//line sql.y:5209 { yyLOCAL = &IndexHint{Type: UseVindexOp, Indexes: yyDollar[4].columnsUnion()} } yyVAL.union = yyLOCAL - case 996: + case 994: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5222 +//line sql.y:5213 { yyLOCAL = &IndexHint{Type: IgnoreVindexOp, Indexes: yyDollar[4].columnsUnion()} } yyVAL.union = yyLOCAL - case 997: + case 995: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5227 +//line sql.y:5218 { yyLOCAL = NoForType } yyVAL.union = yyLOCAL - case 998: + case 996: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5231 +//line sql.y:5222 { yyLOCAL = JoinForType } yyVAL.union = yyLOCAL - case 999: + case 997: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5235 +//line sql.y:5226 { yyLOCAL = OrderByForType } yyVAL.union = yyLOCAL - case 1000: + case 998: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5239 +//line sql.y:5230 { yyLOCAL = GroupByForType } yyVAL.union = yyLOCAL - case 1001: + case 999: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:5245 +//line sql.y:5236 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1002: + case 1000: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5249 +//line sql.y:5240 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1003: + case 1001: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5256 +//line sql.y:5247 { yyLOCAL = &OrExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1004: + case 1002: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5260 +//line sql.y:5251 { yyLOCAL = &XorExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1005: + case 1003: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5264 +//line sql.y:5255 { yyLOCAL = &AndExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1006: + case 1004: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5268 +//line sql.y:5259 { yyLOCAL = &NotExpr{Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1007: + case 1005: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5272 +//line sql.y:5263 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].isExprOperatorUnion()} } yyVAL.union = yyLOCAL - case 1008: + case 1006: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5276 +//line sql.y:5267 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1009: + case 1007: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5280 +//line sql.y:5271 { yyLOCAL = &AssignmentExpr{Left: yyDollar[1].variableUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1010: + case 1008: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5284 +//line sql.y:5275 { yyLOCAL = &MemberOfExpr{Value: yyDollar[1].exprUnion(), JSONArr: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1011: + case 1009: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5290 +//line sql.y:5281 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: IsNullOp} } yyVAL.union = yyLOCAL - case 1012: + case 1010: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5294 +//line sql.y:5285 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: IsNotNullOp} } yyVAL.union = yyLOCAL - case 1013: + case 1011: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5298 +//line sql.y:5289 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: yyDollar[2].comparisonExprOperatorUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1014: + case 1012: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5302 +//line sql.y:5293 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1015: + case 1013: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5308 +//line sql.y:5299 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: InOp, Right: yyDollar[3].colTupleUnion()} } yyVAL.union = yyLOCAL - case 1016: + case 1014: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5312 +//line sql.y:5303 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotInOp, Right: yyDollar[4].colTupleUnion()} } yyVAL.union = yyLOCAL - case 1017: + case 1015: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5316 +//line sql.y:5307 { yyLOCAL = &BetweenExpr{Left: yyDollar[1].exprUnion(), IsBetween: true, From: yyDollar[3].exprUnion(), To: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1018: + case 1016: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5320 +//line sql.y:5311 { yyLOCAL = &BetweenExpr{Left: yyDollar[1].exprUnion(), IsBetween: false, From: yyDollar[4].exprUnion(), To: yyDollar[6].exprUnion()} } yyVAL.union = yyLOCAL - case 1019: + case 1017: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5324 +//line sql.y:5315 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: LikeOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1020: + case 1018: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5328 +//line sql.y:5319 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotLikeOp, Right: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1021: + case 1019: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5332 +//line sql.y:5323 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: LikeOp, Right: yyDollar[3].exprUnion(), Escape: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1022: + case 1020: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5336 +//line sql.y:5327 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotLikeOp, Right: yyDollar[4].exprUnion(), Escape: yyDollar[6].exprUnion()} } yyVAL.union = yyLOCAL - case 1023: + case 1021: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5340 +//line sql.y:5331 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: RegexpOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1024: + case 1022: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5344 +//line sql.y:5335 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotRegexpOp, Right: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1025: + case 1023: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5348 +//line sql.y:5339 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1026: + case 1024: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5354 +//line sql.y:5345 { } - case 1027: + case 1025: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5357 +//line sql.y:5348 { } - case 1028: + case 1026: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5363 +//line sql.y:5354 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitOrOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1029: + case 1027: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5367 +//line sql.y:5358 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitAndOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1030: + case 1028: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5371 +//line sql.y:5362 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ShiftLeftOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1031: + case 1029: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5375 +//line sql.y:5366 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ShiftRightOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1032: + case 1030: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5379 +//line sql.y:5370 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: PlusOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1033: + case 1031: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5383 +//line sql.y:5374 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: MinusOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1034: + case 1032: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5387 +//line sql.y:5378 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinaryAdd, Date: yyDollar[1].exprUnion(), Unit: yyDollar[5].intervalTypeUnion(), Interval: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1035: + case 1033: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5391 +//line sql.y:5382 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinarySub, Date: yyDollar[1].exprUnion(), Unit: yyDollar[5].intervalTypeUnion(), Interval: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1036: + case 1034: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5395 +//line sql.y:5386 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: MultOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1037: + case 1035: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5399 +//line sql.y:5390 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: DivOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1038: + case 1036: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5403 +//line sql.y:5394 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ModOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1039: + case 1037: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5407 +//line sql.y:5398 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: IntDivOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1040: + case 1038: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5411 +//line sql.y:5402 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ModOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1041: + case 1039: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5415 +//line sql.y:5406 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitXorOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1042: + case 1040: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5419 +//line sql.y:5410 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1043: + case 1041: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5425 +//line sql.y:5416 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1044: + case 1042: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5429 +//line sql.y:5420 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1045: + case 1043: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5433 +//line sql.y:5424 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1046: + case 1044: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5437 +//line sql.y:5428 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1047: + case 1045: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5441 +//line sql.y:5432 { yyLOCAL = &CollateExpr{Expr: yyDollar[1].exprUnion(), Collation: yyDollar[3].str} } yyVAL.union = yyLOCAL - case 1048: + case 1046: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5445 +//line sql.y:5436 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1049: + case 1047: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5449 +//line sql.y:5440 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1050: + case 1048: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5453 +//line sql.y:5444 { yyLOCAL = yyDollar[1].variableUnion() } yyVAL.union = yyLOCAL - case 1051: + case 1049: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5457 +//line sql.y:5448 { yyLOCAL = yyDollar[2].exprUnion() // TODO: do we really want to ignore unary '+' before any kind of literals? } yyVAL.union = yyLOCAL - case 1052: + case 1050: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5461 +//line sql.y:5452 { yyLOCAL = &UnaryExpr{Operator: UMinusOp, Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1053: + case 1051: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5465 +//line sql.y:5456 { yyLOCAL = &UnaryExpr{Operator: TildaOp, Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1054: + case 1052: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5469 +//line sql.y:5460 { yyLOCAL = &UnaryExpr{Operator: BangOp, Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1055: + case 1053: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5473 +//line sql.y:5464 { yyLOCAL = yyDollar[1].subqueryUnion() } yyVAL.union = yyLOCAL - case 1056: + case 1054: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5477 +//line sql.y:5468 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1057: + case 1055: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5481 +//line sql.y:5472 { yyLOCAL = &ExistsExpr{Subquery: yyDollar[2].subqueryUnion()} } yyVAL.union = yyLOCAL - case 1058: + case 1056: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:5485 +//line sql.y:5476 { yyLOCAL = &MatchExpr{Columns: yyDollar[2].colNamesUnion(), Expr: yyDollar[5].exprUnion(), Option: yyDollar[6].matchExprOptionUnion()} } yyVAL.union = yyLOCAL - case 1059: + case 1057: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:5489 +//line sql.y:5480 { yyLOCAL = &CastExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].convertTypeUnion(), Array: yyDollar[6].booleanUnion()} } yyVAL.union = yyLOCAL - case 1060: + case 1058: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5493 +//line sql.y:5484 { yyLOCAL = &ConvertExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].convertTypeUnion()} } yyVAL.union = yyLOCAL - case 1061: + case 1059: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5497 +//line sql.y:5488 { yyLOCAL = &ConvertUsingExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].str} } yyVAL.union = yyLOCAL - case 1062: + case 1060: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5501 +//line sql.y:5492 { // From: https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#operator_binary // To convert a string expression to a binary string, these constructs are equivalent: @@ -17983,3177 +17908,3177 @@ yydefault: yyLOCAL = &ConvertExpr{Expr: yyDollar[2].exprUnion(), Type: &ConvertType{Type: yyDollar[1].str}} } yyVAL.union = yyLOCAL - case 1063: + case 1061: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5509 +//line sql.y:5500 { yyLOCAL = &Default{ColName: yyDollar[2].str} } yyVAL.union = yyLOCAL - case 1064: + case 1062: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5513 +//line sql.y:5504 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinaryAddLeft, Date: yyDollar[5].exprUnion(), Unit: yyDollar[3].intervalTypeUnion(), Interval: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1065: + case 1063: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5517 +//line sql.y:5508 { yyLOCAL = &IntervalFuncExpr{Expr: yyDollar[3].exprUnion(), Exprs: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1066: + case 1064: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5521 +//line sql.y:5512 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: JSONExtractOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1067: + case 1065: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5525 +//line sql.y:5516 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: JSONUnquoteExtractOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1068: + case 1066: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5531 +//line sql.y:5522 { yyLOCAL = yyDollar[1].colNamesUnion() } yyVAL.union = yyLOCAL - case 1069: + case 1067: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5535 +//line sql.y:5526 { yyLOCAL = yyDollar[2].colNamesUnion() } yyVAL.union = yyLOCAL - case 1070: + case 1068: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5541 +//line sql.y:5532 { yyLOCAL = []*ColName{yyDollar[1].colNameUnion()} } yyVAL.union = yyLOCAL - case 1071: + case 1069: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5545 +//line sql.y:5536 { yySLICE := (*[]*ColName)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].colNameUnion()) } - case 1072: + case 1070: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5551 +//line sql.y:5542 { yyLOCAL = BothTrimType } yyVAL.union = yyLOCAL - case 1073: + case 1071: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5555 +//line sql.y:5546 { yyLOCAL = LeadingTrimType } yyVAL.union = yyLOCAL - case 1074: + case 1072: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5559 +//line sql.y:5550 { yyLOCAL = TrailingTrimType } yyVAL.union = yyLOCAL - case 1075: + case 1073: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FrameUnitType -//line sql.y:5565 +//line sql.y:5556 { yyLOCAL = FrameRowsType } yyVAL.union = yyLOCAL - case 1076: + case 1074: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FrameUnitType -//line sql.y:5569 +//line sql.y:5560 { yyLOCAL = FrameRangeType } yyVAL.union = yyLOCAL - case 1077: + case 1075: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5576 +//line sql.y:5567 { yyLOCAL = CumeDistExprType } yyVAL.union = yyLOCAL - case 1078: + case 1076: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5580 +//line sql.y:5571 { yyLOCAL = DenseRankExprType } yyVAL.union = yyLOCAL - case 1079: + case 1077: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5584 +//line sql.y:5575 { yyLOCAL = PercentRankExprType } yyVAL.union = yyLOCAL - case 1080: + case 1078: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5588 +//line sql.y:5579 { yyLOCAL = RankExprType } yyVAL.union = yyLOCAL - case 1081: + case 1079: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5592 +//line sql.y:5583 { yyLOCAL = RowNumberExprType } yyVAL.union = yyLOCAL - case 1082: + case 1080: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5598 +//line sql.y:5589 { yyLOCAL = &FramePoint{Type: CurrentRowType} } yyVAL.union = yyLOCAL - case 1083: + case 1081: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5602 +//line sql.y:5593 { yyLOCAL = &FramePoint{Type: UnboundedPrecedingType} } yyVAL.union = yyLOCAL - case 1084: + case 1082: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5606 +//line sql.y:5597 { yyLOCAL = &FramePoint{Type: UnboundedFollowingType} } yyVAL.union = yyLOCAL - case 1085: + case 1083: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5610 +//line sql.y:5601 { yyLOCAL = &FramePoint{Type: ExprPrecedingType, Expr: yyDollar[1].exprUnion()} } yyVAL.union = yyLOCAL - case 1086: + case 1084: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5614 +//line sql.y:5605 { yyLOCAL = &FramePoint{Type: ExprPrecedingType, Expr: yyDollar[2].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1087: + case 1085: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5618 +//line sql.y:5609 { yyLOCAL = &FramePoint{Type: ExprFollowingType, Expr: yyDollar[1].exprUnion()} } yyVAL.union = yyLOCAL - case 1088: + case 1086: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5622 +//line sql.y:5613 { yyLOCAL = &FramePoint{Type: ExprFollowingType, Expr: yyDollar[2].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1089: + case 1087: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5627 +//line sql.y:5618 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1090: + case 1088: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5631 +//line sql.y:5622 { yyLOCAL = yyDollar[1].frameClauseUnion() } yyVAL.union = yyLOCAL - case 1091: + case 1089: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5637 +//line sql.y:5628 { yyLOCAL = &FrameClause{Unit: yyDollar[1].frameUnitTypeUnion(), Start: yyDollar[2].framePointUnion()} } yyVAL.union = yyLOCAL - case 1092: + case 1090: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5641 +//line sql.y:5632 { yyLOCAL = &FrameClause{Unit: yyDollar[1].frameUnitTypeUnion(), Start: yyDollar[3].framePointUnion(), End: yyDollar[5].framePointUnion()} } yyVAL.union = yyLOCAL - case 1093: + case 1091: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:5646 +//line sql.y:5637 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1094: + case 1092: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Exprs -//line sql.y:5650 +//line sql.y:5641 { yyLOCAL = yyDollar[3].exprsUnion() } yyVAL.union = yyLOCAL - case 1095: + case 1093: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5655 +//line sql.y:5646 { } - case 1096: + case 1094: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5658 +//line sql.y:5649 { yyVAL.identifierCI = yyDollar[1].identifierCI } - case 1097: + case 1095: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *WindowSpecification -//line sql.y:5664 +//line sql.y:5655 { yyLOCAL = &WindowSpecification{Name: yyDollar[1].identifierCI, PartitionClause: yyDollar[2].exprsUnion(), OrderClause: yyDollar[3].orderByUnion(), FrameClause: yyDollar[4].frameClauseUnion()} } yyVAL.union = yyLOCAL - case 1098: + case 1096: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5670 +//line sql.y:5661 { yyLOCAL = &OverClause{WindowSpec: yyDollar[3].windowSpecificationUnion()} } yyVAL.union = yyLOCAL - case 1099: + case 1097: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5674 +//line sql.y:5665 { yyLOCAL = &OverClause{WindowName: yyDollar[2].identifierCI} } yyVAL.union = yyLOCAL - case 1100: + case 1098: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *NullTreatmentClause -//line sql.y:5679 +//line sql.y:5670 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1102: + case 1100: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *NullTreatmentClause -//line sql.y:5686 +//line sql.y:5677 { yyLOCAL = &NullTreatmentClause{yyDollar[1].nullTreatmentTypeUnion()} } yyVAL.union = yyLOCAL - case 1103: + case 1101: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL NullTreatmentType -//line sql.y:5692 +//line sql.y:5683 { yyLOCAL = RespectNullsType } yyVAL.union = yyLOCAL - case 1104: + case 1102: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL NullTreatmentType -//line sql.y:5696 +//line sql.y:5687 { yyLOCAL = IgnoreNullsType } yyVAL.union = yyLOCAL - case 1105: + case 1103: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FirstOrLastValueExprType -//line sql.y:5702 +//line sql.y:5693 { yyLOCAL = FirstValueExprType } yyVAL.union = yyLOCAL - case 1106: + case 1104: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FirstOrLastValueExprType -//line sql.y:5706 +//line sql.y:5697 { yyLOCAL = LastValueExprType } yyVAL.union = yyLOCAL - case 1107: + case 1105: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL FromFirstLastType -//line sql.y:5712 +//line sql.y:5703 { yyLOCAL = FromFirstType } yyVAL.union = yyLOCAL - case 1108: + case 1106: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL FromFirstLastType -//line sql.y:5716 +//line sql.y:5707 { yyLOCAL = FromLastType } yyVAL.union = yyLOCAL - case 1109: + case 1107: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *FromFirstLastClause -//line sql.y:5721 +//line sql.y:5712 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1111: + case 1109: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *FromFirstLastClause -//line sql.y:5728 +//line sql.y:5719 { yyLOCAL = &FromFirstLastClause{yyDollar[1].fromFirstLastTypeUnion()} } yyVAL.union = yyLOCAL - case 1112: + case 1110: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LagLeadExprType -//line sql.y:5734 +//line sql.y:5725 { yyLOCAL = LagExprType } yyVAL.union = yyLOCAL - case 1113: + case 1111: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LagLeadExprType -//line sql.y:5738 +//line sql.y:5729 { yyLOCAL = LeadExprType } yyVAL.union = yyLOCAL - case 1114: + case 1112: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *WindowDefinition -//line sql.y:5744 +//line sql.y:5735 { yyLOCAL = &WindowDefinition{Name: yyDollar[1].identifierCI, WindowSpec: yyDollar[4].windowSpecificationUnion()} } yyVAL.union = yyLOCAL - case 1115: + case 1113: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL WindowDefinitions -//line sql.y:5750 +//line sql.y:5741 { yyLOCAL = WindowDefinitions{yyDollar[1].windowDefinitionUnion()} } yyVAL.union = yyLOCAL - case 1116: + case 1114: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5754 +//line sql.y:5745 { yySLICE := (*WindowDefinitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].windowDefinitionUnion()) } - case 1117: + case 1115: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5760 +//line sql.y:5751 { yyVAL.str = "" } - case 1118: + case 1116: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5764 +//line sql.y:5755 { yyVAL.str = string(yyDollar[2].identifierCI.String()) } - case 1119: + case 1117: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL BoolVal -//line sql.y:5770 +//line sql.y:5761 { yyLOCAL = BoolVal(true) } yyVAL.union = yyLOCAL - case 1120: + case 1118: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL BoolVal -//line sql.y:5774 +//line sql.y:5765 { yyLOCAL = BoolVal(false) } yyVAL.union = yyLOCAL - case 1121: + case 1119: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5781 +//line sql.y:5772 { yyLOCAL = IsTrueOp } yyVAL.union = yyLOCAL - case 1122: + case 1120: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5785 +//line sql.y:5776 { yyLOCAL = IsNotTrueOp } yyVAL.union = yyLOCAL - case 1123: + case 1121: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5789 +//line sql.y:5780 { yyLOCAL = IsFalseOp } yyVAL.union = yyLOCAL - case 1124: + case 1122: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5793 +//line sql.y:5784 { yyLOCAL = IsNotFalseOp } yyVAL.union = yyLOCAL - case 1125: + case 1123: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5799 +//line sql.y:5790 { yyLOCAL = EqualOp } yyVAL.union = yyLOCAL - case 1126: + case 1124: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5803 +//line sql.y:5794 { yyLOCAL = LessThanOp } yyVAL.union = yyLOCAL - case 1127: + case 1125: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5807 +//line sql.y:5798 { yyLOCAL = GreaterThanOp } yyVAL.union = yyLOCAL - case 1128: + case 1126: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5811 +//line sql.y:5802 { yyLOCAL = LessEqualOp } yyVAL.union = yyLOCAL - case 1129: + case 1127: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5815 +//line sql.y:5806 { yyLOCAL = GreaterEqualOp } yyVAL.union = yyLOCAL - case 1130: + case 1128: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5819 +//line sql.y:5810 { yyLOCAL = NotEqualOp } yyVAL.union = yyLOCAL - case 1131: + case 1129: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5823 +//line sql.y:5814 { yyLOCAL = NullSafeEqualOp } yyVAL.union = yyLOCAL - case 1132: + case 1130: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5829 +//line sql.y:5820 { yyLOCAL = yyDollar[1].valTupleUnion() } yyVAL.union = yyLOCAL - case 1133: + case 1131: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5833 +//line sql.y:5824 { yyLOCAL = yyDollar[1].subqueryUnion() } yyVAL.union = yyLOCAL - case 1134: + case 1132: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5837 +//line sql.y:5828 { yyLOCAL = ListArg(yyDollar[1].str[2:]) markBindVariable(yylex, yyDollar[1].str[2:]) } yyVAL.union = yyLOCAL - case 1135: + case 1133: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Subquery -//line sql.y:5844 +//line sql.y:5835 { yyLOCAL = &Subquery{yyDollar[1].selStmtUnion()} } yyVAL.union = yyLOCAL - case 1136: + case 1134: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Exprs -//line sql.y:5850 +//line sql.y:5841 { yyLOCAL = Exprs{yyDollar[1].exprUnion()} } yyVAL.union = yyLOCAL - case 1137: + case 1135: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5854 +//line sql.y:5845 { yySLICE := (*Exprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].exprUnion()) } - case 1138: + case 1136: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5864 +//line sql.y:5855 { - yyLOCAL = &FuncExpr{Name: yyDollar[1].identifierCI, Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: yyDollar[1].identifierCI, Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1139: + case 1137: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5868 +//line sql.y:5859 { - yyLOCAL = &FuncExpr{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCI, Exprs: yyDollar[5].selectExprsUnion()} + yyLOCAL = &FuncExpr{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCI, Exprs: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1140: + case 1138: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5878 +//line sql.y:5869 { - yyLOCAL = &FuncExpr{Name: NewIdentifierCI("left"), Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: NewIdentifierCI("left"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1141: + case 1139: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5882 +//line sql.y:5873 { - yyLOCAL = &FuncExpr{Name: NewIdentifierCI("right"), Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: NewIdentifierCI("right"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1142: + case 1140: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5886 +//line sql.y:5877 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1143: + case 1141: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5890 +//line sql.y:5881 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1144: + case 1142: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5894 +//line sql.y:5885 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1145: + case 1143: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5898 +//line sql.y:5889 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1146: + case 1144: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5902 +//line sql.y:5893 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1147: + case 1145: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5906 +//line sql.y:5897 { yyLOCAL = &CaseExpr{Expr: yyDollar[2].exprUnion(), Whens: yyDollar[3].whensUnion(), Else: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1148: + case 1146: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5910 +//line sql.y:5901 { yyLOCAL = &ValuesFuncExpr{Name: yyDollar[3].colNameUnion()} } yyVAL.union = yyLOCAL - case 1149: + case 1147: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:5914 +//line sql.y:5905 { yyLOCAL = &InsertExpr{Str: yyDollar[3].exprUnion(), Pos: yyDollar[5].exprUnion(), Len: yyDollar[7].exprUnion(), NewStr: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1150: + case 1148: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5918 +//line sql.y:5909 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1151: + case 1149: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5929 +//line sql.y:5920 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("utc_date")} } yyVAL.union = yyLOCAL - case 1152: + case 1150: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5933 +//line sql.y:5924 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1153: + case 1151: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5939 +//line sql.y:5930 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("current_date")} } yyVAL.union = yyLOCAL - case 1154: + case 1152: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5943 +//line sql.y:5934 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("curdate")} } yyVAL.union = yyLOCAL - case 1155: + case 1153: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5947 +//line sql.y:5938 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("utc_time"), Fsp: yyDollar[2].integerUnion()} } yyVAL.union = yyLOCAL - case 1156: + case 1154: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5952 +//line sql.y:5943 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("curtime"), Fsp: yyDollar[2].integerUnion()} } yyVAL.union = yyLOCAL - case 1157: + case 1155: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5957 +//line sql.y:5948 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("current_time"), Fsp: yyDollar[2].integerUnion()} } yyVAL.union = yyLOCAL - case 1158: + case 1156: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5961 +//line sql.y:5952 { yyLOCAL = &CountStar{} } yyVAL.union = yyLOCAL - case 1159: + case 1157: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5965 +//line sql.y:5956 { yyLOCAL = &Count{Distinct: yyDollar[3].booleanUnion(), Args: yyDollar[4].exprsUnion()} } yyVAL.union = yyLOCAL - case 1160: + case 1158: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5969 +//line sql.y:5960 { yyLOCAL = &Max{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1161: + case 1159: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5973 +//line sql.y:5964 { yyLOCAL = &Min{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1162: + case 1160: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5977 +//line sql.y:5968 { yyLOCAL = &Sum{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1163: + case 1161: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5981 +//line sql.y:5972 { yyLOCAL = &Avg{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1164: + case 1162: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5985 +//line sql.y:5976 { yyLOCAL = &BitAnd{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1165: + case 1163: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5989 +//line sql.y:5980 { yyLOCAL = &BitOr{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1166: + case 1164: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5993 +//line sql.y:5984 { yyLOCAL = &BitXor{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1167: + case 1165: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5997 +//line sql.y:5988 { yyLOCAL = &Std{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1168: + case 1166: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6001 +//line sql.y:5992 { yyLOCAL = &StdDev{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1169: + case 1167: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6005 +//line sql.y:5996 { yyLOCAL = &StdPop{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1170: + case 1168: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6009 +//line sql.y:6000 { yyLOCAL = &StdSamp{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1171: + case 1169: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6013 +//line sql.y:6004 { yyLOCAL = &VarPop{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1172: + case 1170: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6017 +//line sql.y:6008 { yyLOCAL = &VarSamp{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1173: + case 1171: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6021 +//line sql.y:6012 { yyLOCAL = &Variance{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1174: + case 1172: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6025 +//line sql.y:6016 { yyLOCAL = &GroupConcatExpr{Distinct: yyDollar[3].booleanUnion(), Exprs: yyDollar[4].exprsUnion(), OrderBy: yyDollar[5].orderByUnion(), Separator: yyDollar[6].str, Limit: yyDollar[7].limitUnion()} } yyVAL.union = yyLOCAL - case 1175: + case 1173: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6029 +//line sql.y:6020 { yyLOCAL = &AnyValue{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1176: + case 1174: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6033 +//line sql.y:6024 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprTimestampadd, Date: yyDollar[7].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1177: + case 1175: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6037 +//line sql.y:6028 { yyLOCAL = &TimestampDiffExpr{Unit: yyDollar[3].intervalTypeUnion(), Expr1: yyDollar[5].exprUnion(), Expr2: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1178: + case 1176: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6041 +//line sql.y:6032 { yyLOCAL = &ExtractFuncExpr{IntervalType: yyDollar[3].intervalTypeUnion(), Expr: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1179: + case 1177: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6045 +//line sql.y:6036 { yyLOCAL = &WeightStringFuncExpr{Expr: yyDollar[3].exprUnion(), As: yyDollar[4].convertTypeUnion()} } yyVAL.union = yyLOCAL - case 1180: + case 1178: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6049 +//line sql.y:6040 { yyLOCAL = &JSONPrettyExpr{JSONVal: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1181: + case 1179: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6053 +//line sql.y:6044 { yyLOCAL = &JSONStorageFreeExpr{JSONVal: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1182: + case 1180: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6057 +//line sql.y:6048 { yyLOCAL = &JSONStorageSizeExpr{JSONVal: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1183: + case 1181: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6061 +//line sql.y:6052 { yyLOCAL = &TrimFuncExpr{TrimFuncType: LTrimType, Type: LeadingTrimType, StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1184: + case 1182: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6065 +//line sql.y:6056 { yyLOCAL = &TrimFuncExpr{TrimFuncType: RTrimType, Type: TrailingTrimType, StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1185: + case 1183: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:6069 +//line sql.y:6060 { yyLOCAL = &TrimFuncExpr{Type: yyDollar[3].trimTypeUnion(), TrimArg: yyDollar[4].exprUnion(), StringArg: yyDollar[6].exprUnion()} } yyVAL.union = yyLOCAL - case 1186: + case 1184: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6073 +//line sql.y:6064 { yyLOCAL = &TrimFuncExpr{StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1187: + case 1185: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6077 +//line sql.y:6068 { yyLOCAL = &CharExpr{Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1188: + case 1186: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6081 +//line sql.y:6072 { yyLOCAL = &CharExpr{Exprs: yyDollar[3].exprsUnion(), Charset: yyDollar[5].str} } yyVAL.union = yyLOCAL - case 1189: + case 1187: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6085 +//line sql.y:6076 { yyLOCAL = &TrimFuncExpr{TrimArg: yyDollar[3].exprUnion(), StringArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1190: + case 1188: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6089 +//line sql.y:6080 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1191: + case 1189: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6093 +//line sql.y:6084 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion(), Pos: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1192: + case 1190: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6097 +//line sql.y:6088 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1193: + case 1191: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6101 +//line sql.y:6092 { yyLOCAL = &LockingFunc{Type: GetLock, Name: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1194: + case 1192: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6105 +//line sql.y:6096 { yyLOCAL = &LockingFunc{Type: IsFreeLock, Name: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1195: + case 1193: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6109 +//line sql.y:6100 { yyLOCAL = &LockingFunc{Type: IsUsedLock, Name: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1196: + case 1194: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:6113 +//line sql.y:6104 { yyLOCAL = &LockingFunc{Type: ReleaseAllLocks} } yyVAL.union = yyLOCAL - case 1197: + case 1195: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6117 +//line sql.y:6108 { yyLOCAL = &LockingFunc{Type: ReleaseLock, Name: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1198: + case 1196: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6121 +//line sql.y:6112 { yyLOCAL = &JSONSchemaValidFuncExpr{Schema: yyDollar[3].exprUnion(), Document: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1199: + case 1197: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6125 +//line sql.y:6116 { yyLOCAL = &JSONSchemaValidationReportFuncExpr{Schema: yyDollar[3].exprUnion(), Document: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1200: + case 1198: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6129 +//line sql.y:6120 { yyLOCAL = &JSONArrayExpr{Params: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1201: + case 1199: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6133 +//line sql.y:6124 { yyLOCAL = &GeomFormatExpr{FormatType: BinaryFormat, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1202: + case 1200: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6137 +//line sql.y:6128 { yyLOCAL = &GeomFormatExpr{FormatType: BinaryFormat, Geom: yyDollar[3].exprUnion(), AxisOrderOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1203: + case 1201: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6141 +//line sql.y:6132 { yyLOCAL = &GeomFormatExpr{FormatType: TextFormat, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1204: + case 1202: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6145 +//line sql.y:6136 { yyLOCAL = &GeomFormatExpr{FormatType: TextFormat, Geom: yyDollar[3].exprUnion(), AxisOrderOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1205: + case 1203: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6149 +//line sql.y:6140 { yyLOCAL = &GeomPropertyFuncExpr{Property: IsEmpty, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1206: + case 1204: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6153 +//line sql.y:6144 { yyLOCAL = &GeomPropertyFuncExpr{Property: IsSimple, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1207: + case 1205: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6157 +//line sql.y:6148 { yyLOCAL = &GeomPropertyFuncExpr{Property: Dimension, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1208: + case 1206: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6161 +//line sql.y:6152 { yyLOCAL = &GeomPropertyFuncExpr{Property: Envelope, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1209: + case 1207: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6165 +//line sql.y:6156 { yyLOCAL = &GeomPropertyFuncExpr{Property: GeometryType, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1210: + case 1208: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6169 +//line sql.y:6160 { yyLOCAL = &PointPropertyFuncExpr{Property: Latitude, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1211: + case 1209: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6173 +//line sql.y:6164 { yyLOCAL = &PointPropertyFuncExpr{Property: Latitude, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1212: + case 1210: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6177 +//line sql.y:6168 { yyLOCAL = &PointPropertyFuncExpr{Property: Longitude, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1213: + case 1211: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6181 +//line sql.y:6172 { yyLOCAL = &PointPropertyFuncExpr{Property: Longitude, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1214: + case 1212: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6185 +//line sql.y:6176 { yyLOCAL = &LinestrPropertyFuncExpr{Property: EndPoint, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1215: + case 1213: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6189 +//line sql.y:6180 { yyLOCAL = &LinestrPropertyFuncExpr{Property: IsClosed, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1216: + case 1214: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6193 +//line sql.y:6184 { yyLOCAL = &LinestrPropertyFuncExpr{Property: Length, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1217: + case 1215: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6197 +//line sql.y:6188 { yyLOCAL = &LinestrPropertyFuncExpr{Property: Length, Linestring: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1218: + case 1216: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6201 +//line sql.y:6192 { yyLOCAL = &LinestrPropertyFuncExpr{Property: NumPoints, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1219: + case 1217: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6205 +//line sql.y:6196 { yyLOCAL = &LinestrPropertyFuncExpr{Property: PointN, Linestring: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1220: + case 1218: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6209 +//line sql.y:6200 { yyLOCAL = &LinestrPropertyFuncExpr{Property: StartPoint, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1221: + case 1219: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6213 +//line sql.y:6204 { yyLOCAL = &PointPropertyFuncExpr{Property: XCordinate, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1222: + case 1220: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6217 +//line sql.y:6208 { yyLOCAL = &PointPropertyFuncExpr{Property: XCordinate, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1223: + case 1221: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6221 +//line sql.y:6212 { yyLOCAL = &PointPropertyFuncExpr{Property: YCordinate, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1224: + case 1222: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6225 +//line sql.y:6216 { yyLOCAL = &PointPropertyFuncExpr{Property: YCordinate, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1225: + case 1223: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6229 +//line sql.y:6220 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1226: + case 1224: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6233 +//line sql.y:6224 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1227: + case 1225: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6237 +//line sql.y:6228 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1228: + case 1226: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6241 +//line sql.y:6232 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1229: + case 1227: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6245 +//line sql.y:6236 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1230: + case 1228: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6249 +//line sql.y:6240 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1231: + case 1229: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6253 +//line sql.y:6244 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1232: + case 1230: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6257 +//line sql.y:6248 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1233: + case 1231: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6261 +//line sql.y:6252 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1234: + case 1232: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6265 +//line sql.y:6256 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1235: + case 1233: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6269 +//line sql.y:6260 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1236: + case 1234: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6273 +//line sql.y:6264 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1237: + case 1235: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6277 +//line sql.y:6268 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1238: + case 1236: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6281 +//line sql.y:6272 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1239: + case 1237: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6285 +//line sql.y:6276 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1240: + case 1238: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6289 +//line sql.y:6280 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1241: + case 1239: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6293 +//line sql.y:6284 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1242: + case 1240: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6297 +//line sql.y:6288 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1243: + case 1241: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6301 +//line sql.y:6292 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1244: + case 1242: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6305 +//line sql.y:6296 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1245: + case 1243: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6309 +//line sql.y:6300 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1246: + case 1244: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6313 +//line sql.y:6304 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1247: + case 1245: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6317 +//line sql.y:6308 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1248: + case 1246: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6321 +//line sql.y:6312 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1249: + case 1247: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6325 +//line sql.y:6316 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1250: + case 1248: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6329 +//line sql.y:6320 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1251: + case 1249: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6333 +//line sql.y:6324 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1252: + case 1250: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6337 +//line sql.y:6328 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1253: + case 1251: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6341 +//line sql.y:6332 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1254: + case 1252: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6345 +//line sql.y:6336 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1255: + case 1253: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6349 +//line sql.y:6340 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1256: + case 1254: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6353 +//line sql.y:6344 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1257: + case 1255: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6357 +//line sql.y:6348 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1258: + case 1256: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6361 +//line sql.y:6352 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1259: + case 1257: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6365 +//line sql.y:6356 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1260: + case 1258: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6369 +//line sql.y:6360 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1261: + case 1259: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6373 +//line sql.y:6364 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1262: + case 1260: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6377 +//line sql.y:6368 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1263: + case 1261: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6381 +//line sql.y:6372 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1264: + case 1262: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6385 +//line sql.y:6376 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1265: + case 1263: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6389 +//line sql.y:6380 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1266: + case 1264: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6393 +//line sql.y:6384 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1267: + case 1265: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6397 +//line sql.y:6388 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1268: + case 1266: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6401 +//line sql.y:6392 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1269: + case 1267: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6405 +//line sql.y:6396 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1270: + case 1268: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6409 +//line sql.y:6400 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1271: + case 1269: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6413 +//line sql.y:6404 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1272: + case 1270: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6417 +//line sql.y:6408 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1273: + case 1271: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6421 +//line sql.y:6412 { yyLOCAL = &PolygonPropertyFuncExpr{Property: Area, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1274: + case 1272: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6425 +//line sql.y:6416 { yyLOCAL = &PolygonPropertyFuncExpr{Property: Centroid, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1275: + case 1273: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6429 +//line sql.y:6420 { yyLOCAL = &PolygonPropertyFuncExpr{Property: ExteriorRing, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1276: + case 1274: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6433 +//line sql.y:6424 { yyLOCAL = &PolygonPropertyFuncExpr{Property: InteriorRingN, Polygon: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1277: + case 1275: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6437 +//line sql.y:6428 { yyLOCAL = &PolygonPropertyFuncExpr{Property: NumInteriorRings, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1278: + case 1276: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6441 +//line sql.y:6432 { yyLOCAL = &GeomCollPropertyFuncExpr{Property: GeometryN, GeomColl: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1279: + case 1277: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6445 +//line sql.y:6436 { yyLOCAL = &GeomCollPropertyFuncExpr{Property: NumGeometries, GeomColl: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1280: + case 1278: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6449 +//line sql.y:6440 { yyLOCAL = &GeoHashFromLatLongExpr{Longitude: yyDollar[3].exprUnion(), Latitude: yyDollar[5].exprUnion(), MaxLength: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1281: + case 1279: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6453 +//line sql.y:6444 { yyLOCAL = &GeoHashFromPointExpr{Point: yyDollar[3].exprUnion(), MaxLength: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1282: + case 1280: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6457 +//line sql.y:6448 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: LatitudeFromHash, GeoHash: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1283: + case 1281: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6461 +//line sql.y:6452 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: LongitudeFromHash, GeoHash: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1284: + case 1282: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6465 +//line sql.y:6456 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: PointFromHash, GeoHash: yyDollar[3].exprUnion(), SridOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1285: + case 1283: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6469 +//line sql.y:6460 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1286: + case 1284: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6473 +//line sql.y:6464 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion(), HigherDimHandlerOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1287: + case 1285: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6477 +//line sql.y:6468 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion(), HigherDimHandlerOpt: yyDollar[5].exprUnion(), Srid: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1288: + case 1286: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6481 +//line sql.y:6472 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1289: + case 1287: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6485 +//line sql.y:6476 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion(), MaxDecimalDigits: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1290: + case 1288: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6489 +//line sql.y:6480 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion(), MaxDecimalDigits: yyDollar[5].exprUnion(), Bitmask: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1291: + case 1289: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6493 +//line sql.y:6484 { yyLOCAL = &JSONObjectExpr{Params: yyDollar[3].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1292: + case 1290: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6497 +//line sql.y:6488 { yyLOCAL = &JSONQuoteExpr{StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1293: + case 1291: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6501 +//line sql.y:6492 { yyLOCAL = &JSONContainsExpr{Target: yyDollar[3].exprUnion(), Candidate: yyDollar[5].exprsUnion()[0], PathList: yyDollar[5].exprsUnion()[1:]} } yyVAL.union = yyLOCAL - case 1294: + case 1292: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6505 +//line sql.y:6496 { yyLOCAL = &JSONContainsPathExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), PathList: yyDollar[7].exprsUnion()} } yyVAL.union = yyLOCAL - case 1295: + case 1293: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6509 +//line sql.y:6500 { yyLOCAL = &JSONExtractExpr{JSONDoc: yyDollar[3].exprUnion(), PathList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1296: + case 1294: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6513 +//line sql.y:6504 { yyLOCAL = &JSONKeysExpr{JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1297: + case 1295: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6517 +//line sql.y:6508 { yyLOCAL = &JSONKeysExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1298: + case 1296: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6521 +//line sql.y:6512 { yyLOCAL = &JSONOverlapsExpr{JSONDoc1: yyDollar[3].exprUnion(), JSONDoc2: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1299: + case 1297: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6525 +//line sql.y:6516 { yyLOCAL = &JSONSearchExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), SearchStr: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1300: + case 1298: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6529 +//line sql.y:6520 { yyLOCAL = &JSONSearchExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), SearchStr: yyDollar[7].exprUnion(), EscapeChar: yyDollar[9].exprsUnion()[0], PathList: yyDollar[9].exprsUnion()[1:]} } yyVAL.union = yyLOCAL - case 1301: + case 1299: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:6533 +//line sql.y:6524 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion()} } yyVAL.union = yyLOCAL - case 1302: + case 1300: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6537 +//line sql.y:6528 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion()} } yyVAL.union = yyLOCAL - case 1303: + case 1301: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6541 +//line sql.y:6532 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), ErrorOnResponse: yyDollar[7].jtOnResponseUnion()} } yyVAL.union = yyLOCAL - case 1304: + case 1302: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6545 +//line sql.y:6536 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion(), ErrorOnResponse: yyDollar[8].jtOnResponseUnion()} } yyVAL.union = yyLOCAL - case 1305: + case 1303: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6549 +//line sql.y:6540 { yyLOCAL = &JSONAttributesExpr{Type: DepthAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1306: + case 1304: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6553 +//line sql.y:6544 { yyLOCAL = &JSONAttributesExpr{Type: ValidAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1307: + case 1305: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6557 +//line sql.y:6548 { yyLOCAL = &JSONAttributesExpr{Type: TypeAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1308: + case 1306: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6561 +//line sql.y:6552 { yyLOCAL = &JSONAttributesExpr{Type: LengthAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1309: + case 1307: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6565 +//line sql.y:6556 { yyLOCAL = &JSONAttributesExpr{Type: LengthAttributeType, JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1310: + case 1308: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6569 +//line sql.y:6560 { yyLOCAL = &JSONValueModifierExpr{Type: JSONArrayAppendType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1311: + case 1309: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6573 +//line sql.y:6564 { yyLOCAL = &JSONValueModifierExpr{Type: JSONArrayInsertType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1312: + case 1310: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6577 +//line sql.y:6568 { yyLOCAL = &JSONValueModifierExpr{Type: JSONInsertType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1313: + case 1311: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6581 +//line sql.y:6572 { yyLOCAL = &JSONValueModifierExpr{Type: JSONReplaceType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1314: + case 1312: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6585 +//line sql.y:6576 { yyLOCAL = &JSONValueModifierExpr{Type: JSONSetType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1315: + case 1313: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6589 +//line sql.y:6580 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergeType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1316: + case 1314: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6593 +//line sql.y:6584 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergePatchType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1317: + case 1315: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6597 +//line sql.y:6588 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergePreserveType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1318: + case 1316: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6601 +//line sql.y:6592 { yyLOCAL = &JSONRemoveExpr{JSONDoc: yyDollar[3].exprUnion(), PathList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1319: + case 1317: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6605 +//line sql.y:6596 { yyLOCAL = &JSONUnquoteExpr{JSONValue: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1320: + case 1318: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6609 +//line sql.y:6600 { yyLOCAL = &MultiPolygonExpr{PolygonParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1321: + case 1319: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6613 +//line sql.y:6604 { yyLOCAL = &MultiPointExpr{PointParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1322: + case 1320: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6617 +//line sql.y:6608 { yyLOCAL = &MultiLinestringExpr{LinestringParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1323: + case 1321: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6621 +//line sql.y:6612 { yyLOCAL = &PolygonExpr{LinestringParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1324: + case 1322: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6625 +//line sql.y:6616 { yyLOCAL = &LineStringExpr{PointParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1325: + case 1323: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6629 +//line sql.y:6620 { yyLOCAL = &PointExpr{XCordinate: yyDollar[3].exprUnion(), YCordinate: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1326: + case 1324: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6633 +//line sql.y:6624 { yyLOCAL = &ArgumentLessWindowExpr{Type: yyDollar[1].argumentLessWindowExprTypeUnion(), OverClause: yyDollar[4].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1327: + case 1325: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6637 +//line sql.y:6628 { yyLOCAL = &FirstOrLastValueExpr{Type: yyDollar[1].firstOrLastValueExprTypeUnion(), Expr: yyDollar[3].exprUnion(), NullTreatmentClause: yyDollar[5].nullTreatmentClauseUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1328: + case 1326: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6641 +//line sql.y:6632 { yyLOCAL = &NtileExpr{N: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1329: + case 1327: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6645 +//line sql.y:6636 { yyLOCAL = &NTHValueExpr{Expr: yyDollar[3].exprUnion(), N: yyDollar[5].exprUnion(), FromFirstLastClause: yyDollar[7].fromFirstLastClauseUnion(), NullTreatmentClause: yyDollar[8].nullTreatmentClauseUnion(), OverClause: yyDollar[9].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1330: + case 1328: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6649 +//line sql.y:6640 { yyLOCAL = &LagLeadExpr{Type: yyDollar[1].lagLeadExprTypeUnion(), Expr: yyDollar[3].exprUnion(), NullTreatmentClause: yyDollar[5].nullTreatmentClauseUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1331: + case 1329: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6653 +//line sql.y:6644 { yyLOCAL = &LagLeadExpr{Type: yyDollar[1].lagLeadExprTypeUnion(), Expr: yyDollar[3].exprUnion(), N: yyDollar[5].exprUnion(), Default: yyDollar[6].exprUnion(), NullTreatmentClause: yyDollar[8].nullTreatmentClauseUnion(), OverClause: yyDollar[9].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1332: + case 1330: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6657 +//line sql.y:6648 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprAdddate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1333: + case 1331: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6661 +//line sql.y:6652 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprAdddate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: IntervalNone} } yyVAL.union = yyLOCAL - case 1334: + case 1332: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6665 +//line sql.y:6656 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprDateAdd, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1335: + case 1333: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6669 +//line sql.y:6660 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprDateSub, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1336: + case 1334: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6673 +//line sql.y:6664 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprSubdate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1337: + case 1335: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6677 +//line sql.y:6668 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprSubdate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: IntervalNone} } yyVAL.union = yyLOCAL - case 1342: + case 1340: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6687 +//line sql.y:6678 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1343: + case 1341: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6691 +//line sql.y:6682 { yyLOCAL = NewIntLiteral(yyDollar[1].str) } yyVAL.union = yyLOCAL - case 1344: + case 1342: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6695 +//line sql.y:6686 { yyLOCAL = yyDollar[1].variableUnion() } yyVAL.union = yyLOCAL - case 1345: + case 1343: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6699 +//line sql.y:6690 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } yyVAL.union = yyLOCAL - case 1346: + case 1344: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:6704 +//line sql.y:6695 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1347: + case 1345: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6708 +//line sql.y:6699 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1348: + case 1346: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6714 +//line sql.y:6705 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1349: + case 1347: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6718 +//line sql.y:6709 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1350: + case 1348: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6722 +//line sql.y:6713 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1351: + case 1349: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6726 +//line sql.y:6717 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), ReturnOption: yyDollar[11].exprUnion()} } yyVAL.union = yyLOCAL - case 1352: + case 1350: yyDollar = yyS[yypt-14 : yypt+1] var yyLOCAL Expr -//line sql.y:6730 +//line sql.y:6721 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), ReturnOption: yyDollar[11].exprUnion(), MatchType: yyDollar[13].exprUnion()} } yyVAL.union = yyLOCAL - case 1353: + case 1351: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6735 +//line sql.y:6726 { yyLOCAL = &RegexpLikeExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1354: + case 1352: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6739 +//line sql.y:6730 { yyLOCAL = &RegexpLikeExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), MatchType: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1355: + case 1353: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6743 +//line sql.y:6734 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1356: + case 1354: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6747 +//line sql.y:6738 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1357: + case 1355: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6751 +//line sql.y:6742 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion(), Occurrence: yyDollar[11].exprUnion()} } yyVAL.union = yyLOCAL - case 1358: + case 1356: yyDollar = yyS[yypt-14 : yypt+1] var yyLOCAL Expr -//line sql.y:6755 +//line sql.y:6746 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion(), Occurrence: yyDollar[11].exprUnion(), MatchType: yyDollar[13].exprUnion()} } yyVAL.union = yyLOCAL - case 1359: + case 1357: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6760 +//line sql.y:6751 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1360: + case 1358: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6764 +//line sql.y:6755 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1361: + case 1359: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6768 +//line sql.y:6759 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1362: + case 1360: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6772 +//line sql.y:6763 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), MatchType: yyDollar[11].exprUnion()} } yyVAL.union = yyLOCAL - case 1363: + case 1361: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6779 +//line sql.y:6770 { yyLOCAL = &ExtractValueExpr{Fragment: yyDollar[3].exprUnion(), XPathExpr: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1364: + case 1362: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6783 +//line sql.y:6774 { yyLOCAL = &UpdateXMLExpr{Target: yyDollar[3].exprUnion(), XPathExpr: yyDollar[5].exprUnion(), NewXML: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1365: + case 1363: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6789 +//line sql.y:6780 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: FormatBytesType, Argument: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1366: + case 1364: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6793 +//line sql.y:6784 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: FormatPicoTimeType, Argument: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1367: + case 1365: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:6797 +//line sql.y:6788 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: PsCurrentThreadIDType} } yyVAL.union = yyLOCAL - case 1368: + case 1366: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6801 +//line sql.y:6792 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: PsThreadIDType, Argument: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1369: + case 1367: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6807 +//line sql.y:6798 { yyLOCAL = >IDFuncExpr{Type: GTIDSubsetType, Set1: yyDollar[3].exprUnion(), Set2: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1370: + case 1368: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6811 +//line sql.y:6802 { yyLOCAL = >IDFuncExpr{Type: GTIDSubtractType, Set1: yyDollar[3].exprUnion(), Set2: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1371: + case 1369: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6815 +//line sql.y:6806 { yyLOCAL = >IDFuncExpr{Type: WaitForExecutedGTIDSetType, Set1: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1372: + case 1370: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6819 +//line sql.y:6810 { yyLOCAL = >IDFuncExpr{Type: WaitForExecutedGTIDSetType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1373: + case 1371: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6823 +//line sql.y:6814 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1374: + case 1372: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6827 +//line sql.y:6818 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1375: + case 1373: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6831 +//line sql.y:6822 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion(), Channel: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1376: + case 1374: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:6836 +//line sql.y:6827 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1377: + case 1375: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:6840 +//line sql.y:6831 { yyLOCAL = yyDollar[2].convertTypeUnion() } yyVAL.union = yyLOCAL - case 1378: + case 1376: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6846 +//line sql.y:6837 { yyLOCAL = IntervalDayHour } yyVAL.union = yyLOCAL - case 1379: + case 1377: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6850 +//line sql.y:6841 { yyLOCAL = IntervalDayMicrosecond } yyVAL.union = yyLOCAL - case 1380: + case 1378: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6854 +//line sql.y:6845 { yyLOCAL = IntervalDayMinute } yyVAL.union = yyLOCAL - case 1381: + case 1379: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6858 +//line sql.y:6849 { yyLOCAL = IntervalDaySecond } yyVAL.union = yyLOCAL - case 1382: + case 1380: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6862 +//line sql.y:6853 { yyLOCAL = IntervalHourMicrosecond } yyVAL.union = yyLOCAL - case 1383: + case 1381: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6866 +//line sql.y:6857 { yyLOCAL = IntervalHourMinute } yyVAL.union = yyLOCAL - case 1384: + case 1382: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6870 +//line sql.y:6861 { yyLOCAL = IntervalHourSecond } yyVAL.union = yyLOCAL - case 1385: + case 1383: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6874 +//line sql.y:6865 { yyLOCAL = IntervalMinuteMicrosecond } yyVAL.union = yyLOCAL - case 1386: + case 1384: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6878 +//line sql.y:6869 { yyLOCAL = IntervalMinuteSecond } yyVAL.union = yyLOCAL - case 1387: + case 1385: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6882 +//line sql.y:6873 { yyLOCAL = IntervalSecondMicrosecond } yyVAL.union = yyLOCAL - case 1388: + case 1386: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6886 +//line sql.y:6877 { yyLOCAL = IntervalYearMonth } yyVAL.union = yyLOCAL - case 1389: + case 1387: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6890 +//line sql.y:6881 { yyLOCAL = IntervalDay } yyVAL.union = yyLOCAL - case 1390: + case 1388: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6894 +//line sql.y:6885 { yyLOCAL = IntervalWeek } yyVAL.union = yyLOCAL - case 1391: + case 1389: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6898 +//line sql.y:6889 { yyLOCAL = IntervalHour } yyVAL.union = yyLOCAL - case 1392: + case 1390: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6902 +//line sql.y:6893 { yyLOCAL = IntervalMinute } yyVAL.union = yyLOCAL - case 1393: + case 1391: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6906 +//line sql.y:6897 { yyLOCAL = IntervalMonth } yyVAL.union = yyLOCAL - case 1394: + case 1392: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6910 +//line sql.y:6901 { yyLOCAL = IntervalQuarter } yyVAL.union = yyLOCAL - case 1395: + case 1393: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6914 +//line sql.y:6905 { yyLOCAL = IntervalSecond } yyVAL.union = yyLOCAL - case 1396: + case 1394: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6918 +//line sql.y:6909 { yyLOCAL = IntervalMicrosecond } yyVAL.union = yyLOCAL - case 1397: + case 1395: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6922 +//line sql.y:6913 { yyLOCAL = IntervalYear } yyVAL.union = yyLOCAL - case 1398: + case 1396: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6928 +//line sql.y:6919 { yyLOCAL = IntervalDay } yyVAL.union = yyLOCAL - case 1399: + case 1397: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6932 +//line sql.y:6923 { yyLOCAL = IntervalWeek } yyVAL.union = yyLOCAL - case 1400: + case 1398: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6936 +//line sql.y:6927 { yyLOCAL = IntervalHour } yyVAL.union = yyLOCAL - case 1401: + case 1399: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6940 +//line sql.y:6931 { yyLOCAL = IntervalMinute } yyVAL.union = yyLOCAL - case 1402: + case 1400: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6944 +//line sql.y:6935 { yyLOCAL = IntervalMonth } yyVAL.union = yyLOCAL - case 1403: + case 1401: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6948 +//line sql.y:6939 { yyLOCAL = IntervalQuarter } yyVAL.union = yyLOCAL - case 1404: + case 1402: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6952 +//line sql.y:6943 { yyLOCAL = IntervalSecond } yyVAL.union = yyLOCAL - case 1405: + case 1403: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6956 +//line sql.y:6947 { yyLOCAL = IntervalMicrosecond } yyVAL.union = yyLOCAL - case 1406: + case 1404: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6960 +//line sql.y:6951 { yyLOCAL = IntervalYear } yyVAL.union = yyLOCAL - case 1407: + case 1405: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6964 +//line sql.y:6955 { yyLOCAL = IntervalDay } yyVAL.union = yyLOCAL - case 1408: + case 1406: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6968 +//line sql.y:6959 { yyLOCAL = IntervalWeek } yyVAL.union = yyLOCAL - case 1409: + case 1407: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6972 +//line sql.y:6963 { yyLOCAL = IntervalHour } yyVAL.union = yyLOCAL - case 1410: + case 1408: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6976 +//line sql.y:6967 { yyLOCAL = IntervalMinute } yyVAL.union = yyLOCAL - case 1411: + case 1409: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6980 +//line sql.y:6971 { yyLOCAL = IntervalMonth } yyVAL.union = yyLOCAL - case 1412: + case 1410: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6984 +//line sql.y:6975 { yyLOCAL = IntervalQuarter } yyVAL.union = yyLOCAL - case 1413: + case 1411: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6988 +//line sql.y:6979 { yyLOCAL = IntervalSecond } yyVAL.union = yyLOCAL - case 1414: + case 1412: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6992 +//line sql.y:6983 { yyLOCAL = IntervalMicrosecond } yyVAL.union = yyLOCAL - case 1415: + case 1413: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6996 +//line sql.y:6987 { yyLOCAL = IntervalYear } yyVAL.union = yyLOCAL - case 1418: + case 1416: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:7006 +//line sql.y:6997 { yyLOCAL = 0 } yyVAL.union = yyLOCAL - case 1419: + case 1417: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL int -//line sql.y:7010 +//line sql.y:7001 { yyLOCAL = 0 } yyVAL.union = yyLOCAL - case 1420: + case 1418: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:7014 +//line sql.y:7005 { yyLOCAL = convertStringToInt(yyDollar[2].str) } yyVAL.union = yyLOCAL - case 1421: + case 1419: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7024 +//line sql.y:7015 { - yyLOCAL = &FuncExpr{Name: NewIdentifierCI("if"), Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: NewIdentifierCI("if"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1422: + case 1420: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7028 +//line sql.y:7019 { - yyLOCAL = &FuncExpr{Name: NewIdentifierCI("database"), Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: NewIdentifierCI("database"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1423: + case 1421: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7032 +//line sql.y:7023 { - yyLOCAL = &FuncExpr{Name: NewIdentifierCI("schema"), Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: NewIdentifierCI("schema"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1424: + case 1422: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7036 +//line sql.y:7027 { - yyLOCAL = &FuncExpr{Name: NewIdentifierCI("mod"), Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: NewIdentifierCI("mod"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1425: + case 1423: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7040 +//line sql.y:7031 { - yyLOCAL = &FuncExpr{Name: NewIdentifierCI("replace"), Exprs: yyDollar[3].selectExprsUnion()} + yyLOCAL = &FuncExpr{Name: NewIdentifierCI("replace"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1426: + case 1424: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7046 +//line sql.y:7037 { yyLOCAL = NoOption } yyVAL.union = yyLOCAL - case 1427: + case 1425: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7050 +//line sql.y:7041 { yyLOCAL = BooleanModeOpt } yyVAL.union = yyLOCAL - case 1428: + case 1426: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7054 +//line sql.y:7045 { yyLOCAL = NaturalLanguageModeOpt } yyVAL.union = yyLOCAL - case 1429: + case 1427: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7058 +//line sql.y:7049 { yyLOCAL = NaturalLanguageModeWithQueryExpansionOpt } yyVAL.union = yyLOCAL - case 1430: + case 1428: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7062 +//line sql.y:7053 { yyLOCAL = QueryExpansionOpt } yyVAL.union = yyLOCAL - case 1431: + case 1429: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7068 +//line sql.y:7059 { yyVAL.str = string(yyDollar[1].identifierCI.String()) } - case 1432: + case 1430: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7072 +//line sql.y:7063 { yyVAL.str = string(yyDollar[1].str) } - case 1433: + case 1431: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7076 +//line sql.y:7067 { yyVAL.str = string(yyDollar[1].str) } - case 1434: + case 1432: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7082 +//line sql.y:7073 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1435: + case 1433: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7086 +//line sql.y:7077 { yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: ptr.Of(convertStringToInt(yyDollar[4].str))} } yyVAL.union = yyLOCAL - case 1436: + case 1434: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7090 +//line sql.y:7081 { yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: ptr.Of(convertStringToInt(yyDollar[4].str))} } yyVAL.union = yyLOCAL - case 1437: + case 1435: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7096 +//line sql.y:7087 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1438: + case 1436: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7100 +//line sql.y:7091 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion(), Charset: yyDollar[3].columnCharset} } yyVAL.union = yyLOCAL - case 1439: + case 1437: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7104 +//line sql.y:7095 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1440: + case 1438: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7108 +//line sql.y:7099 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1441: + case 1439: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7112 +//line sql.y:7103 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} yyLOCAL.Length = yyDollar[2].LengthScaleOption.Length yyLOCAL.Scale = yyDollar[2].LengthScaleOption.Scale } yyVAL.union = yyLOCAL - case 1442: + case 1440: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7118 +//line sql.y:7109 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1443: + case 1441: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7122 +//line sql.y:7113 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1444: + case 1442: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7126 +//line sql.y:7117 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1445: + case 1443: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7130 +//line sql.y:7121 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1446: + case 1444: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7134 +//line sql.y:7125 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1447: + case 1445: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7138 +//line sql.y:7129 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1448: + case 1446: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7142 +//line sql.y:7133 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1449: + case 1447: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7146 +//line sql.y:7137 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1450: + case 1448: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7150 +//line sql.y:7141 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1451: + case 1449: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7154 +//line sql.y:7145 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1452: + case 1450: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7160 +//line sql.y:7151 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1453: + case 1451: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:7164 +//line sql.y:7155 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1454: + case 1452: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7169 +//line sql.y:7160 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1455: + case 1453: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7173 +//line sql.y:7164 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1456: + case 1454: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7178 +//line sql.y:7169 { yyVAL.str = string("") } - case 1457: + case 1455: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7182 +//line sql.y:7173 { yyVAL.str = encodeSQLString(yyDollar[2].str) } - case 1458: + case 1456: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*When -//line sql.y:7188 +//line sql.y:7179 { yyLOCAL = []*When{yyDollar[1].whenUnion()} } yyVAL.union = yyLOCAL - case 1459: + case 1457: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7192 +//line sql.y:7183 { yySLICE := (*[]*When)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].whenUnion()) } - case 1460: + case 1458: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *When -//line sql.y:7198 +//line sql.y:7189 { yyLOCAL = &When{Cond: yyDollar[2].exprUnion(), Val: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1461: + case 1459: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7203 +//line sql.y:7194 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1462: + case 1460: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7207 +//line sql.y:7198 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1463: + case 1461: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ColName -//line sql.y:7213 +//line sql.y:7204 { yyLOCAL = &ColName{Name: yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 1464: + case 1462: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ColName -//line sql.y:7217 +//line sql.y:7208 { yyLOCAL = &ColName{Name: NewIdentifierCI(string(yyDollar[1].str))} } yyVAL.union = yyLOCAL - case 1465: + case 1463: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColName -//line sql.y:7221 +//line sql.y:7212 { yyLOCAL = &ColName{Qualifier: TableName{Name: yyDollar[1].identifierCS}, Name: yyDollar[3].identifierCI} } yyVAL.union = yyLOCAL - case 1466: + case 1464: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ColName -//line sql.y:7225 +//line sql.y:7216 { yyLOCAL = &ColName{Qualifier: TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS}, Name: yyDollar[5].identifierCI} } yyVAL.union = yyLOCAL - case 1467: + case 1465: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7231 +//line sql.y:7222 { yyLOCAL = yyDollar[1].colNameUnion() } yyVAL.union = yyLOCAL - case 1468: + case 1466: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7235 +//line sql.y:7226 { yyLOCAL = &Offset{V: convertStringToInt(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1469: + case 1467: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7241 +//line sql.y:7232 { // TODO(sougou): Deprecate this construct. if yyDollar[1].identifierCI.Lowered() != "value" { @@ -21163,426 +21088,426 @@ yydefault: yyLOCAL = NewIntLiteral("1") } yyVAL.union = yyLOCAL - case 1470: + case 1468: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7250 +//line sql.y:7241 { yyLOCAL = NewIntLiteral(yyDollar[1].str) } yyVAL.union = yyLOCAL - case 1471: + case 1469: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7254 +//line sql.y:7245 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } yyVAL.union = yyLOCAL - case 1472: + case 1470: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:7259 +//line sql.y:7250 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1473: + case 1471: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Exprs -//line sql.y:7263 +//line sql.y:7254 { yyLOCAL = yyDollar[3].exprsUnion() } yyVAL.union = yyLOCAL - case 1474: + case 1472: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7268 +//line sql.y:7259 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1475: + case 1473: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7272 +//line sql.y:7263 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1476: + case 1474: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *NamedWindow -//line sql.y:7278 +//line sql.y:7269 { yyLOCAL = &NamedWindow{yyDollar[2].windowDefinitionsUnion()} } yyVAL.union = yyLOCAL - case 1477: + case 1475: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7284 +//line sql.y:7275 { yyLOCAL = NamedWindows{yyDollar[1].namedWindowUnion()} } yyVAL.union = yyLOCAL - case 1478: + case 1476: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7288 +//line sql.y:7279 { yySLICE := (*NamedWindows)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].namedWindowUnion()) } - case 1479: + case 1477: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7293 +//line sql.y:7284 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1480: + case 1478: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7297 +//line sql.y:7288 { yyLOCAL = yyDollar[1].namedWindowsUnion() } yyVAL.union = yyLOCAL - case 1481: + case 1479: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7302 +//line sql.y:7293 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1482: + case 1480: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7306 +//line sql.y:7297 { yyLOCAL = yyDollar[1].orderByUnion() } yyVAL.union = yyLOCAL - case 1483: + case 1481: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7312 +//line sql.y:7303 { yyLOCAL = yyDollar[3].orderByUnion() } yyVAL.union = yyLOCAL - case 1484: + case 1482: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7318 +//line sql.y:7309 { yyLOCAL = OrderBy{yyDollar[1].orderUnion()} } yyVAL.union = yyLOCAL - case 1485: + case 1483: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7322 +//line sql.y:7313 { yySLICE := (*OrderBy)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].orderUnion()) } - case 1486: + case 1484: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Order -//line sql.y:7328 +//line sql.y:7319 { yyLOCAL = &Order{Expr: yyDollar[1].exprUnion(), Direction: yyDollar[2].orderDirectionUnion()} } yyVAL.union = yyLOCAL - case 1487: + case 1485: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7333 +//line sql.y:7324 { yyLOCAL = AscOrder } yyVAL.union = yyLOCAL - case 1488: + case 1486: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7337 +//line sql.y:7328 { yyLOCAL = AscOrder } yyVAL.union = yyLOCAL - case 1489: + case 1487: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7341 +//line sql.y:7332 { yyLOCAL = DescOrder } yyVAL.union = yyLOCAL - case 1490: + case 1488: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *Limit -//line sql.y:7346 +//line sql.y:7337 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1491: + case 1489: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Limit -//line sql.y:7350 +//line sql.y:7341 { yyLOCAL = yyDollar[1].limitUnion() } yyVAL.union = yyLOCAL - case 1492: + case 1490: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Limit -//line sql.y:7356 +//line sql.y:7347 { yyLOCAL = &Limit{Rowcount: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1493: + case 1491: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Limit -//line sql.y:7360 +//line sql.y:7351 { yyLOCAL = &Limit{Offset: yyDollar[2].exprUnion(), Rowcount: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1494: + case 1492: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Limit -//line sql.y:7364 +//line sql.y:7355 { yyLOCAL = &Limit{Offset: yyDollar[4].exprUnion(), Rowcount: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1495: + case 1493: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7369 +//line sql.y:7360 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1496: + case 1494: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7373 +//line sql.y:7364 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion(), yyDollar[2].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1497: + case 1495: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7377 +//line sql.y:7368 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion(), yyDollar[2].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1498: + case 1496: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7381 +//line sql.y:7372 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1499: + case 1497: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7385 +//line sql.y:7376 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1500: + case 1498: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7392 +//line sql.y:7383 { yyLOCAL = &LockOption{Type: DefaultType} } yyVAL.union = yyLOCAL - case 1501: + case 1499: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7396 +//line sql.y:7387 { yyLOCAL = &LockOption{Type: NoneType} } yyVAL.union = yyLOCAL - case 1502: + case 1500: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7400 +//line sql.y:7391 { yyLOCAL = &LockOption{Type: SharedType} } yyVAL.union = yyLOCAL - case 1503: + case 1501: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7404 +//line sql.y:7395 { yyLOCAL = &LockOption{Type: ExclusiveType} } yyVAL.union = yyLOCAL - case 1504: + case 1502: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7410 +//line sql.y:7401 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1505: + case 1503: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7414 +//line sql.y:7405 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1506: + case 1504: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7418 +//line sql.y:7409 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1507: + case 1505: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7422 +//line sql.y:7413 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1508: + case 1506: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7427 +//line sql.y:7418 { yyVAL.str = "" } - case 1509: + case 1507: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7431 +//line sql.y:7422 { yyVAL.str = string(yyDollar[3].str) } - case 1510: + case 1508: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7435 +//line sql.y:7426 { yyVAL.str = string(yyDollar[3].str) } - case 1511: + case 1509: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7439 +//line sql.y:7430 { yyVAL.str = string(yyDollar[3].str) } - case 1512: + case 1510: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7444 +//line sql.y:7435 { yyVAL.str = "" } - case 1513: + case 1511: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7448 +//line sql.y:7439 { yyVAL.str = yyDollar[3].str } - case 1514: + case 1512: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7454 +//line sql.y:7445 { yyVAL.str = string(yyDollar[1].str) } - case 1515: + case 1513: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7458 +//line sql.y:7449 { yyVAL.str = string(yyDollar[1].str) } - case 1516: + case 1514: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7463 +//line sql.y:7454 { yyVAL.str = "" } - case 1517: + case 1515: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7467 +//line sql.y:7458 { yyVAL.str = yyDollar[2].str } - case 1518: + case 1516: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7472 +//line sql.y:7463 { yyVAL.str = "cascaded" } - case 1519: + case 1517: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7476 +//line sql.y:7467 { yyVAL.str = string(yyDollar[1].str) } - case 1520: + case 1518: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7480 +//line sql.y:7471 { yyVAL.str = string(yyDollar[1].str) } - case 1521: + case 1519: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *Definer -//line sql.y:7485 +//line sql.y:7476 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1522: + case 1520: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Definer -//line sql.y:7489 +//line sql.y:7480 { yyLOCAL = yyDollar[3].definerUnion() } yyVAL.union = yyLOCAL - case 1523: + case 1521: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Definer -//line sql.y:7495 +//line sql.y:7486 { yyLOCAL = &Definer{ Name: string(yyDollar[1].str), } } yyVAL.union = yyLOCAL - case 1524: + case 1522: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Definer -//line sql.y:7501 +//line sql.y:7492 { yyLOCAL = &Definer{ Name: string(yyDollar[1].str), } } yyVAL.union = yyLOCAL - case 1525: + case 1523: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Definer -//line sql.y:7507 +//line sql.y:7498 { yyLOCAL = &Definer{ Name: yyDollar[1].str, @@ -21590,409 +21515,409 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1526: + case 1524: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7516 +//line sql.y:7507 { yyVAL.str = encodeSQLString(yyDollar[1].str) } - case 1527: + case 1525: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7520 +//line sql.y:7511 { yyVAL.str = formatIdentifier(yyDollar[1].str) } - case 1528: + case 1526: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7525 +//line sql.y:7516 { yyVAL.str = "" } - case 1529: + case 1527: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7529 +//line sql.y:7520 { yyVAL.str = formatAddress(yyDollar[1].str) } - case 1530: + case 1528: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Lock -//line sql.y:7535 +//line sql.y:7526 { yyLOCAL = ForUpdateLock } yyVAL.union = yyLOCAL - case 1531: + case 1529: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Lock -//line sql.y:7539 +//line sql.y:7530 { yyLOCAL = ForUpdateLockNoWait } yyVAL.union = yyLOCAL - case 1532: + case 1530: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7543 +//line sql.y:7534 { yyLOCAL = ForUpdateLockSkipLocked } yyVAL.union = yyLOCAL - case 1533: + case 1531: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Lock -//line sql.y:7547 +//line sql.y:7538 { yyLOCAL = ForShareLock } yyVAL.union = yyLOCAL - case 1534: + case 1532: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Lock -//line sql.y:7551 +//line sql.y:7542 { yyLOCAL = ForShareLockNoWait } yyVAL.union = yyLOCAL - case 1535: + case 1533: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7555 +//line sql.y:7546 { yyLOCAL = ForShareLockSkipLocked } yyVAL.union = yyLOCAL - case 1536: + case 1534: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7559 +//line sql.y:7550 { yyLOCAL = ShareModeLock } yyVAL.union = yyLOCAL - case 1537: + case 1535: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7565 +//line sql.y:7556 { yyLOCAL = &SelectInto{Type: IntoOutfileS3, FileName: encodeSQLString(yyDollar[4].str), Charset: yyDollar[5].columnCharset, FormatOption: yyDollar[6].str, ExportOption: yyDollar[7].str, Manifest: yyDollar[8].str, Overwrite: yyDollar[9].str} } yyVAL.union = yyLOCAL - case 1538: + case 1536: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7569 +//line sql.y:7560 { yyLOCAL = &SelectInto{Type: IntoDumpfile, FileName: encodeSQLString(yyDollar[3].str), Charset: ColumnCharset{}, FormatOption: "", ExportOption: "", Manifest: "", Overwrite: ""} } yyVAL.union = yyLOCAL - case 1539: + case 1537: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7573 +//line sql.y:7564 { yyLOCAL = &SelectInto{Type: IntoOutfile, FileName: encodeSQLString(yyDollar[3].str), Charset: yyDollar[4].columnCharset, FormatOption: "", ExportOption: yyDollar[5].str, Manifest: "", Overwrite: ""} } yyVAL.union = yyLOCAL - case 1540: + case 1538: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7578 +//line sql.y:7569 { yyVAL.str = "" } - case 1541: + case 1539: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7582 +//line sql.y:7573 { yyVAL.str = " format csv" + yyDollar[3].str } - case 1542: + case 1540: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7586 +//line sql.y:7577 { yyVAL.str = " format text" + yyDollar[3].str } - case 1543: + case 1541: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7591 +//line sql.y:7582 { yyVAL.str = "" } - case 1544: + case 1542: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7595 +//line sql.y:7586 { yyVAL.str = " header" } - case 1545: + case 1543: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7600 +//line sql.y:7591 { yyVAL.str = "" } - case 1546: + case 1544: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7604 +//line sql.y:7595 { yyVAL.str = " manifest on" } - case 1547: + case 1545: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7608 +//line sql.y:7599 { yyVAL.str = " manifest off" } - case 1548: + case 1546: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7613 +//line sql.y:7604 { yyVAL.str = "" } - case 1549: + case 1547: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7617 +//line sql.y:7608 { yyVAL.str = " overwrite on" } - case 1550: + case 1548: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7621 +//line sql.y:7612 { yyVAL.str = " overwrite off" } - case 1551: + case 1549: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7627 +//line sql.y:7618 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } - case 1552: + case 1550: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7632 +//line sql.y:7623 { yyVAL.str = "" } - case 1553: + case 1551: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7636 +//line sql.y:7627 { yyVAL.str = " lines" + yyDollar[2].str } - case 1554: + case 1552: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7642 +//line sql.y:7633 { yyVAL.str = yyDollar[1].str } - case 1555: + case 1553: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7646 +//line sql.y:7637 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } - case 1556: + case 1554: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7652 +//line sql.y:7643 { yyVAL.str = " starting by " + encodeSQLString(yyDollar[3].str) } - case 1557: + case 1555: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7656 +//line sql.y:7647 { yyVAL.str = " terminated by " + encodeSQLString(yyDollar[3].str) } - case 1558: + case 1556: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7661 +//line sql.y:7652 { yyVAL.str = "" } - case 1559: + case 1557: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7665 +//line sql.y:7656 { yyVAL.str = " " + yyDollar[1].str + yyDollar[2].str } - case 1560: + case 1558: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7671 +//line sql.y:7662 { yyVAL.str = yyDollar[1].str } - case 1561: + case 1559: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7675 +//line sql.y:7666 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } - case 1562: + case 1560: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7681 +//line sql.y:7672 { yyVAL.str = " terminated by " + encodeSQLString(yyDollar[3].str) } - case 1563: + case 1561: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7685 +//line sql.y:7676 { yyVAL.str = yyDollar[1].str + " enclosed by " + encodeSQLString(yyDollar[4].str) } - case 1564: + case 1562: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7689 +//line sql.y:7680 { yyVAL.str = " escaped by " + encodeSQLString(yyDollar[3].str) } - case 1565: + case 1563: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7694 +//line sql.y:7685 { yyVAL.str = "" } - case 1566: + case 1564: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7698 +//line sql.y:7689 { yyVAL.str = " optionally" } - case 1567: + case 1565: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Insert -//line sql.y:7711 +//line sql.y:7702 { yyLOCAL = &Insert{Rows: yyDollar[2].valuesUnion()} } yyVAL.union = yyLOCAL - case 1568: + case 1566: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Insert -//line sql.y:7715 +//line sql.y:7706 { yyLOCAL = &Insert{Rows: yyDollar[1].selStmtUnion()} } yyVAL.union = yyLOCAL - case 1569: + case 1567: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *Insert -//line sql.y:7719 +//line sql.y:7710 { yyLOCAL = &Insert{Columns: yyDollar[2].columnsUnion(), Rows: yyDollar[5].valuesUnion()} } yyVAL.union = yyLOCAL - case 1570: + case 1568: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Insert -//line sql.y:7723 +//line sql.y:7714 { yyLOCAL = &Insert{Columns: []IdentifierCI{}, Rows: yyDollar[4].valuesUnion()} } yyVAL.union = yyLOCAL - case 1571: + case 1569: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Insert -//line sql.y:7727 +//line sql.y:7718 { yyLOCAL = &Insert{Columns: yyDollar[2].columnsUnion(), Rows: yyDollar[4].selStmtUnion()} } yyVAL.union = yyLOCAL - case 1572: + case 1570: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:7733 +//line sql.y:7724 { yyLOCAL = Columns{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 1573: + case 1571: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Columns -//line sql.y:7737 +//line sql.y:7728 { yyLOCAL = Columns{yyDollar[3].identifierCI} } yyVAL.union = yyLOCAL - case 1574: + case 1572: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7741 +//line sql.y:7732 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 1575: + case 1573: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7745 +//line sql.y:7736 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[5].identifierCI) } - case 1576: + case 1574: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7750 +//line sql.y:7741 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1577: + case 1575: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7754 +//line sql.y:7745 { yyLOCAL = yyDollar[5].updateExprsUnion() } yyVAL.union = yyLOCAL - case 1578: + case 1576: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Values -//line sql.y:7760 +//line sql.y:7751 { yyLOCAL = Values{yyDollar[1].valTupleUnion()} } yyVAL.union = yyLOCAL - case 1579: + case 1577: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7764 +//line sql.y:7755 { yySLICE := (*Values)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].valTupleUnion()) } - case 1580: + case 1578: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7770 +//line sql.y:7761 { yyLOCAL = yyDollar[1].valTupleUnion() } yyVAL.union = yyLOCAL - case 1581: + case 1579: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7774 +//line sql.y:7765 { yyLOCAL = ValTuple{} } yyVAL.union = yyLOCAL - case 1582: + case 1580: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7780 +//line sql.y:7771 { yyLOCAL = ValTuple(yyDollar[2].exprsUnion()) } yyVAL.union = yyLOCAL - case 1583: + case 1581: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7784 +//line sql.y:7775 { yyLOCAL = ValTuple(yyDollar[3].exprsUnion()) } yyVAL.union = yyLOCAL - case 1584: + case 1582: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7789 +//line sql.y:7780 { if len(yyDollar[1].valTupleUnion()) == 1 { yyLOCAL = yyDollar[1].valTupleUnion()[0] @@ -22001,300 +21926,300 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1585: + case 1583: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7799 +//line sql.y:7790 { yyLOCAL = UpdateExprs{yyDollar[1].updateExprUnion()} } yyVAL.union = yyLOCAL - case 1586: + case 1584: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7803 +//line sql.y:7794 { yySLICE := (*UpdateExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].updateExprUnion()) } - case 1587: + case 1585: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *UpdateExpr -//line sql.y:7809 +//line sql.y:7800 { yyLOCAL = &UpdateExpr{Name: yyDollar[1].colNameUnion(), Expr: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1589: + case 1587: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7816 +//line sql.y:7807 { yyVAL.str = "charset" } - case 1592: + case 1590: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7826 +//line sql.y:7817 { yyLOCAL = NewStrLiteral(yyDollar[1].identifierCI.String()) } yyVAL.union = yyLOCAL - case 1593: + case 1591: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7830 +//line sql.y:7821 { yyLOCAL = NewStrLiteral(yyDollar[1].str) } yyVAL.union = yyLOCAL - case 1594: + case 1592: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7834 +//line sql.y:7825 { yyLOCAL = &Default{} } yyVAL.union = yyLOCAL - case 1597: + case 1595: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7843 +//line sql.y:7834 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1598: + case 1596: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:7845 +//line sql.y:7836 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1599: + case 1597: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7848 +//line sql.y:7839 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1600: + case 1598: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:7850 +//line sql.y:7841 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1601: + case 1599: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7853 +//line sql.y:7844 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1602: + case 1600: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL bool -//line sql.y:7855 +//line sql.y:7846 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1603: + case 1601: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Ignore -//line sql.y:7858 +//line sql.y:7849 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1604: + case 1602: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Ignore -//line sql.y:7860 +//line sql.y:7851 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1605: + case 1603: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7863 +//line sql.y:7854 { yyVAL.empty = struct{}{} } - case 1606: + case 1604: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7865 +//line sql.y:7856 { yyVAL.empty = struct{}{} } - case 1607: + case 1605: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7867 +//line sql.y:7858 { yyVAL.empty = struct{}{} } - case 1608: + case 1606: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:7871 +//line sql.y:7862 { yyLOCAL = &CallProc{Name: yyDollar[2].tableName, Params: yyDollar[4].exprsUnion()} } yyVAL.union = yyLOCAL - case 1609: + case 1607: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:7876 +//line sql.y:7867 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1610: + case 1608: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Exprs -//line sql.y:7880 +//line sql.y:7871 { yyLOCAL = yyDollar[1].exprsUnion() } yyVAL.union = yyLOCAL - case 1611: + case 1609: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:7885 +//line sql.y:7876 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1612: + case 1610: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:7887 +//line sql.y:7878 { yyLOCAL = []*IndexOption{yyDollar[1].indexOptionUnion()} } yyVAL.union = yyLOCAL - case 1613: + case 1611: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:7891 +//line sql.y:7882 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str), String: string(yyDollar[2].identifierCI.String())} } yyVAL.union = yyLOCAL - case 1614: + case 1612: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7897 +//line sql.y:7888 { yyVAL.identifierCI = yyDollar[1].identifierCI } - case 1615: + case 1613: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7901 +//line sql.y:7892 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } - case 1617: + case 1615: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7908 +//line sql.y:7899 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } - case 1618: + case 1616: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7914 +//line sql.y:7905 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 1619: + case 1617: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7918 +//line sql.y:7909 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 1620: + case 1618: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7924 +//line sql.y:7915 { yyVAL.identifierCS = NewIdentifierCS("") } - case 1621: + case 1619: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7928 +//line sql.y:7919 { yyVAL.identifierCS = yyDollar[1].identifierCS } - case 1623: + case 1621: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7935 +//line sql.y:7926 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 1624: + case 1622: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:7941 +//line sql.y:7932 { yyLOCAL = &Kill{Type: yyDollar[2].killTypeUnion(), ProcesslistID: convertStringToUInt64(yyDollar[3].str)} } yyVAL.union = yyLOCAL - case 1625: + case 1623: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL KillType -//line sql.y:7947 +//line sql.y:7938 { yyLOCAL = ConnectionType } yyVAL.union = yyLOCAL - case 1626: + case 1624: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL KillType -//line sql.y:7951 +//line sql.y:7942 { yyLOCAL = ConnectionType } yyVAL.union = yyLOCAL - case 1627: + case 1625: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL KillType -//line sql.y:7955 +//line sql.y:7946 { yyLOCAL = QueryType } yyVAL.union = yyLOCAL - case 2244: + case 2242: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8600 +//line sql.y:8591 { } - case 2245: + case 2243: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8605 +//line sql.y:8596 { } - case 2246: + case 2244: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8609 +//line sql.y:8600 { skipToEnd(yylex) } - case 2247: + case 2245: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8614 +//line sql.y:8605 { skipToEnd(yylex) } - case 2248: + case 2246: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8618 +//line sql.y:8609 { skipToEnd(yylex) } - case 2249: + case 2247: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8622 +//line sql.y:8613 { skipToEnd(yylex) } diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index 38af54c7323..09aa8705e17 100644 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -469,7 +469,7 @@ func markBindVariable(yylex yyLexer, bvar string) { %type cache_opt separator_opt flush_option for_channel_opt maxvalue %type match_option %type distinct_opt union_op replace_opt local_opt -%type select_expression_list select_expression_list_opt +%type select_expression_list %type select_expression %type select_options select_options_opt flush_option_list %type select_option algorithm_view security_view security_view_opt @@ -4793,15 +4793,6 @@ deallocate_statement: $$ = &DeallocateStmt{Comments: Comments($2).Parsed(), Name: $4} } -select_expression_list_opt: - { - $$ = nil - } -| select_expression_list - { - $$ = $1 - } - select_options_opt: { $$ = nil @@ -5860,11 +5851,11 @@ expression_list: introduce side effects due to being a simple identifier */ function_call_generic: - sql_id openb select_expression_list_opt closeb + sql_id openb expression_list_opt closeb { $$ = &FuncExpr{Name: $1, Exprs: $3} } -| table_id '.' reserved_sql_id openb select_expression_list_opt closeb +| table_id '.' reserved_sql_id openb expression_list_opt closeb { $$ = &FuncExpr{Qualifier: $1, Name: $3, Exprs: $5} } @@ -5874,11 +5865,11 @@ function_call_generic: as a result */ function_call_keyword: - LEFT openb select_expression_list closeb + LEFT openb expression_list_opt closeb { $$ = &FuncExpr{Name: NewIdentifierCI("left"), Exprs: $3} } -| RIGHT openb select_expression_list closeb +| RIGHT openb expression_list_opt closeb { $$ = &FuncExpr{Name: NewIdentifierCI("right"), Exprs: $3} } @@ -7020,23 +7011,23 @@ func_datetime_precision: the names are non-reserved, they need a dedicated rule so as not to conflict */ function_call_conflict: - IF openb select_expression_list closeb + IF openb expression_list closeb { $$ = &FuncExpr{Name: NewIdentifierCI("if"), Exprs: $3} } -| DATABASE openb select_expression_list_opt closeb +| DATABASE openb expression_list_opt closeb { $$ = &FuncExpr{Name: NewIdentifierCI("database"), Exprs: $3} } -| SCHEMA openb select_expression_list_opt closeb +| SCHEMA openb expression_list_opt closeb { $$ = &FuncExpr{Name: NewIdentifierCI("schema"), Exprs: $3} } -| MOD openb select_expression_list closeb +| MOD openb expression_list closeb { $$ = &FuncExpr{Name: NewIdentifierCI("mod"), Exprs: $3} } -| REPLACE openb select_expression_list closeb +| REPLACE openb expression_list closeb { $$ = &FuncExpr{Name: NewIdentifierCI("replace"), Exprs: $3} } diff --git a/go/vt/sqlparser/testdata/select_cases.txt b/go/vt/sqlparser/testdata/select_cases.txt index b7d1a32c894..e602eb1ec32 100644 --- a/go/vt/sqlparser/testdata/select_cases.txt +++ b/go/vt/sqlparser/testdata/select_cases.txt @@ -8384,7 +8384,7 @@ INPUT select quote(concat('abc'', 'cba')); END ERROR -syntax error at position 37 near '));' +syntax error at position 33 near 'cba' END INPUT select max(t1.a1), max(t2.a1) from t1, t2 where t2.a2=9; diff --git a/go/vt/vtctl/workflow/materializer.go b/go/vt/vtctl/workflow/materializer.go index a965d801cee..4812953f507 100644 --- a/go/vt/vtctl/workflow/materializer.go +++ b/go/vt/vtctl/workflow/materializer.go @@ -222,13 +222,13 @@ func (mz *materializer) generateInserts(ctx context.Context, sourceShards []*top } mappedCols = append(mappedCols, colName) } - subExprs := make(sqlparser.SelectExprs, 0, len(mappedCols)+2) + subExprs := make(sqlparser.Exprs, 0, len(mappedCols)+2) for _, mappedCol := range mappedCols { - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: mappedCol}) + subExprs = append(subExprs, mappedCol) } vindexName := fmt.Sprintf("%s.%s", mz.ms.TargetKeyspace, cv.Name) - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(vindexName)}) - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral("{{.keyrange}}")}) + subExprs = append(subExprs, sqlparser.NewStrLiteral(vindexName)) + subExprs = append(subExprs, sqlparser.NewStrLiteral("{{.keyrange}}")) inKeyRange := &sqlparser.FuncExpr{ Name: sqlparser.NewIdentifierCI("in_keyrange"), Exprs: subExprs, @@ -321,13 +321,13 @@ func (mz *materializer) generateBinlogSources(ctx context.Context, targetShard * } mappedCols = append(mappedCols, colName) } - subExprs := make(sqlparser.SelectExprs, 0, len(mappedCols)+2) + subExprs := make(sqlparser.Exprs, 0, len(mappedCols)+2) for _, mappedCol := range mappedCols { - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: mappedCol}) + subExprs = append(subExprs, mappedCol) } vindexName := fmt.Sprintf("%s.%s", mz.ms.TargetKeyspace, cv.Name) - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(vindexName)}) - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(key.KeyRangeString(targetShard.KeyRange))}) + subExprs = append(subExprs, sqlparser.NewStrLiteral(vindexName)) + subExprs = append(subExprs, sqlparser.NewStrLiteral(key.KeyRangeString(targetShard.KeyRange))) inKeyRange := &sqlparser.FuncExpr{ Name: sqlparser.NewIdentifierCI("in_keyrange"), Exprs: subExprs, diff --git a/go/vt/vtctl/workflow/stream_migrator.go b/go/vt/vtctl/workflow/stream_migrator.go index 7d225f6dd9f..751ad5c49dd 100644 --- a/go/vt/vtctl/workflow/stream_migrator.go +++ b/go/vt/vtctl/workflow/stream_migrator.go @@ -713,7 +713,7 @@ func (sm *StreamMigrator) templatizeKeyRange(ctx context.Context, rule *binlogda continue } - var krExpr sqlparser.SelectExpr + var krExpr sqlparser.Expr switch len(funcExpr.Exprs) { case 1: krExpr = funcExpr.Exprs[0] @@ -723,12 +723,7 @@ func (sm *StreamMigrator) templatizeKeyRange(ctx context.Context, rule *binlogda return fmt.Errorf("unexpected in_keyrange parameters: %v", sqlparser.String(funcExpr)) } - aliased, ok := krExpr.(*sqlparser.AliasedExpr) - if !ok { - return fmt.Errorf("unexpected in_keyrange parameters: %v", sqlparser.String(funcExpr)) - } - - val, ok := aliased.Expr.(*sqlparser.Literal) + val, ok := krExpr.(*sqlparser.Literal) if !ok { return fmt.Errorf("unexpected in_keyrange parameters: %v", sqlparser.String(funcExpr)) } @@ -746,10 +741,10 @@ func (sm *StreamMigrator) templatizeKeyRange(ctx context.Context, rule *binlogda vtable := sm.ts.SourceKeyspaceSchema().Tables[rule.Match] inkr := &sqlparser.FuncExpr{ Name: sqlparser.NewIdentifierCI("in_keyrange"), - Exprs: sqlparser.SelectExprs{ - &sqlparser.AliasedExpr{Expr: &sqlparser.ColName{Name: vtable.ColumnVindexes[0].Columns[0]}}, - &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(vtable.ColumnVindexes[0].Type)}, - &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral("{{.}}")}, + Exprs: sqlparser.Exprs{ + &sqlparser.ColName{Name: vtable.ColumnVindexes[0].Columns[0]}, + sqlparser.NewStrLiteral(vtable.ColumnVindexes[0].Type), + sqlparser.NewStrLiteral("{{.}}"), }, } sel.AddWhere(inkr) diff --git a/go/vt/vtgate/evalengine/translate_builtin.go b/go/vt/vtgate/evalengine/translate_builtin.go index cabe406bfb6..97900c98e57 100644 --- a/go/vt/vtgate/evalengine/translate_builtin.go +++ b/go/vt/vtgate/evalengine/translate_builtin.go @@ -47,11 +47,7 @@ func (ast *astCompiler) translateFuncArgs(fnargs []sqlparser.Expr) ([]IR, error) func (ast *astCompiler) translateFuncExpr(fn *sqlparser.FuncExpr) (IR, error) { var args TupleExpr for _, expr := range fn.Exprs { - aliased, ok := expr.(*sqlparser.AliasedExpr) - if !ok { - return nil, translateExprNotSupported(fn) - } - convertedExpr, err := ast.translateExpr(aliased.Expr) + convertedExpr, err := ast.translateExpr(expr) if err != nil { return nil, err } diff --git a/go/vt/vtgate/planbuilder/operators/aggregation_pushing.go b/go/vt/vtgate/planbuilder/operators/aggregation_pushing.go index a0963929eaa..f4aa851e176 100644 --- a/go/vt/vtgate/planbuilder/operators/aggregation_pushing.go +++ b/go/vt/vtgate/planbuilder/operators/aggregation_pushing.go @@ -580,9 +580,9 @@ func coalesceFunc(e sqlparser.Expr) sqlparser.Expr { // `coalesce(e,1)` will return `e` if `e` is not `NULL`, otherwise it will return `1` return &sqlparser.FuncExpr{ Name: sqlparser.NewIdentifierCI("coalesce"), - Exprs: sqlparser.SelectExprs{ - aeWrap(e), - aeWrap(sqlparser.NewIntLiteral("1")), + Exprs: sqlparser.Exprs{ + e, + sqlparser.NewIntLiteral("1"), }, } } diff --git a/go/vt/vtgate/simplifier/expression_simplifier.go b/go/vt/vtgate/simplifier/expression_simplifier.go index 5582ac3993d..86e3471baea 100644 --- a/go/vt/vtgate/simplifier/expression_simplifier.go +++ b/go/vt/vtgate/simplifier/expression_simplifier.go @@ -177,12 +177,8 @@ func (s *shrinker) fillQueue() bool { s.queue = append(s.queue, append(e[:i], e[i+1:]...)) } case *sqlparser.FuncExpr: - for _, ae := range e.Exprs { - expr, ok := ae.(*sqlparser.AliasedExpr) - if !ok { - continue - } - s.queue = append(s.queue, expr.Expr) + for _, expr := range e.Exprs { + s.queue = append(s.queue, expr) } case sqlparser.AggrFunc: for _, ae := range e.GetArgs() { diff --git a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go index 7ad83a3ad4b..1b64662e551 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go +++ b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go @@ -864,10 +864,10 @@ func (td *tableDiffer) adjustForSourceTimeZone(targetSelectExprs sqlparser.Selec if fieldType == querypb.Type_DATETIME { convertTZFuncExpr = &sqlparser.FuncExpr{ Name: sqlparser.NewIdentifierCI("convert_tz"), - Exprs: sqlparser.SelectExprs{ - expr, - &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(td.wd.ct.targetTimeZone)}, - &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(td.wd.ct.sourceTimeZone)}, + Exprs: sqlparser.Exprs{ + selExpr.Expr, + sqlparser.NewStrLiteral(td.wd.ct.targetTimeZone), + sqlparser.NewStrLiteral(td.wd.ct.sourceTimeZone), }, } log.Infof("converting datetime column %s using convert_tz()", colName) diff --git a/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go b/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go index 5f4f9ea7fb7..c3e1975c0a1 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go +++ b/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go @@ -770,9 +770,9 @@ func (plan *Plan) analyzeExpr(vschema *localVSchema, selExpr sqlparser.SelectExp // analyzeInKeyRange allows the following constructs: "in_keyrange('-80')", // "in_keyrange(col, 'hash', '-80')", "in_keyrange(col, 'local_vindex', '-80')", or // "in_keyrange(col, 'ks.external_vindex', '-80')". -func (plan *Plan) analyzeInKeyRange(vschema *localVSchema, exprs sqlparser.SelectExprs) error { +func (plan *Plan) analyzeInKeyRange(vschema *localVSchema, exprs sqlparser.Exprs) error { var colnames []sqlparser.IdentifierCI - var krExpr sqlparser.SelectExpr + var krExpr sqlparser.Expr whereFilter := Filter{ Opcode: VindexMatch, } @@ -787,14 +787,10 @@ func (plan *Plan) analyzeInKeyRange(vschema *localVSchema, exprs sqlparser.Selec krExpr = exprs[0] case len(exprs) >= 3: for _, expr := range exprs[:len(exprs)-2] { - aexpr, ok := expr.(*sqlparser.AliasedExpr) + qualifiedName, ok := expr.(*sqlparser.ColName) if !ok { return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "[BUG] unexpected: %T %s", expr, sqlparser.String(expr)) } - qualifiedName, ok := aexpr.Expr.(*sqlparser.ColName) - if !ok { - return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "[BUG] unexpected: %T %s", aexpr.Expr, sqlparser.String(aexpr.Expr)) - } if !qualifiedName.Qualifier.IsEmpty() { return vterrors.Errorf(vtrpcpb.Code_UNIMPLEMENTED, "unsupported qualifier for column: %v", sqlparser.String(qualifiedName)) } @@ -838,16 +834,12 @@ func (plan *Plan) analyzeInKeyRange(vschema *localVSchema, exprs sqlparser.Selec return nil } -func selString(expr sqlparser.SelectExpr) (string, error) { - aexpr, ok := expr.(*sqlparser.AliasedExpr) - if !ok { - return "", fmt.Errorf("unsupported: %v", sqlparser.String(expr)) - } - val, ok := aexpr.Expr.(*sqlparser.Literal) +func selString(expr sqlparser.Expr) (string, error) { + val, ok := expr.(*sqlparser.Literal) if !ok { return "", fmt.Errorf("unsupported: %v", sqlparser.String(expr)) } - return string(val.Val), nil + return val.Val, nil } // buildVindexColumns builds the list of column numbers of the table diff --git a/go/vt/vttablet/tabletserver/vstreamer/planbuilder_test.go b/go/vt/vttablet/tabletserver/vstreamer/planbuilder_test.go index 19fa5ee06a2..e9721daa693 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/planbuilder_test.go +++ b/go/vt/vttablet/tabletserver/vstreamer/planbuilder_test.go @@ -591,10 +591,6 @@ func TestPlanBuilder(t *testing.T) { inTable: t1, inRule: &binlogdatapb.Rule{Match: "t1", Filter: "select id, val from t1 where in_keyrange(id)"}, outErr: `unsupported: id`, - }, { - inTable: t1, - inRule: &binlogdatapb.Rule{Match: "t1", Filter: "select id, val from t1 where in_keyrange(*, 'hash', '-80')"}, - outErr: `[BUG] unexpected: *sqlparser.StarExpr *`, }, { inTable: t1, inRule: &binlogdatapb.Rule{Match: "t1", Filter: "select id, val from t1 where in_keyrange(1, 'hash', '-80')"}, @@ -632,11 +628,6 @@ func TestPlanBuilder(t *testing.T) { inTable: t1, inRule: &binlogdatapb.Rule{Match: "t1", Filter: "select t1.id, val from t1"}, outErr: `unsupported qualifier for column: t1.id`, - }, { - // selString - inTable: t1, - inRule: &binlogdatapb.Rule{Match: "t1", Filter: "select id, val from t1 where in_keyrange(id, *, '-80')"}, - outErr: `unsupported: *`, }, { inTable: t1, inRule: &binlogdatapb.Rule{Match: "t1", Filter: "select id, val from t1 where in_keyrange(id, 1+1, '-80')"}, diff --git a/go/vt/wrangler/materializer.go b/go/vt/wrangler/materializer.go index 5b159e35a11..707149262eb 100644 --- a/go/vt/wrangler/materializer.go +++ b/go/vt/wrangler/materializer.go @@ -134,7 +134,7 @@ func (wr *Wrangler) MoveTables(ctx context.Context, workflow, sourceKeyspace, ta cell, tabletTypesStr string, allTables bool, excludeTables string, autoStart, stopAfterCopy bool, externalCluster string, dropForeignKeys, deferSecondaryKeys bool, sourceTimeZone, onDDL string, sourceShards []string, noRoutingRules bool, atomicCopy bool) (err error) { - //FIXME validate tableSpecs, allTables, excludeTables + // FIXME validate tableSpecs, allTables, excludeTables var tables []string var externalTopo *topo.Server @@ -1205,9 +1205,9 @@ func (mz *materializer) deploySchema(ctx context.Context) error { var err error mu.Lock() if len(sourceDDLs) == 0 { - //only get ddls for tables, once and lazily: if we need to copy the schema from source to target - //we copy schemas from primaries on the source keyspace - //and we have found use cases where user just has a replica (no primary) in the source keyspace + // only get ddls for tables, once and lazily: if we need to copy the schema from source to target + // we copy schemas from primaries on the source keyspace + // and we have found use cases where user just has a replica (no primary) in the source keyspace sourceDDLs, err = mz.getSourceTableDDLs(ctx) } mu.Unlock() @@ -1391,13 +1391,13 @@ func (mz *materializer) generateInserts(ctx context.Context, sourceShards []*top } mappedCols = append(mappedCols, colName) } - subExprs := make(sqlparser.SelectExprs, 0, len(mappedCols)+2) + subExprs := make(sqlparser.Exprs, 0, len(mappedCols)+2) for _, mappedCol := range mappedCols { - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: mappedCol}) + subExprs = append(subExprs, mappedCol) } vindexName := fmt.Sprintf("%s.%s", mz.ms.TargetKeyspace, cv.Name) - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(vindexName)}) - subExprs = append(subExprs, &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral("{{.keyrange}}")}) + subExprs = append(subExprs, sqlparser.NewStrLiteral(vindexName)) + subExprs = append(subExprs, sqlparser.NewStrLiteral("{{.keyrange}}")) inKeyRange := &sqlparser.FuncExpr{ Name: sqlparser.NewIdentifierCI("in_keyrange"), Exprs: subExprs, diff --git a/go/vt/wrangler/vdiff.go b/go/vt/wrangler/vdiff.go index 70dee1261fc..2196152b122 100644 --- a/go/vt/wrangler/vdiff.go +++ b/go/vt/wrangler/vdiff.go @@ -611,10 +611,10 @@ func (df *vdiff) adjustForSourceTimeZone(targetSelectExprs sqlparser.SelectExprs if fieldType == querypb.Type_DATETIME { convertTZFuncExpr = &sqlparser.FuncExpr{ Name: sqlparser.NewIdentifierCI("convert_tz"), - Exprs: sqlparser.SelectExprs{ - expr, - &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(df.targetTimeZone)}, - &sqlparser.AliasedExpr{Expr: sqlparser.NewStrLiteral(df.sourceTimeZone)}, + Exprs: sqlparser.Exprs{ + colAs, + sqlparser.NewStrLiteral(df.targetTimeZone), + sqlparser.NewStrLiteral(df.sourceTimeZone), }, } log.Infof("converting datetime column %s using convert_tz()", colName) From aba0d83c8ae23c493fe2af76b39d68e872c3ab86 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Tue, 27 Feb 2024 07:46:55 -0500 Subject: [PATCH 62/79] CI: Address data races on memorytopo Conn.closed (#15365) Signed-off-by: Matt Lord --- go/vt/topo/memorytopo/election.go | 8 ++++---- go/vt/topo/memorytopo/lock.go | 2 +- go/vt/topo/memorytopo/memorytopo.go | 7 ++++--- go/vt/topo/memorytopo/watch.go | 4 ++-- 4 files changed, 11 insertions(+), 10 deletions(-) diff --git a/go/vt/topo/memorytopo/election.go b/go/vt/topo/memorytopo/election.go index 52bbe2e93ce..0a76c202de2 100644 --- a/go/vt/topo/memorytopo/election.go +++ b/go/vt/topo/memorytopo/election.go @@ -28,7 +28,7 @@ import ( func (c *Conn) NewLeaderParticipation(name, id string) (topo.LeaderParticipation, error) { c.factory.callstats.Add([]string{"NewLeaderParticipation"}, 1) - if c.closed { + if c.closed.Load() { return nil, ErrConnectionClosed } @@ -74,7 +74,7 @@ type cLeaderParticipation struct { // WaitForLeadership is part of the topo.LeaderParticipation interface. func (mp *cLeaderParticipation) WaitForLeadership() (context.Context, error) { - if mp.c.closed { + if mp.c.closed.Load() { return nil, ErrConnectionClosed } @@ -122,7 +122,7 @@ func (mp *cLeaderParticipation) Stop() { // GetCurrentLeaderID is part of the topo.LeaderParticipation interface func (mp *cLeaderParticipation) GetCurrentLeaderID(ctx context.Context) (string, error) { - if mp.c.closed { + if mp.c.closed.Load() { return "", ErrConnectionClosed } @@ -141,7 +141,7 @@ func (mp *cLeaderParticipation) GetCurrentLeaderID(ctx context.Context) (string, // WaitForNewLeader is part of the topo.LeaderParticipation interface func (mp *cLeaderParticipation) WaitForNewLeader(ctx context.Context) (<-chan string, error) { - if mp.c.closed { + if mp.c.closed.Load() { return nil, ErrConnectionClosed } diff --git a/go/vt/topo/memorytopo/lock.go b/go/vt/topo/memorytopo/lock.go index 0545ba8b182..afce7868469 100644 --- a/go/vt/topo/memorytopo/lock.go +++ b/go/vt/topo/memorytopo/lock.go @@ -116,7 +116,7 @@ func (ld *memoryTopoLockDescriptor) Unlock(ctx context.Context) error { } func (c *Conn) unlock(ctx context.Context, dirPath string) error { - if c.closed { + if c.closed.Load() { return ErrConnectionClosed } diff --git a/go/vt/topo/memorytopo/memorytopo.go b/go/vt/topo/memorytopo/memorytopo.go index 55057b62468..abf99e760c3 100644 --- a/go/vt/topo/memorytopo/memorytopo.go +++ b/go/vt/topo/memorytopo/memorytopo.go @@ -25,6 +25,7 @@ import ( "math/rand" "strings" "sync" + "sync/atomic" "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/log" @@ -134,13 +135,13 @@ type Conn struct { factory *Factory cell string serverAddr string - closed bool + closed atomic.Bool } // dial returns immediately, unless the Conn points to the sentinel // UnreachableServerAddr, in which case it will block until the context expires. func (c *Conn) dial(ctx context.Context) error { - if c.closed { + if c.closed.Load() { return ErrConnectionClosed } if c.serverAddr == UnreachableServerAddr { @@ -153,7 +154,7 @@ func (c *Conn) dial(ctx context.Context) error { // Close is part of the topo.Conn interface. func (c *Conn) Close() { c.factory.callstats.Add([]string{"Close"}, 1) - c.closed = true + c.closed.Store(true) } type watch struct { diff --git a/go/vt/topo/memorytopo/watch.go b/go/vt/topo/memorytopo/watch.go index 8d9ef5cb54c..3651bcca9ce 100644 --- a/go/vt/topo/memorytopo/watch.go +++ b/go/vt/topo/memorytopo/watch.go @@ -27,7 +27,7 @@ import ( func (c *Conn) Watch(ctx context.Context, filePath string) (*topo.WatchData, <-chan *topo.WatchData, error) { c.factory.callstats.Add([]string{"Watch"}, 1) - if c.closed { + if c.closed.Load() { return nil, nil, ErrConnectionClosed } @@ -79,7 +79,7 @@ func (c *Conn) Watch(ctx context.Context, filePath string) (*topo.WatchData, <-c func (c *Conn) WatchRecursive(ctx context.Context, dirpath string) ([]*topo.WatchDataRecursive, <-chan *topo.WatchDataRecursive, error) { c.factory.callstats.Add([]string{"WatchRecursive"}, 1) - if c.closed { + if c.closed.Load() { return nil, nil, ErrConnectionClosed } From 69604edbebfceb98a4056a67048005e413f9d941 Mon Sep 17 00:00:00 2001 From: yohei yoshimuta Date: Tue, 27 Feb 2024 21:48:10 +0900 Subject: [PATCH 63/79] Add initialize_with_vt_dba_tcp flag to enable TCP/IP connection access to the underlying MySQL instance (#15354) Signed-off-by: Yohei Yoshimuta --- go/cmd/vttestserver/cli/main.go | 51 ++++++++++++++++++++-------- go/cmd/vttestserver/cli/main_test.go | 33 ++++++++++++++++++ go/flags/endtoend/vttestserver.txt | 1 + go/vt/vttest/environment.go | 4 ++- go/vt/vttest/toxiproxyctl.go | 23 +++++++++---- 5 files changed, 89 insertions(+), 23 deletions(-) diff --git a/go/cmd/vttestserver/cli/main.go b/go/cmd/vttestserver/cli/main.go index 35362aa3263..2cc59f539e1 100644 --- a/go/cmd/vttestserver/cli/main.go +++ b/go/cmd/vttestserver/cli/main.go @@ -22,6 +22,7 @@ import ( "fmt" "os" "os/signal" + "path" "strconv" "strings" "syscall" @@ -47,13 +48,14 @@ type topoFlags struct { } var ( - basePort int - config vttest.Config - doSeed bool - mycnf string - protoTopo string - seed vttest.SeedConfig - topo topoFlags + basePort int + config vttest.Config + doSeed bool + mycnf string + protoTopo string + seed vttest.SeedConfig + topo topoFlags + doCreateTCPUser bool ) func (t *topoFlags) buildTopology() (*vttestpb.VTTestTopology, error) { @@ -220,25 +222,44 @@ func New() (cmd *cobra.Command) { cmd.Flags().StringVar(&config.ExternalTopoGlobalRoot, "external_topo_global_root", "", "the path of the global topology data in the global topology server for vtcombo process") cmd.Flags().DurationVar(&config.VtgateTabletRefreshInterval, "tablet_refresh_interval", 10*time.Second, "Interval at which vtgate refreshes tablet information from topology server.") + + cmd.Flags().BoolVar(&doCreateTCPUser, "initialize-with-vt-dba-tcp", false, "If this flag is enabled, MySQL will be initialized with an additional user named vt_dba_tcp, who will have access via TCP/IP connection.") acl.RegisterFlags(cmd.Flags()) return cmd } -func newEnv() (env vttest.Environment, err error) { - if basePort != 0 { +func newEnv() (env *vttest.LocalTestEnv, err error) { + if basePort == 0 { + env, err = vttest.NewLocalTestEnv(0) + } else { if config.DataDir == "" { env, err = vttest.NewLocalTestEnv(basePort) - if err != nil { - return - } } else { env, err = vttest.NewLocalTestEnvWithDirectory(basePort, config.DataDir) - if err != nil { - return - } } } + if err != nil { + return + } + + if doCreateTCPUser { + // The original initFile does not have any users who can access through TCP/IP connection. + // Here we update the init file to create the user. + mysqlInitFile := env.InitDBFile + createUserCmd := ` + # Admin user for TCP/IP connection with all privileges. + CREATE USER 'vt_dba_tcp'@'%'; + GRANT ALL ON *.* TO 'vt_dba_tcp'@'%'; + GRANT GRANT OPTION ON *.* TO 'vt_dba_tcp'@'%'; + ` + newInitFile := path.Join(env.Directory(), "init_db_with_vt_dba_tcp.sql") + err = vttest.WriteInitDBFile(mysqlInitFile, createUserCmd, newInitFile) + if err != nil { + return + } + env.InitDBFile = newInitFile + } if protoTopo == "" { config.Topology, err = topo.buildTopology() diff --git a/go/cmd/vttestserver/cli/main_test.go b/go/cmd/vttestserver/cli/main_test.go index dbaf256c806..98a49b5bc4e 100644 --- a/go/cmd/vttestserver/cli/main_test.go +++ b/go/cmd/vttestserver/cli/main_test.go @@ -186,6 +186,39 @@ func TestForeignKeysAndDDLModes(t *testing.T) { assert.NoError(t, err) } +// TestCreateDbaTCPUser tests that the vt_dba_tcp user is created and can connect through TCP/IP connection +// when --initialize-with-vt-dba-tcp is set to true. +func TestCreateDbaTCPUser(t *testing.T) { + conf := config + defer resetConfig(conf) + + clusterInstance, err := startCluster("--initialize-with-vt-dba-tcp=true") + assert.NoError(t, err) + defer clusterInstance.TearDown() + + defer func() { + if t.Failed() { + cluster.PrintFiles(t, clusterInstance.Env.Directory(), "init_db_with_vt_dba_tcp.sql") + } + }() + + // Ensure that the vt_dba_tcp user was created and can connect through TCP/IP connection. + ctx := context.Background() + vtParams := mysql.ConnParams{ + Host: "127.0.0.1", + Uname: "vt_dba_tcp", + Port: clusterInstance.Env.PortForProtocol("mysql", ""), + } + conn, err := mysql.Connect(ctx, &vtParams) + assert.NoError(t, err) + defer conn.Close() + + // Ensure that the existing vt_dba user remains unaffected, meaning it cannot connect through TCP/IP connection. + vtParams.Uname = "vt_dba" + _, err = mysql.Connect(ctx, &vtParams) + assert.Error(t, err) +} + func TestCanGetKeyspaces(t *testing.T) { conf := config defer resetConfig(conf) diff --git a/go/flags/endtoend/vttestserver.txt b/go/flags/endtoend/vttestserver.txt index 3ca21d3d60e..e650ef536f7 100644 --- a/go/flags/endtoend/vttestserver.txt +++ b/go/flags/endtoend/vttestserver.txt @@ -72,6 +72,7 @@ Flags: --grpc_server_keepalive_time duration After a duration of this time, if the server doesn't see any activity, it pings the client to see if the transport is still alive. (default 10s) --grpc_server_keepalive_timeout duration After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that the connection is closed. (default 10s) -h, --help help for vttestserver + --initialize-with-vt-dba-tcp If this flag is enabled, MySQL will be initialized with an additional user named vt_dba_tcp, who will have access via TCP/IP connection. --initialize_with_random_data If this flag is each table-shard will be initialized with random data. See also the 'rng_seed' and 'min_shard_size' and 'max_shard_size' flags. --keep_logs duration keep logs for this long (using ctime) (zero to keep forever) --keep_logs_by_mtime duration keep logs for this long (using mtime) (zero to keep forever) diff --git a/go/vt/vttest/environment.go b/go/vt/vttest/environment.go index 7f3ea88437a..91b38674113 100644 --- a/go/vt/vttest/environment.go +++ b/go/vt/vttest/environment.go @@ -99,6 +99,7 @@ type LocalTestEnv struct { BasePort int TmpPath string DefaultMyCnf []string + InitDBFile string Env []string EnableToxiproxy bool } @@ -133,7 +134,7 @@ func (env *LocalTestEnv) BinaryPath(binary string) string { func (env *LocalTestEnv) MySQLManager(mycnf []string, snapshot string) (MySQLManager, error) { mysqlctl := &Mysqlctl{ Binary: env.BinaryPath("mysqlctl"), - InitFile: path.Join(os.Getenv("VTROOT"), "config/init_db.sql"), + InitFile: env.InitDBFile, Directory: env.TmpPath, Port: env.PortForProtocol("mysql", ""), MyCnf: append(env.DefaultMyCnf, mycnf...), @@ -281,6 +282,7 @@ func NewLocalTestEnvWithDirectory(basePort int, directory string) (*LocalTestEnv BasePort: basePort, TmpPath: directory, DefaultMyCnf: mycnf, + InitDBFile: path.Join(os.Getenv("VTROOT"), "config/init_db.sql"), Env: []string{ fmt.Sprintf("VTDATAROOT=%s", directory), "VTTEST=endtoend", diff --git a/go/vt/vttest/toxiproxyctl.go b/go/vt/vttest/toxiproxyctl.go index 436739fcf4c..6ffc9548c07 100644 --- a/go/vt/vttest/toxiproxyctl.go +++ b/go/vt/vttest/toxiproxyctl.go @@ -63,21 +63,16 @@ func NewToxiproxyctl(binary string, apiPort, mysqlPort int, mysqlctl *Mysqlctl, // The original initFile does not have any users who can access through TCP/IP connection. // Here we update the init file to create the user. - initDb, _ := os.ReadFile(mysqlctl.InitFile) createUserCmd := fmt.Sprintf(` # Admin user for TCP/IP connection with all privileges. CREATE USER '%s'@'127.0.0.1'; GRANT ALL ON *.* TO '%s'@'127.0.0.1'; GRANT GRANT OPTION ON *.* TO '%s'@'127.0.0.1'; `, dbaUser, dbaUser, dbaUser) - sql, err := getInitDBSQL(string(initDb), createUserCmd) - if err != nil { - return nil, vterrors.Wrap(err, "failed to get a modified init db sql") - } newInitFile := path.Join(mysqlctl.Directory, "init_db_toxiproxyctl.sql") - err = os.WriteFile(newInitFile, []byte(sql), 0600) + err := WriteInitDBFile(mysqlctl.InitFile, createUserCmd, newInitFile) if err != nil { - return nil, vterrors.Wrap(err, "failed to write a modified init db file") + return nil, vterrors.Wrap(err, "failed to get a modified init db sql") } mysqlctl.InitFile = newInitFile @@ -235,6 +230,20 @@ func (ctl *Toxiproxyctl) RemoveTimeoutToxic() error { return ctl.proxy.RemoveToxic("my-timeout") } +// WriteInitDBFile is a helper function that writes a modified init_db.sql file with custom SQL statements. +func WriteInitDBFile(initFile, customSQL, newInitFile string) error { + initDb, _ := os.ReadFile(initFile) + sql, err := getInitDBSQL(string(initDb), customSQL) + if err != nil { + return vterrors.Wrap(err, "failed to get a modified init db sql") + } + err = os.WriteFile(newInitFile, []byte(sql), 0600) + if err != nil { + return vterrors.Wrap(err, "failed to write a modified init db file") + } + return nil +} + // getInitDBSQL is a helper function that retrieves the modified contents of the init_db.sql file with custom SQL statements. // We avoid using vitess.io/vitess/go/test/endtoend/utils.GetInitDBSQL as importing this package adds unnecessary flags to vttestserver. func getInitDBSQL(initDBSQL string, customSQL string) (string, error) { From fb4abd5dd8bfbf3bb911727105a15b2dd01d1739 Mon Sep 17 00:00:00 2001 From: Harshit Gangal Date: Tue, 27 Feb 2024 21:30:55 +0530 Subject: [PATCH 64/79] Multi Target Delete Support (#15294) Signed-off-by: Harshit Gangal --- .../endtoend/vtgate/queries/dml/dml_test.go | 75 +++ go/vt/vtgate/engine/cached_size.go | 22 +- go/vt/vtgate/engine/dml_with_input.go | 41 +- go/vt/vtgate/engine/dml_with_input_test.go | 78 ++- go/vt/vtgate/evalengine/cached_size.go | 2 +- go/vt/vtgate/evalengine/expr_tuple_bvar.go | 6 - go/vt/vtgate/planbuilder/delete.go | 21 +- go/vt/vtgate/planbuilder/dml_with_input.go | 11 +- .../planbuilder/operator_transformers.go | 12 +- go/vt/vtgate/planbuilder/operators/delete.go | 135 +++-- .../planbuilder/operators/dml_planning.go | 22 + .../planbuilder/operators/dml_with_input.go | 40 +- go/vt/vtgate/planbuilder/operators/phases.go | 5 +- go/vt/vtgate/planbuilder/operators/update.go | 19 +- go/vt/vtgate/planbuilder/plan_test.go | 13 + .../planbuilder/testdata/dml_cases.json | 501 +++++++++++++++++- .../testdata/foreignkey_cases.json | 25 +- .../testdata/foreignkey_checks_on_cases.json | 8 +- .../planbuilder/testdata/show_cases.json | 2 +- .../testdata/unknown_schema_cases.json | 10 + .../testdata/unsupported_cases.json | 25 - .../planbuilder/testdata/vschemas/schema.json | 47 ++ 22 files changed, 941 insertions(+), 179 deletions(-) diff --git a/go/test/endtoend/vtgate/queries/dml/dml_test.go b/go/test/endtoend/vtgate/queries/dml/dml_test.go index 561d73f44d5..deca3f01caf 100644 --- a/go/test/endtoend/vtgate/queries/dml/dml_test.go +++ b/go/test/endtoend/vtgate/queries/dml/dml_test.go @@ -293,3 +293,78 @@ func TestDeleteWithSubquery(t *testing.T) { utils.AssertMatches(t, mcmp.VtConn, `select region_id, oid, cust_no from order_tbl order by oid`, `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)]]`) } + +// TestMultiTargetDelete executed multi-target delete queries +func TestMultiTargetDelete(t *testing.T) { + utils.SkipIfBinaryIsBelowVersion(t, 20, "vtgate") + + mcmp, closer := start(t) + defer closer() + + // initial rows + mcmp.Exec("insert into order_tbl(region_id, oid, cust_no) values (1,1,4), (1,2,2), (2,3,5), (2,4,55)") + mcmp.Exec("insert into oevent_tbl(oid, ename) values (1,'a'), (2,'b'), (3,'a'), (2,'c')") + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[[INT64(1) VARCHAR("a")] [INT64(2) VARCHAR("b")] [INT64(2) VARCHAR("c")] [INT64(3) VARCHAR("a")]]`) + + // multi table delete + qr := mcmp.Exec(`delete o, ev from order_tbl o join oevent_tbl ev where o.oid = ev.oid and ev.ename = 'a'`) + assert.EqualValues(t, 4, qr.RowsAffected) + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[[INT64(2) VARCHAR("b")] [INT64(2) VARCHAR("c")]]`) + + qr = mcmp.Exec(`delete o, ev from order_tbl o join oevent_tbl ev where o.cust_no = ev.oid`) + assert.EqualValues(t, 3, qr.RowsAffected) + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[]`) +} + +// TestMultiTargetDeleteMore executed multi-target delete queries with additional cases +func TestMultiTargetDeleteMore(t *testing.T) { + utils.SkipIfBinaryIsBelowVersion(t, 20, "vtgate") + + mcmp, closer := start(t) + defer closer() + + // multi table delete on empty table. + qr := mcmp.Exec(`delete o, ev from order_tbl o join oevent_tbl ev on o.oid = ev.oid`) + assert.EqualValues(t, 0, qr.RowsAffected) + + // initial rows + mcmp.Exec("insert into order_tbl(region_id, oid, cust_no) values (1,1,4), (1,2,2), (2,3,5), (2,4,55)") + mcmp.Exec("insert into oevent_tbl(oid, ename) values (1,'a'), (2,'b'), (3,'a'), (2,'c')") + + // multi table delete on non-existent data. + qr = mcmp.Exec(`delete o, ev from order_tbl o join oevent_tbl ev on o.oid = ev.oid where ev.oid = 10`) + assert.EqualValues(t, 0, qr.RowsAffected) + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[[INT64(1) VARCHAR("a")] [INT64(2) VARCHAR("b")] [INT64(2) VARCHAR("c")] [INT64(3) VARCHAR("a")]]`) + + // multi table delete with rollback + mcmp.Exec(`begin`) + qr = mcmp.Exec(`delete o, ev from order_tbl o join oevent_tbl ev on o.oid = ev.oid where o.cust_no != 4`) + assert.EqualValues(t, 5, qr.RowsAffected) + mcmp.Exec(`rollback`) + + // check rows + mcmp.AssertMatches(`select region_id, oid, cust_no from order_tbl order by oid`, + `[[INT64(1) INT64(1) INT64(4)] [INT64(1) INT64(2) INT64(2)] [INT64(2) INT64(3) INT64(5)] [INT64(2) INT64(4) INT64(55)]]`) + mcmp.AssertMatches(`select oid, ename from oevent_tbl order by oid`, + `[[INT64(1) VARCHAR("a")] [INT64(2) VARCHAR("b")] [INT64(2) VARCHAR("c")] [INT64(3) VARCHAR("a")]]`) +} diff --git a/go/vt/vtgate/engine/cached_size.go b/go/vt/vtgate/engine/cached_size.go index 781c5904044..32ecd9ff6a9 100644 --- a/go/vt/vtgate/engine/cached_size.go +++ b/go/vt/vtgate/engine/cached_size.go @@ -185,17 +185,27 @@ func (cached *DMLWithInput) CachedSize(alloc bool) int64 { if alloc { size += int64(64) } - // field DML vitess.io/vitess/go/vt/vtgate/engine.Primitive - if cc, ok := cached.DML.(cachedObject); ok { - size += cc.CachedSize(true) - } // field Input vitess.io/vitess/go/vt/vtgate/engine.Primitive if cc, ok := cached.Input.(cachedObject); ok { size += cc.CachedSize(true) } - // field OutputCols []int + // field DMLs []vitess.io/vitess/go/vt/vtgate/engine.Primitive + { + size += hack.RuntimeAllocSize(int64(cap(cached.DMLs)) * int64(16)) + for _, elem := range cached.DMLs { + if cc, ok := elem.(cachedObject); ok { + size += cc.CachedSize(true) + } + } + } + // field OutputCols [][]int { - size += hack.RuntimeAllocSize(int64(cap(cached.OutputCols)) * int64(8)) + size += hack.RuntimeAllocSize(int64(cap(cached.OutputCols)) * int64(24)) + for _, elem := range cached.OutputCols { + { + size += hack.RuntimeAllocSize(int64(cap(elem)) * int64(8)) + } + } } return size } diff --git a/go/vt/vtgate/engine/dml_with_input.go b/go/vt/vtgate/engine/dml_with_input.go index 87d7c1d9826..28b306511df 100644 --- a/go/vt/vtgate/engine/dml_with_input.go +++ b/go/vt/vtgate/engine/dml_with_input.go @@ -18,6 +18,7 @@ package engine import ( "context" + "fmt" topodatapb "vitess.io/vitess/go/vt/proto/topodata" "vitess.io/vitess/go/vt/vterrors" @@ -34,10 +35,10 @@ const DmlVals = "dml_vals" type DMLWithInput struct { txNeeded - DML Primitive Input Primitive - OutputCols []int + DMLs []Primitive + OutputCols [][]int } func (dml *DMLWithInput) RouteType() string { @@ -53,7 +54,7 @@ func (dml *DMLWithInput) GetTableName() string { } func (dml *DMLWithInput) Inputs() ([]Primitive, []map[string]any) { - return []Primitive{dml.Input, dml.DML}, nil + return append([]Primitive{dml.Input}, dml.DMLs...), nil } // TryExecute performs a non-streaming exec. @@ -66,15 +67,27 @@ func (dml *DMLWithInput) TryExecute(ctx context.Context, vcursor VCursor, bindVa return &sqltypes.Result{}, nil } - var bv *querypb.BindVariable - if len(dml.OutputCols) == 1 { - bv = getBVSingle(inputRes, dml.OutputCols[0]) - } else { - bv = getBVMulti(inputRes, dml.OutputCols) - } + var res *sqltypes.Result + for idx, prim := range dml.DMLs { + var bv *querypb.BindVariable + if len(dml.OutputCols[idx]) == 1 { + bv = getBVSingle(inputRes, dml.OutputCols[idx][0]) + } else { + bv = getBVMulti(inputRes, dml.OutputCols[idx]) + } - bindVars[DmlVals] = bv - return vcursor.ExecutePrimitive(ctx, dml.DML, bindVars, false) + bindVars[DmlVals] = bv + qr, err := vcursor.ExecutePrimitive(ctx, prim, bindVars, false) + if err != nil { + return nil, err + } + if res == nil { + res = qr + } else { + res.RowsAffected += qr.RowsAffected + } + } + return res, nil } func getBVSingle(res *sqltypes.Result, offset int) *querypb.BindVariable { @@ -113,8 +126,12 @@ func (dml *DMLWithInput) GetFields(context.Context, VCursor, map[string]*querypb } func (dml *DMLWithInput) description() PrimitiveDescription { + var offsets []string + for idx, offset := range dml.OutputCols { + offsets = append(offsets, fmt.Sprintf("%d:%v", idx, offset)) + } other := map[string]any{ - "Offset": dml.OutputCols, + "Offset": offsets, } return PrimitiveDescription{ OperatorType: "DMLWithInput", diff --git a/go/vt/vtgate/engine/dml_with_input_test.go b/go/vt/vtgate/engine/dml_with_input_test.go index fb75ae70f1d..e43bc2b151f 100644 --- a/go/vt/vtgate/engine/dml_with_input_test.go +++ b/go/vt/vtgate/engine/dml_with_input_test.go @@ -24,6 +24,7 @@ import ( "vitess.io/vitess/go/sqltypes" querypb "vitess.io/vitess/go/vt/proto/query" + "vitess.io/vitess/go/vt/vtgate/evalengine" "vitess.io/vitess/go/vt/vtgate/vindexes" ) @@ -34,7 +35,7 @@ func TestDeleteWithInputSingleOffset(t *testing.T) { del := &DMLWithInput{ Input: input, - DML: &Delete{ + DMLs: []Primitive{&Delete{ DML: &DML{ RoutingParameters: &RoutingParameters{ Opcode: Scatter, @@ -45,8 +46,8 @@ func TestDeleteWithInputSingleOffset(t *testing.T) { }, Query: "dummy_delete", }, - }, - OutputCols: []int{0}, + }}, + OutputCols: [][]int{{0}}, } vc := newDMLTestVCursor("-20", "20-") @@ -78,7 +79,7 @@ func TestDeleteWithInputMultiOffset(t *testing.T) { del := &DMLWithInput{ Input: input, - DML: &Delete{ + DMLs: []Primitive{&Delete{ DML: &DML{ RoutingParameters: &RoutingParameters{ Opcode: Scatter, @@ -89,8 +90,8 @@ func TestDeleteWithInputMultiOffset(t *testing.T) { }, Query: "dummy_delete", }, - }, - OutputCols: []int{1, 0}, + }}, + OutputCols: [][]int{{1, 0}}, } vc := newDMLTestVCursor("-20", "20-") @@ -114,3 +115,68 @@ func TestDeleteWithInputMultiOffset(t *testing.T) { `ks.20-: dummy_delete {dml_vals: type:TUPLE values:{type:TUPLE value:"\x950\x01a\x89\x02\x011"} values:{type:TUPLE value:"\x950\x01b\x89\x02\x012"} values:{type:TUPLE value:"\x950\x01c\x89\x02\x013"}} true false`, }) } + +func TestDeleteWithMultiTarget(t *testing.T) { + input := &fakePrimitive{results: []*sqltypes.Result{ + sqltypes.MakeTestResult( + sqltypes.MakeTestFields("id|id|user_id", "int64|int64|int64"), + "1|100|1", "2|100|2", "3|200|3"), + }} + + vindex, _ := vindexes.CreateVindex("hash", "", nil) + + del1 := &Delete{ + DML: &DML{ + RoutingParameters: &RoutingParameters{ + Opcode: IN, + Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true}, + Vindex: vindex, + Values: []evalengine.Expr{ + &evalengine.BindVariable{Key: "dml_vals", Type: sqltypes.Tuple}, + }, + }, + Query: "dummy_delete_1", + }, + } + + del2 := &Delete{ + DML: &DML{ + RoutingParameters: &RoutingParameters{ + Opcode: MultiEqual, + Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true}, + Vindex: vindex, + Values: []evalengine.Expr{ + &evalengine.TupleBindVariable{Key: "dml_vals", Index: 1}, + }, + }, + Query: "dummy_delete_2", + }, + } + + del := &DMLWithInput{ + Input: input, + DMLs: []Primitive{del1, del2}, + OutputCols: [][]int{{0}, {1, 2}}, + } + + vc := newDMLTestVCursor("-20", "20-") + _, err := del.TryExecute(context.Background(), vc, map[string]*querypb.BindVariable{}, false) + require.NoError(t, err) + vc.ExpectLog(t, []string{ + `ResolveDestinations ks [type:INT64 value:"1" type:INT64 value:"2" type:INT64 value:"3"] Destinations:DestinationKeyspaceID(166b40b44aba4bd6),DestinationKeyspaceID(06e7ea22ce92708f),DestinationKeyspaceID(4eb190c9a2fa169c)`, + `ExecuteMultiShard ks.-20: dummy_delete_1 {dml_vals: type:TUPLE values:{type:INT64 value:"1"} values:{type:INT64 value:"2"} values:{type:INT64 value:"3"}} true true`, + `ResolveDestinations ks [type:INT64 value:"1" type:INT64 value:"2" type:INT64 value:"3"] Destinations:DestinationKeyspaceID(166b40b44aba4bd6),DestinationKeyspaceID(06e7ea22ce92708f),DestinationKeyspaceID(4eb190c9a2fa169c)`, + `ExecuteMultiShard ks.-20: dummy_delete_2 {dml_vals: type:TUPLE values:{type:TUPLE value:"\x89\x02\x03100\x89\x02\x011"} values:{type:TUPLE value:"\x89\x02\x03100\x89\x02\x012"} values:{type:TUPLE value:"\x89\x02\x03200\x89\x02\x013"}} true true`, + }) + + vc.Rewind() + input.rewind() + err = del.TryStreamExecute(context.Background(), vc, map[string]*querypb.BindVariable{}, false, func(result *sqltypes.Result) error { return nil }) + require.NoError(t, err) + vc.ExpectLog(t, []string{ + `ResolveDestinations ks [type:INT64 value:"1" type:INT64 value:"2" type:INT64 value:"3"] Destinations:DestinationKeyspaceID(166b40b44aba4bd6),DestinationKeyspaceID(06e7ea22ce92708f),DestinationKeyspaceID(4eb190c9a2fa169c)`, + `ExecuteMultiShard ks.-20: dummy_delete_1 {dml_vals: type:TUPLE values:{type:INT64 value:"1"} values:{type:INT64 value:"2"} values:{type:INT64 value:"3"}} true true`, + `ResolveDestinations ks [type:INT64 value:"1" type:INT64 value:"2" type:INT64 value:"3"] Destinations:DestinationKeyspaceID(166b40b44aba4bd6),DestinationKeyspaceID(06e7ea22ce92708f),DestinationKeyspaceID(4eb190c9a2fa169c)`, + `ExecuteMultiShard ks.-20: dummy_delete_2 {dml_vals: type:TUPLE values:{type:TUPLE value:"\x89\x02\x03100\x89\x02\x011"} values:{type:TUPLE value:"\x89\x02\x03100\x89\x02\x012"} values:{type:TUPLE value:"\x89\x02\x03200\x89\x02\x013"}} true true`, + }) +} diff --git a/go/vt/vtgate/evalengine/cached_size.go b/go/vt/vtgate/evalengine/cached_size.go index b386d3dc915..72bfbafed73 100644 --- a/go/vt/vtgate/evalengine/cached_size.go +++ b/go/vt/vtgate/evalengine/cached_size.go @@ -373,7 +373,7 @@ func (cached *TupleBindVariable) CachedSize(alloc bool) int64 { } size := int64(0) if alloc { - size += int64(48) + size += int64(32) } // field Key string size += hack.RuntimeAllocSize(int64(len(cached.Key))) diff --git a/go/vt/vtgate/evalengine/expr_tuple_bvar.go b/go/vt/vtgate/evalengine/expr_tuple_bvar.go index b8e506eaff5..3b2553f25ba 100644 --- a/go/vt/vtgate/evalengine/expr_tuple_bvar.go +++ b/go/vt/vtgate/evalengine/expr_tuple_bvar.go @@ -32,12 +32,6 @@ type ( Index int Type sqltypes.Type Collation collations.ID - - // dynamicTypeOffset is set when the type of this bind variable cannot be calculated - // at translation time. Since expressions with dynamic types cannot be compiled ahead of time, - // compilation will be delayed until the expression is first executed with the bind variables - // sent by the user. See: UntypedExpr - dynamicTypeOffset int } ) diff --git a/go/vt/vtgate/planbuilder/delete.go b/go/vt/vtgate/planbuilder/delete.go index a613c158ab7..6d56a41c6df 100644 --- a/go/vt/vtgate/planbuilder/delete.go +++ b/go/vt/vtgate/planbuilder/delete.go @@ -23,7 +23,6 @@ import ( "vitess.io/vitess/go/vt/vtgate/engine" "vitess.io/vitess/go/vt/vtgate/planbuilder/operators" "vitess.io/vitess/go/vt/vtgate/planbuilder/plancontext" - "vitess.io/vitess/go/vt/vtgate/semantics" "vitess.io/vitess/go/vt/vtgate/vindexes" ) @@ -68,8 +67,10 @@ func gen4DeleteStmtPlanner( } } - if err := checkIfDeleteSupported(deleteStmt, ctx.SemTable); err != nil { - return nil, err + // error out here if delete query cannot bypass the planner and + // planner cannot plan such query due to different reason like missing full information, etc. + if ctx.SemTable.NotUnshardedErr != nil { + return nil, ctx.SemTable.NotUnshardedErr } op, err := operators.PlanQuery(ctx, deleteStmt) @@ -132,17 +133,3 @@ func deleteUnshardedShortcut(stmt *sqlparser.Delete, ks *vindexes.Keyspace, tabl } return &primitiveWrapper{prim: &engine.Delete{DML: edml}} } - -// checkIfDeleteSupported checks if the delete query is supported or we must return an error. -func checkIfDeleteSupported(del *sqlparser.Delete, semTable *semantics.SemTable) error { - if semTable.NotUnshardedErr != nil { - return semTable.NotUnshardedErr - } - - // Delete is only supported for single Target. - if len(del.Targets) > 1 { - return vterrors.VT12001("multi-table DELETE statement with multi-target") - } - - return nil -} diff --git a/go/vt/vtgate/planbuilder/dml_with_input.go b/go/vt/vtgate/planbuilder/dml_with_input.go index 1b6d1c0835a..729314e0fc9 100644 --- a/go/vt/vtgate/planbuilder/dml_with_input.go +++ b/go/vt/vtgate/planbuilder/dml_with_input.go @@ -22,9 +22,9 @@ import ( type dmlWithInput struct { input logicalPlan - dml logicalPlan + dmls []logicalPlan - outputCols []int + outputCols [][]int } var _ logicalPlan = (*dmlWithInput)(nil) @@ -32,9 +32,12 @@ var _ logicalPlan = (*dmlWithInput)(nil) // Primitive implements the logicalPlan interface func (d *dmlWithInput) Primitive() engine.Primitive { inp := d.input.Primitive() - del := d.dml.Primitive() + var dels []engine.Primitive + for _, dml := range d.dmls { + dels = append(dels, dml.Primitive()) + } return &engine.DMLWithInput{ - DML: del, + DMLs: dels, Input: inp, OutputCols: d.outputCols, } diff --git a/go/vt/vtgate/planbuilder/operator_transformers.go b/go/vt/vtgate/planbuilder/operator_transformers.go index 577e585351d..4d5a5642dac 100644 --- a/go/vt/vtgate/planbuilder/operator_transformers.go +++ b/go/vt/vtgate/planbuilder/operator_transformers.go @@ -87,13 +87,17 @@ func transformDMLWithInput(ctx *plancontext.PlanningContext, op *operators.DMLWi return nil, err } - del, err := transformToLogicalPlan(ctx, op.DML) - if err != nil { - return nil, err + var dmls []logicalPlan + for _, dml := range op.DML { + del, err := transformToLogicalPlan(ctx, dml) + if err != nil { + return nil, err + } + dmls = append(dmls, del) } return &dmlWithInput{ input: input, - dml: del, + dmls: dmls, outputCols: op.Offsets, }, nil } diff --git a/go/vt/vtgate/planbuilder/operators/delete.go b/go/vt/vtgate/planbuilder/operators/delete.go index c22da14c35f..7ce321378d0 100644 --- a/go/vt/vtgate/planbuilder/operators/delete.go +++ b/go/vt/vtgate/planbuilder/operators/delete.go @@ -17,8 +17,9 @@ limitations under the License. package operators import ( - "fmt" + "sort" + "vitess.io/vitess/go/slice" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vtgate/engine" @@ -34,15 +35,11 @@ type Delete struct { noPredicates } -type TargetTable struct { - ID semantics.TableSet - VTable *vindexes.Table - Name sqlparser.TableName -} - -// Introduces implements the PhysicalOperator interface -func (d *Delete) introducesTableID() semantics.TableSet { - return d.Target.ID +// delOp stores intermediary value for Delete Operator with the vindexes.Table for ordering. +type delOp struct { + op Operator + vTbl *vindexes.Table + cols []*sqlparser.ColName } // Clone implements the Operator interface @@ -63,28 +60,16 @@ func (d *Delete) SetInputs(inputs []Operator) { d.Source = inputs[0] } -func (d *Delete) TablesUsed() []string { - return SingleQualifiedIdentifier(d.Target.VTable.Keyspace, d.Target.VTable.Name) -} - func (d *Delete) GetOrdering(*plancontext.PlanningContext) []OrderBy { return nil } +func (d *Delete) TablesUsed() []string { + return SingleQualifiedIdentifier(d.Target.VTable.Keyspace, d.Target.VTable.Name) +} + func (d *Delete) ShortDescription() string { - ovq := "" - if d.OwnedVindexQuery != nil { - var cols, orderby, limit string - cols = fmt.Sprintf("COLUMNS: [%s]", sqlparser.String(d.OwnedVindexQuery.SelectExprs)) - if len(d.OwnedVindexQuery.OrderBy) > 0 { - orderby = fmt.Sprintf(" ORDERBY: [%s]", sqlparser.String(d.OwnedVindexQuery.OrderBy)) - } - if d.OwnedVindexQuery.Limit != nil { - limit = fmt.Sprintf(" LIMIT: [%s]", sqlparser.String(d.OwnedVindexQuery.Limit)) - } - ovq = fmt.Sprintf(" vindexQuery(%s%s%s)", cols, orderby, limit) - } - return fmt.Sprintf("%s.%s%s", d.Target.VTable.Keyspace.Name, d.Target.VTable.Name.String(), ovq) + return shortDesc(d.Target, d.OwnedVindexQuery) } func createOperatorFromDelete(ctx *plancontext.PlanningContext, deleteStmt *sqlparser.Delete) (op Operator) { @@ -94,7 +79,7 @@ func createOperatorFromDelete(ctx *plancontext.PlanningContext, deleteStmt *sqlp // slower, because it does a selection and then creates a delete statement wherein we have to // list all the primary key values. if deleteWithInputPlanningRequired(childFks, deleteStmt) { - return deleteWithInputPlanningForFk(ctx, deleteStmt) + return createDeleteWithInputOp(ctx, deleteStmt) } delClone := sqlparser.CloneRefOfDelete(deleteStmt) @@ -117,6 +102,12 @@ func createOperatorFromDelete(ctx *plancontext.PlanningContext, deleteStmt *sqlp } func deleteWithInputPlanningRequired(childFks []vindexes.ChildFKInfo, deleteStmt *sqlparser.Delete) bool { + if len(deleteStmt.Targets) > 1 { + if len(childFks) > 0 { + panic(vterrors.VT12001("multi table delete with foreign keys")) + } + return true + } // If there are no foreign keys, we don't need to use delete with input. if len(childFks) == 0 { return false @@ -132,7 +123,7 @@ func deleteWithInputPlanningRequired(childFks []vindexes.ChildFKInfo, deleteStmt return !deleteStmt.IsSingleAliasExpr() } -func deleteWithInputPlanningForFk(ctx *plancontext.PlanningContext, del *sqlparser.Delete) Operator { +func createDeleteWithInputOp(ctx *plancontext.PlanningContext, del *sqlparser.Delete) (op Operator) { delClone := ctx.SemTable.Clone(del).(*sqlparser.Delete) del.Limit = nil del.OrderBy = nil @@ -144,18 +135,81 @@ func deleteWithInputPlanningForFk(ctx *plancontext.PlanningContext, del *sqlpars Limit: delClone.Limit, Lock: sqlparser.ForUpdateLock, } - ts := ctx.SemTable.Targets[del.Targets[0].Name] + + var delOps []delOp + for _, target := range del.Targets { + op := createDeleteOpWithTarget(ctx, target) + delOps = append(delOps, op) + } + + // sort the operator based on sharding vindex type. + // Unsharded < Lookup Vindex < Any + // This is needed to ensure all the rows are deleted from unowned sharding tables first. + // Otherwise, those table rows will be missed from getting deleted as + // the owned table row won't have matching values. + sort.Slice(delOps, func(i, j int) bool { + a, b := delOps[i], delOps[j] + // Get the first Vindex of a and b, if available + aVdx, bVdx := getFirstVindex(a.vTbl), getFirstVindex(b.vTbl) + + // Sort nil Vindexes to the start + if aVdx == nil || bVdx == nil { + return aVdx != nil // true if bVdx is nil and aVdx is not nil + } + + // Among non-nil Vindexes, those that need VCursor come first + return aVdx.NeedsVCursor() && !bVdx.NeedsVCursor() + }) + + // now map the operator and column list. + var colsList [][]*sqlparser.ColName + dmls := slice.Map(delOps, func(from delOp) Operator { + colsList = append(colsList, from.cols) + for _, col := range from.cols { + selectStmt.SelectExprs = append(selectStmt.SelectExprs, aeWrap(col)) + } + return from.op + }) + + op = &DMLWithInput{ + DML: dmls, + Source: createOperatorFromSelect(ctx, selectStmt), + cols: colsList, + } + + if del.Comments != nil { + op = &LockAndComment{ + Source: op, + Comments: del.Comments, + } + } + return op +} + +// getFirstVindex returns the first Vindex, if available +func getFirstVindex(vTbl *vindexes.Table) vindexes.Vindex { + if len(vTbl.ColumnVindexes) > 0 { + return vTbl.ColumnVindexes[0].Vindex + } + return nil +} + +func createDeleteOpWithTarget(ctx *plancontext.PlanningContext, target sqlparser.TableName) delOp { + ts := ctx.SemTable.Targets[target.Name] ti, err := ctx.SemTable.TableInfoFor(ts) if err != nil { panic(vterrors.VT13001(err.Error())) } + vTbl := ti.GetVindexTable() + if len(vTbl.PrimaryKey) == 0 { + panic(vterrors.VT09015()) + } var leftComp sqlparser.ValTuple cols := make([]*sqlparser.ColName, 0, len(vTbl.PrimaryKey)) for _, col := range vTbl.PrimaryKey { - colName := sqlparser.NewColNameWithQualifier(col.String(), vTbl.GetTableName()) - selectStmt.SelectExprs = append(selectStmt.SelectExprs, aeWrap(colName)) + colName := sqlparser.NewColNameWithQualifier(col.String(), target) cols = append(cols, colName) leftComp = append(leftComp, colName) ctx.SemTable.Recursive[colName] = ts @@ -167,14 +221,15 @@ func deleteWithInputPlanningForFk(ctx *plancontext.PlanningContext, del *sqlpars } compExpr := sqlparser.NewComparisonExpr(sqlparser.InOp, lhs, sqlparser.ListArg(engine.DmlVals), nil) - del.Targets = sqlparser.TableNames{del.Targets[0]} - del.TableExprs = sqlparser.TableExprs{ti.GetAliasedTableExpr()} - del.Where = sqlparser.NewWhere(sqlparser.WhereClause, compExpr) - - return &DMLWithInput{ - DML: createOperatorFromDelete(ctx, del), - Source: createOperatorFromSelect(ctx, selectStmt), - cols: cols, + del := &sqlparser.Delete{ + TableExprs: sqlparser.TableExprs{ti.GetAliasedTableExpr()}, + Targets: sqlparser.TableNames{target}, + Where: sqlparser.NewWhere(sqlparser.WhereClause, compExpr), + } + return delOp{ + createOperatorFromDelete(ctx, del), + vTbl, + cols, } } diff --git a/go/vt/vtgate/planbuilder/operators/dml_planning.go b/go/vt/vtgate/planbuilder/operators/dml_planning.go index 6f71b41162e..561cfde4c1a 100644 --- a/go/vt/vtgate/planbuilder/operators/dml_planning.go +++ b/go/vt/vtgate/planbuilder/operators/dml_planning.go @@ -35,6 +35,28 @@ type DMLCommon struct { Source Operator } +type TargetTable struct { + ID semantics.TableSet + VTable *vindexes.Table + Name sqlparser.TableName +} + +func shortDesc(target TargetTable, ovq *sqlparser.Select) string { + ovqString := "" + if ovq != nil { + var cols, orderby, limit string + cols = fmt.Sprintf("COLUMNS: [%s]", sqlparser.String(ovq.SelectExprs)) + if len(ovq.OrderBy) > 0 { + orderby = fmt.Sprintf(" ORDERBY: [%s]", sqlparser.String(ovq.OrderBy)) + } + if ovq.Limit != nil { + limit = fmt.Sprintf(" LIMIT: [%s]", sqlparser.String(ovq.Limit)) + } + ovqString = fmt.Sprintf(" vindexQuery(%s%s%s)", cols, orderby, limit) + } + return fmt.Sprintf("%s.%s%s", target.VTable.Keyspace.Name, target.VTable.Name.String(), ovqString) +} + // getVindexInformation returns the vindex and VindexPlusPredicates for the DML, // If it cannot find a unique vindex match, it returns an error. func getVindexInformation(id semantics.TableSet, table *vindexes.Table) ( diff --git a/go/vt/vtgate/planbuilder/operators/dml_with_input.go b/go/vt/vtgate/planbuilder/operators/dml_with_input.go index e15a1042a47..848941b4468 100644 --- a/go/vt/vtgate/planbuilder/operators/dml_with_input.go +++ b/go/vt/vtgate/planbuilder/operators/dml_with_input.go @@ -27,10 +27,10 @@ import ( // DMLWithInput is used to represent a DML Operator taking input from a Source Operator type DMLWithInput struct { Source Operator - DML Operator - cols []*sqlparser.ColName - Offsets []int + DML []Operator + cols [][]*sqlparser.ColName + Offsets [][]int noColumns noPredicates @@ -43,26 +43,38 @@ func (d *DMLWithInput) Clone(inputs []Operator) Operator { } func (d *DMLWithInput) Inputs() []Operator { - return []Operator{d.Source, d.DML} + return append([]Operator{d.Source}, d.DML...) } func (d *DMLWithInput) SetInputs(inputs []Operator) { - if len(inputs) != 2 { + if len(inputs) < 2 { panic("unexpected number of inputs for DMLWithInput operator") } d.Source = inputs[0] - d.DML = inputs[1] + d.DML = inputs[1:] } func (d *DMLWithInput) ShortDescription() string { - colStrings := slice.Map(d.cols, func(from *sqlparser.ColName) string { + colStrings := "" + for idx, columns := range d.cols { + var offsets []int + if len(d.Offsets) > idx { + offsets = d.Offsets[idx] + } + colStrings += fmt.Sprintf("[%s]", getShortDesc(columns, offsets)) + } + return colStrings +} + +func getShortDesc(cols []*sqlparser.ColName, offsets []int) string { + colStrings := slice.Map(cols, func(from *sqlparser.ColName) string { return sqlparser.String(from) }) out := "" for idx, colString := range colStrings { out += colString - if len(d.Offsets) > idx { - out += fmt.Sprintf(":%d", d.Offsets[idx]) + if len(offsets) > idx { + out += fmt.Sprintf(":%d", offsets[idx]) } out += " " } @@ -74,10 +86,14 @@ func (d *DMLWithInput) GetOrdering(ctx *plancontext.PlanningContext) []OrderBy { } func (d *DMLWithInput) planOffsets(ctx *plancontext.PlanningContext) Operator { - for _, col := range d.cols { - offset := d.Source.AddColumn(ctx, true, false, aeWrap(col)) - d.Offsets = append(d.Offsets, offset) + offsets := make([][]int, len(d.cols)) + for idx, columns := range d.cols { + for _, col := range columns { + offset := d.Source.AddColumn(ctx, true, false, aeWrap(col)) + offsets[idx] = append(offsets[idx], offset) + } } + d.Offsets = offsets return d } diff --git a/go/vt/vtgate/planbuilder/operators/phases.go b/go/vt/vtgate/planbuilder/operators/phases.go index 3937105c494..2fc3a5a044f 100644 --- a/go/vt/vtgate/planbuilder/operators/phases.go +++ b/go/vt/vtgate/planbuilder/operators/phases.go @@ -144,10 +144,11 @@ func createDMLWithInput(ctx *plancontext.PlanningContext, op, src Operator, in * dm := &DMLWithInput{} var leftComp sqlparser.ValTuple proj := newAliasedProjection(src) + dm.cols = make([][]*sqlparser.ColName, 1) for _, col := range in.Target.VTable.PrimaryKey { colName := sqlparser.NewColNameWithQualifier(col.String(), in.Target.Name) proj.AddColumn(ctx, true, false, aeWrap(colName)) - dm.cols = append(dm.cols, colName) + dm.cols[0] = append(dm.cols[0], colName) leftComp = append(leftComp, colName) ctx.SemTable.Recursive[colName] = in.Target.ID } @@ -189,7 +190,7 @@ func createDMLWithInput(ctx *plancontext.PlanningContext, op, src Operator, in * in.OwnedVindexQuery.OrderBy = nil in.OwnedVindexQuery.Limit = nil } - dm.DML = op + dm.DML = append(dm.DML, op) return dm, Rewrote("changed Delete to DMLWithInput") } diff --git a/go/vt/vtgate/planbuilder/operators/update.go b/go/vt/vtgate/planbuilder/operators/update.go index cf55f91fddd..311064fd3e6 100644 --- a/go/vt/vtgate/planbuilder/operators/update.go +++ b/go/vt/vtgate/planbuilder/operators/update.go @@ -72,11 +72,6 @@ func (se SetExpr) String() string { return fmt.Sprintf("%s = %s", sqlparser.String(se.Name), sqlparser.String(se.Expr.EvalExpr)) } -// Introduces implements the PhysicalOperator interface -func (u *Update) introducesTableID() semantics.TableSet { - return u.Target.ID -} - // Clone implements the Operator interface func (u *Update) Clone(inputs []Operator) Operator { upd := *u @@ -95,19 +90,7 @@ func (u *Update) TablesUsed() []string { } func (u *Update) ShortDescription() string { - ovq := "" - if u.OwnedVindexQuery != nil { - var cols, orderby, limit string - cols = fmt.Sprintf("COLUMNS: [%s]", sqlparser.String(u.OwnedVindexQuery.SelectExprs)) - if len(u.OwnedVindexQuery.OrderBy) > 0 { - orderby = fmt.Sprintf(" ORDERBY: [%s]", sqlparser.String(u.OwnedVindexQuery.OrderBy)) - } - if u.OwnedVindexQuery.Limit != nil { - limit = fmt.Sprintf(" LIMIT: [%s]", sqlparser.String(u.OwnedVindexQuery.Limit)) - } - ovq = fmt.Sprintf(" vindexQuery(%s%s%s)", cols, orderby, limit) - } - return fmt.Sprintf("%s.%s%s", u.Target.VTable.Keyspace.Name, u.Target.VTable.Name.String(), ovq) + return shortDesc(u.Target, u.OwnedVindexQuery) } func createOperatorFromUpdate(ctx *plancontext.PlanningContext, updStmt *sqlparser.Update) (op Operator) { diff --git a/go/vt/vtgate/planbuilder/plan_test.go b/go/vt/vtgate/planbuilder/plan_test.go index e7c18af1d4c..2ce1d04b4c5 100644 --- a/go/vt/vtgate/planbuilder/plan_test.go +++ b/go/vt/vtgate/planbuilder/plan_test.go @@ -64,6 +64,9 @@ func TestPlan(t *testing.T) { } testOutputTempDir := makeTestOutput(t) addPKs(t, vschemaWrapper.V, "user", []string{"user", "music"}) + addPKsProvided(t, vschemaWrapper.V, "user", []string{"user_extra"}, []string{"id", "user_id"}) + addPKsProvided(t, vschemaWrapper.V, "ordering", []string{"order"}, []string{"oid", "region_id"}) + addPKsProvided(t, vschemaWrapper.V, "ordering", []string{"order_event"}, []string{"oid", "ename"}) // You will notice that some tests expect user.Id instead of user.id. // This is because we now pre-create vindex columns in the symbol @@ -238,6 +241,13 @@ func addPKs(t *testing.T, vschema *vindexes.VSchema, ks string, tbls []string) { } } +func addPKsProvided(t *testing.T, vschema *vindexes.VSchema, ks string, tbls []string, pks []string) { + for _, tbl := range tbls { + require.NoError(t, + vschema.AddPrimaryKey(ks, tbl, pks)) + } +} + func TestSystemTables57(t *testing.T) { // first we move everything to use 5.7 logic env, err := vtenv.New(vtenv.Options{ @@ -280,6 +290,9 @@ func TestOne(t *testing.T) { setFks(t, lv) addPKs(t, lv, "user", []string{"user", "music"}) addPKs(t, lv, "main", []string{"unsharded"}) + addPKsProvided(t, lv, "user", []string{"user_extra"}, []string{"id", "user_id"}) + addPKsProvided(t, lv, "ordering", []string{"order"}, []string{"oid", "region_id"}) + addPKsProvided(t, lv, "ordering", []string{"order_event"}, []string{"oid", "ename"}) vschema := &vschemawrapper.VSchemaWrapper{ V: lv, TestBuilder: TestBuilder, diff --git a/go/vt/vtgate/planbuilder/testdata/dml_cases.json b/go/vt/vtgate/planbuilder/testdata/dml_cases.json index 6fbc31eb84d..7fb3a577729 100644 --- a/go/vt/vtgate/planbuilder/testdata/dml_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/dml_cases.json @@ -5058,7 +5058,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5134,7 +5134,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5206,7 +5206,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5304,7 +5304,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5377,7 +5377,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5450,7 +5450,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5505,7 +5505,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5561,7 +5561,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5613,7 +5613,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5671,7 +5671,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -5750,7 +5750,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -6188,5 +6188,484 @@ "user.user" ] } + }, + { + "comment": "multi target delete on sharded table", + "query": "delete u, m from user u, music m where u.col = m.col and u.foo = m.bar and u.baz = 12 and m.baz = 21", + "plan": { + "QueryType": "DELETE", + "Original": "delete u, m from user u, music m where u.col = m.col and u.foo = m.bar and u.baz = 12 and m.baz = 21", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + "0:[0]", + "1:[1]" + ], + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "L:0,R:0", + "JoinVars": { + "u_col": 1, + "u_foo": 2 + }, + "TableName": "`user`_music", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select u.id, u.col, u.foo from `user` as u where 1 != 1", + "Query": "select u.id, u.col, u.foo from `user` as u where u.baz = 12 for update", + "Table": "`user`" + }, + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select m.id from music as m where 1 != 1", + "Query": "select m.id from music as m where m.baz = 21 and m.bar = :u_foo and m.col = :u_col for update", + "Table": "music" + } + ] + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly from `user` as u where u.id in ::dml_vals for update", + "Query": "delete from `user` as u where u.id in ::dml_vals", + "Table": "user", + "Values": [ + "::dml_vals" + ], + "Vindex": "user_index" + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select user_id, id from music as m where m.id in ::dml_vals for update", + "Query": "delete from music as m where m.id in ::dml_vals", + "Table": "music", + "Values": [ + "::dml_vals" + ], + "Vindex": "music_user_map" + } + ] + }, + "TablesUsed": [ + "user.music", + "user.user" + ] + } + }, + { + "comment": "delete with multi-table targets", + "query": "delete music,user from music inner join user where music.id = user.id", + "plan": { + "QueryType": "DELETE", + "Original": "delete music,user from music inner join user where music.id = user.id", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + "0:[0]", + "1:[1]" + ], + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "L:0,R:0", + "JoinVars": { + "music_id": 0 + }, + "TableName": "music_`user`", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select music.id from music where 1 != 1", + "Query": "select music.id from music for update", + "Table": "music" + }, + { + "OperatorType": "Route", + "Variant": "EqualUnique", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select `user`.id from `user` where 1 != 1", + "Query": "select `user`.id from `user` where `user`.id = :music_id for update", + "Table": "`user`", + "Values": [ + ":music_id" + ], + "Vindex": "user_index" + } + ] + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select user_id, id from music where music.id in ::dml_vals for update", + "Query": "delete from music where music.id in ::dml_vals", + "Table": "music", + "Values": [ + "::dml_vals" + ], + "Vindex": "music_user_map" + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly from `user` where `user`.id in ::dml_vals for update", + "Query": "delete from `user` where `user`.id in ::dml_vals", + "Table": "user", + "Values": [ + "::dml_vals" + ], + "Vindex": "user_index" + } + ] + }, + "TablesUsed": [ + "user.music", + "user.user" + ] + } + }, + { + "comment": "multi table delete with 2 sharded tables join on vindex column", + "query": "delete u, m from user u join music m on u.id = m.user_id", + "plan": { + "QueryType": "DELETE", + "Original": "delete u, m from user u join music m on u.id = m.user_id", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + "0:[0]", + "1:[1]" + ], + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select u.id, m.id from `user` as u, music as m where 1 != 1", + "Query": "select u.id, m.id from `user` as u, music as m where u.id = m.user_id for update", + "Table": "`user`, music" + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly from `user` as u where u.id in ::dml_vals for update", + "Query": "delete from `user` as u where u.id in ::dml_vals", + "Table": "user", + "Values": [ + "::dml_vals" + ], + "Vindex": "user_index" + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select user_id, id from music as m where m.id in ::dml_vals for update", + "Query": "delete from music as m where m.id in ::dml_vals", + "Table": "music", + "Values": [ + "::dml_vals" + ], + "Vindex": "music_user_map" + } + ] + }, + "TablesUsed": [ + "user.music", + "user.user" + ] + } + }, + { + "comment": "multi table delete with 2 sharded tables join on non-vindex column", + "query": "delete u, m from user u join music m on u.col = m.col", + "plan": { + "QueryType": "DELETE", + "Original": "delete u, m from user u join music m on u.col = m.col", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + "0:[0]", + "1:[1]" + ], + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "Join", + "JoinColumnIndexes": "L:0,R:0", + "JoinVars": { + "u_col": 1 + }, + "TableName": "`user`_music", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select u.id, u.col from `user` as u where 1 != 1", + "Query": "select u.id, u.col from `user` as u for update", + "Table": "`user`" + }, + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select m.id from music as m where 1 != 1", + "Query": "select m.id from music as m where m.col = :u_col for update", + "Table": "music" + } + ] + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly from `user` as u where u.id in ::dml_vals for update", + "Query": "delete from `user` as u where u.id in ::dml_vals", + "Table": "user", + "Values": [ + "::dml_vals" + ], + "Vindex": "user_index" + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select user_id, id from music as m where m.id in ::dml_vals for update", + "Query": "delete from music as m where m.id in ::dml_vals", + "Table": "music", + "Values": [ + "::dml_vals" + ], + "Vindex": "music_user_map" + } + ] + }, + "TablesUsed": [ + "user.music", + "user.user" + ] + } + }, + { + "comment": "multi target delete with composite primary key having single column vindex", + "query": "delete u, ue from user u join user_extra ue on u.id = ue.user_id", + "plan": { + "QueryType": "DELETE", + "Original": "delete u, ue from user u join user_extra ue on u.id = ue.user_id", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + "0:[0]", + "1:[1 2]" + ], + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select u.id, ue.id, ue.user_id from `user` as u, user_extra as ue where 1 != 1", + "Query": "select u.id, ue.id, ue.user_id from `user` as u, user_extra as ue where u.id = ue.user_id for update", + "Table": "`user`, user_extra" + }, + { + "OperatorType": "Delete", + "Variant": "IN", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "user_index", + "OwnedVindexQuery": "select Id, `Name`, Costly from `user` as u where u.id in ::dml_vals for update", + "Query": "delete from `user` as u where u.id in ::dml_vals", + "Table": "user", + "Values": [ + "::dml_vals" + ], + "Vindex": "user_index" + }, + { + "OperatorType": "Delete", + "Variant": "MultiEqual", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from user_extra as ue where (ue.id, ue.user_id) in ::dml_vals", + "Table": "user_extra", + "Values": [ + "dml_vals:1" + ], + "Vindex": "user_index" + } + ] + }, + "TablesUsed": [ + "user.user", + "user.user_extra" + ] + } + }, + { + "comment": "multi target delete with composite primary key with lookup vindex as sharding column", + "query": "delete o, ev from `order` o join order_event ev where o.oid = ev.oid and ev.ename = 'a'", + "plan": { + "QueryType": "DELETE", + "Original": "delete o, ev from `order` o join order_event ev where o.oid = ev.oid and ev.ename = 'a'", + "Instructions": { + "OperatorType": "DMLWithInput", + "TargetTabletType": "PRIMARY", + "Offset": [ + "0:[0 1]", + "1:[2 3]" + ], + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "ordering", + "Sharded": true + }, + "FieldQuery": "select ev.oid, ev.ename, o.oid, o.region_id from `order` as o, order_event as ev where 1 != 1", + "Query": "select ev.oid, ev.ename, o.oid, o.region_id from `order` as o, order_event as ev where ev.ename = 'a' and o.oid = ev.oid for update", + "Table": "`order`, order_event" + }, + { + "OperatorType": "Delete", + "Variant": "MultiEqual", + "Keyspace": { + "Name": "ordering", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "Query": "delete from order_event as ev where (ev.oid, ev.ename) in ::dml_vals", + "Table": "order_event", + "Values": [ + "dml_vals:0" + ], + "Vindex": "oid_vdx" + }, + { + "OperatorType": "Delete", + "Variant": "MultiEqual", + "Keyspace": { + "Name": "ordering", + "Sharded": true + }, + "TargetTabletType": "PRIMARY", + "KsidLength": 1, + "KsidVindex": "xxhash", + "OwnedVindexQuery": "select region_id, oid from `order` as o where (o.oid, o.region_id) in ::dml_vals for update", + "Query": "delete from `order` as o where (o.oid, o.region_id) in ::dml_vals", + "Table": "order", + "Values": [ + "dml_vals:1" + ], + "Vindex": "xxhash" + } + ] + }, + "TablesUsed": [ + "ordering.order", + "ordering.order_event" + ] + } } ] diff --git a/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json b/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json index c8f059b7b88..b28955e368f 100644 --- a/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/foreignkey_cases.json @@ -1255,7 +1255,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -3131,7 +3131,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -3141,8 +3141,8 @@ "Name": "unsharded_fk_allow", "Sharded": false }, - "FieldQuery": "select u_tbl6.id from u_tbl6 as u, u_tbl5 as m where 1 != 1", - "Query": "select u_tbl6.id from u_tbl6 as u, u_tbl5 as m where u.col2 = 4 and m.col3 = 6 and u.col = m.col for update", + "FieldQuery": "select u.id from u_tbl6 as u, u_tbl5 as m where 1 != 1", + "Query": "select u.id from u_tbl6 as u, u_tbl5 as m where u.col2 = 4 and m.col3 = 6 and u.col = m.col for update", "Table": "u_tbl5, u_tbl6" }, { @@ -3157,7 +3157,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl6.col6 from u_tbl6 as u where 1 != 1", - "Query": "select u_tbl6.col6 from u_tbl6 as u where u_tbl6.id in ::dml_vals for update", + "Query": "select u_tbl6.col6 from u_tbl6 as u where u.id in ::dml_vals for update", "Table": "u_tbl6" }, { @@ -3185,7 +3185,7 @@ "Sharded": false }, "TargetTabletType": "PRIMARY", - "Query": "delete from u_tbl6 as u where u_tbl6.id in ::dml_vals", + "Query": "delete from u_tbl6 as u where u.id in ::dml_vals", "Table": "u_tbl6" } ] @@ -3209,7 +3209,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -3286,7 +3286,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -3399,7 +3399,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -3740,7 +3740,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -3806,5 +3806,10 @@ "unsharded_fk_allow.u_tbl8" ] } + }, + { + "comment": "multi table delete on foreign key enabled tables", + "query": "delete u, m from u_tbl6 u join u_tbl5 m on u.col = m.col where u.col2 = 4 and m.col3 = 6", + "plan": "VT12001: unsupported: multi table delete with foreign keys" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json b/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json index 311ff6adbff..6962ce50621 100644 --- a/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/foreignkey_checks_on_cases.json @@ -1255,7 +1255,7 @@ "OperatorType": "DMLWithInput", "TargetTabletType": "PRIMARY", "Offset": [ - 0 + "0:[0]" ], "Inputs": [ { @@ -1266,7 +1266,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl2.id from u_tbl2 where 1 != 1", - "Query": "select u_tbl2.id from u_tbl2 limit 2 for update", + "Query": "select /*+ SET_VAR(foreign_key_checks=On) */ u_tbl2.id from u_tbl2 limit 2", "Table": "u_tbl2" }, { @@ -1281,7 +1281,7 @@ "Sharded": false }, "FieldQuery": "select u_tbl2.col2 from u_tbl2 where 1 != 1", - "Query": "select u_tbl2.col2 from u_tbl2 where u_tbl2.id in ::dml_vals for update", + "Query": "select /*+ SET_VAR(foreign_key_checks=On) */ u_tbl2.col2 from u_tbl2 where u_tbl2.id in ::dml_vals", "Table": "u_tbl2" }, { @@ -1297,7 +1297,7 @@ "Cols": [ 0 ], - "Query": "update /*+ SET_VAR(foreign_key_checks=ON) */ u_tbl3 set col3 = null where (col3) in ::fkc_vals", + "Query": "update /*+ SET_VAR(foreign_key_checks=On) */ u_tbl3 set col3 = null where (col3) in ::fkc_vals", "Table": "u_tbl3" }, { diff --git a/go/vt/vtgate/planbuilder/testdata/show_cases.json b/go/vt/vtgate/planbuilder/testdata/show_cases.json index 896f762819e..e7a810bb42f 100644 --- a/go/vt/vtgate/planbuilder/testdata/show_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/show_cases.json @@ -734,7 +734,7 @@ "Keyspace": "VARCHAR", "Sharded": "VARCHAR" }, - "RowCount": 7 + "RowCount": 8 } } }, diff --git a/go/vt/vtgate/planbuilder/testdata/unknown_schema_cases.json b/go/vt/vtgate/planbuilder/testdata/unknown_schema_cases.json index 888127f11c4..df4459d9e0f 100644 --- a/go/vt/vtgate/planbuilder/testdata/unknown_schema_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/unknown_schema_cases.json @@ -68,5 +68,15 @@ "comment": "unsharded insert, no col list with auto-inc", "query": "insert into unsharded_auto values(1,1)", "plan": "VT09004: INSERT should contain column list or the table should have authoritative columns in vschema" + }, + { + "comment": "We need schema tracking to allow unexpanded columns inside UNION", + "query": "select x from (select t.*, 0 as x from user t union select t.*, 1 as x from user_extra t) AS t", + "plan": "VT09015: schema tracking required" + }, + { + "comment": "multi table delete with 1 sharded and 1 reference table", + "query": "delete u, r from user u join ref_with_source r on u.col = r.col", + "plan": "VT09015: schema tracking required" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json index 8007a0e1a0a..1fb4e61b37a 100644 --- a/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/unsupported_cases.json @@ -104,11 +104,6 @@ "query": "replace into user(id) values (1), (2)", "plan": "VT12001: unsupported: REPLACE INTO with sharded keyspace" }, - { - "comment": "delete with multi-table targets", - "query": "delete music,user from music inner join user where music.id = user.id", - "plan": "VT12001: unsupported: multi-table DELETE statement with multi-target" - }, { "comment": "select get_lock with non-dual table", "query": "select get_lock('xyz', 10) from user", @@ -329,26 +324,6 @@ "query": "SELECT (SELECT sum(user.name) FROM music LIMIT 1) FROM user", "plan": "VT12001: unsupported: correlated subquery is only supported for EXISTS" }, - { - "comment": "We need schema tracking to allow unexpanded columns inside UNION", - "query": "select x from (select t.*, 0 as x from user t union select t.*, 1 as x from user_extra t) AS t", - "plan": "VT09015: schema tracking required" - }, - { - "comment": "multi table delete with 2 sharded tables join on vindex column", - "query": "delete u, m from user u join music m on u.id = m.user_id", - "plan": "VT12001: unsupported: multi-table DELETE statement with multi-target" - }, - { - "comment": "multi table delete with 2 sharded tables join on non-vindex column", - "query": "delete u, m from user u join music m on u.col = m.col", - "plan": "VT12001: unsupported: multi-table DELETE statement with multi-target" - }, - { - "comment": "multi table delete with 1 sharded and 1 reference table", - "query": "delete u, r from user u join ref_with_source r on u.col = r.col", - "plan": "VT12001: unsupported: multi-table DELETE statement with multi-target" - }, { "comment": "reference table delete with join", "query": "delete r from user u join ref_with_source r on u.col = r.col", diff --git a/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json b/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json index 7aaa2648388..a8fe91e5d49 100644 --- a/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json +++ b/go/vt/vtgate/planbuilder/testdata/vschemas/schema.json @@ -895,6 +895,53 @@ "u_multicol_tbl2": {}, "u_multicol_tbl3": {} } + }, + "ordering": { + "sharded": true, + "vindexes": { + "xxhash": { + "type": "xxhash" + }, + "oid_vdx": { + "type": "consistent_lookup_unique", + "params": { + "table": "oid_idx", + "from": "oid", + "to": "keyspace_id" + }, + "owner": "order" + } + }, + "tables": { + "order": { + "column_vindexes": [ + { + "column": "region_id", + "name": "xxhash" + }, + { + "column": "oid", + "name": "oid_vdx" + } + ] + }, + "oid_idx": { + "column_vindexes": [ + { + "column": "oid", + "name": "xxhash" + } + ] + }, + "order_event": { + "column_vindexes": [ + { + "column": "oid", + "name": "oid_vdx" + } + ] + } + } } } } From 236f84ca0278de59eb0cc4e363eb8d4430a18301 Mon Sep 17 00:00:00 2001 From: Tim Vaillancourt Date: Tue, 27 Feb 2024 19:18:23 +0100 Subject: [PATCH 65/79] Filter by keyspace earlier in `tabletgateway`s `WaitForTablets(...)` (#15347) Signed-off-by: Tim Vaillancourt --- go/vt/discovery/healthcheck.go | 22 ------ go/vt/discovery/healthcheck_test.go | 21 ------ go/vt/srvtopo/discover.go | 19 +++--- go/vt/srvtopo/discover_test.go | 100 ++++++++++++++++------------ go/vt/vtgate/tabletgateway.go | 2 +- 5 files changed, 70 insertions(+), 94 deletions(-) diff --git a/go/vt/discovery/healthcheck.go b/go/vt/discovery/healthcheck.go index 5d6a5e32662..6b30a794893 100644 --- a/go/vt/discovery/healthcheck.go +++ b/go/vt/discovery/healthcheck.go @@ -750,30 +750,8 @@ func (hc *HealthCheckImpl) WaitForAllServingTablets(ctx context.Context, targets return hc.waitForTablets(ctx, targets, true) } -// FilterTargetsByKeyspaces only returns the targets that are part of the provided keyspaces -func FilterTargetsByKeyspaces(keyspaces []string, targets []*query.Target) []*query.Target { - filteredTargets := make([]*query.Target, 0) - - // Keep them all if there are no keyspaces to watch - if len(KeyspacesToWatch) == 0 { - return append(filteredTargets, targets...) - } - - // Let's remove from the target shards that are not in the keyspaceToWatch list. - for _, target := range targets { - for _, keyspaceToWatch := range keyspaces { - if target.Keyspace == keyspaceToWatch { - filteredTargets = append(filteredTargets, target) - } - } - } - return filteredTargets -} - // waitForTablets is the internal method that polls for tablets. func (hc *HealthCheckImpl) waitForTablets(ctx context.Context, targets []*query.Target, requireServing bool) error { - targets = FilterTargetsByKeyspaces(KeyspacesToWatch, targets) - for { // We nil targets as we find them. allPresent := true diff --git a/go/vt/discovery/healthcheck_test.go b/go/vt/discovery/healthcheck_test.go index 9563d9bfdc5..31376bd8c7d 100644 --- a/go/vt/discovery/healthcheck_test.go +++ b/go/vt/discovery/healthcheck_test.go @@ -672,27 +672,6 @@ func TestWaitForAllServingTablets(t *testing.T) { err = hc.WaitForAllServingTablets(ctx, targets) assert.NotNil(t, err, "error should not be nil (there are no tablets on this keyspace") - - targets = []*querypb.Target{ - - { - Keyspace: tablet.Keyspace, - Shard: tablet.Shard, - TabletType: tablet.Type, - }, - { - Keyspace: "newkeyspace", - Shard: tablet.Shard, - TabletType: tablet.Type, - }, - } - - KeyspacesToWatch = []string{tablet.Keyspace} - - err = hc.WaitForAllServingTablets(ctx, targets) - assert.Nil(t, err, "error should be nil. Keyspace with no tablets is filtered") - - KeyspacesToWatch = []string{} } // TestRemoveTablet tests the behavior when a tablet goes away. diff --git a/go/vt/srvtopo/discover.go b/go/vt/srvtopo/discover.go index 91aaea9daf6..2997dc42e21 100644 --- a/go/vt/srvtopo/discover.go +++ b/go/vt/srvtopo/discover.go @@ -29,20 +29,23 @@ import ( topodatapb "vitess.io/vitess/go/vt/proto/topodata" ) -// FindAllTargets goes through all serving shards in the topology -// for the provided tablet types. It returns one Target object per -// keyspace / shard / matching TabletType. -func FindAllTargets(ctx context.Context, ts Server, cell string, tabletTypes []topodatapb.TabletType) ([]*querypb.Target, error) { - ksNames, err := ts.GetSrvKeyspaceNames(ctx, cell, true) - if err != nil { - return nil, err +// FindAllTargets goes through all serving shards in the topology for the provided keyspaces +// and tablet types. If no keyspaces are provided all available keyspaces in the topo are +// fetched. It returns one Target object per keyspace/shard/matching TabletType. +func FindAllTargets(ctx context.Context, ts Server, cell string, keyspaces []string, tabletTypes []topodatapb.TabletType) ([]*querypb.Target, error) { + var err error + if len(keyspaces) == 0 { + keyspaces, err = ts.GetSrvKeyspaceNames(ctx, cell, true) + if err != nil { + return nil, err + } } var targets []*querypb.Target var wg sync.WaitGroup var mu sync.Mutex var errRecorder concurrency.AllErrorRecorder - for _, ksName := range ksNames { + for _, ksName := range keyspaces { wg.Add(1) go func(keyspace string) { defer wg.Done() diff --git a/go/vt/srvtopo/discover_test.go b/go/vt/srvtopo/discover_test.go index 81279b7d61a..75c5f25cc6e 100644 --- a/go/vt/srvtopo/discover_test.go +++ b/go/vt/srvtopo/discover_test.go @@ -18,11 +18,12 @@ package srvtopo import ( "context" - "reflect" "sort" "testing" "time" + "github.com/stretchr/testify/assert" + "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/topo/memorytopo" @@ -64,16 +65,12 @@ func TestFindAllTargets(t *testing.T) { rs := NewResilientServer(ctx, ts, counts) // No keyspace / shards. - ks, err := FindAllTargets(ctx, rs, "cell1", []topodatapb.TabletType{topodatapb.TabletType_PRIMARY}) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - if len(ks) > 0 { - t.Errorf("why did I get anything? %v", ks) - } + ks, err := FindAllTargets(ctx, rs, "cell1", []string{"test_keyspace"}, []topodatapb.TabletType{topodatapb.TabletType_PRIMARY}) + assert.NoError(t, err) + assert.Len(t, ks, 0) // Add one. - if err := ts.UpdateSrvKeyspace(ctx, "cell1", "test_keyspace", &topodatapb.SrvKeyspace{ + assert.NoError(t, ts.UpdateSrvKeyspace(ctx, "cell1", "test_keyspace", &topodatapb.SrvKeyspace{ Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{ { ServedType: topodatapb.TabletType_PRIMARY, @@ -84,28 +81,34 @@ func TestFindAllTargets(t *testing.T) { }, }, }, - }); err != nil { - t.Fatalf("can't add srvKeyspace: %v", err) - } + })) // Get it. - ks, err = FindAllTargets(ctx, rs, "cell1", []topodatapb.TabletType{topodatapb.TabletType_PRIMARY}) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - if !reflect.DeepEqual(ks, []*querypb.Target{ + ks, err = FindAllTargets(ctx, rs, "cell1", []string{"test_keyspace"}, []topodatapb.TabletType{topodatapb.TabletType_PRIMARY}) + assert.NoError(t, err) + assert.EqualValues(t, []*querypb.Target{ { Cell: "cell1", Keyspace: "test_keyspace", Shard: "test_shard0", TabletType: topodatapb.TabletType_PRIMARY, }, - }) { - t.Errorf("got wrong value: %v", ks) - } + }, ks) + + // Get any keyspace. + ks, err = FindAllTargets(ctx, rs, "cell1", nil, []topodatapb.TabletType{topodatapb.TabletType_PRIMARY}) + assert.NoError(t, err) + assert.EqualValues(t, []*querypb.Target{ + { + Cell: "cell1", + Keyspace: "test_keyspace", + Shard: "test_shard0", + TabletType: topodatapb.TabletType_PRIMARY, + }, + }, ks) // Add another one. - if err := ts.UpdateSrvKeyspace(ctx, "cell1", "test_keyspace2", &topodatapb.SrvKeyspace{ + assert.NoError(t, ts.UpdateSrvKeyspace(ctx, "cell1", "test_keyspace2", &topodatapb.SrvKeyspace{ Partitions: []*topodatapb.SrvKeyspace_KeyspacePartition{ { ServedType: topodatapb.TabletType_PRIMARY, @@ -124,17 +127,13 @@ func TestFindAllTargets(t *testing.T) { }, }, }, - }); err != nil { - t.Fatalf("can't add srvKeyspace: %v", err) - } + })) - // Get it for all types. - ks, err = FindAllTargets(ctx, rs, "cell1", []topodatapb.TabletType{topodatapb.TabletType_PRIMARY, topodatapb.TabletType_REPLICA}) - if err != nil { - t.Errorf("unexpected error: %v", err) - } + // Get it for any keyspace, all types. + ks, err = FindAllTargets(ctx, rs, "cell1", nil, []topodatapb.TabletType{topodatapb.TabletType_PRIMARY, topodatapb.TabletType_REPLICA}) + assert.NoError(t, err) sort.Sort(TargetArray(ks)) - if !reflect.DeepEqual(ks, []*querypb.Target{ + assert.EqualValues(t, []*querypb.Target{ { Cell: "cell1", Keyspace: "test_keyspace", @@ -153,23 +152,40 @@ func TestFindAllTargets(t *testing.T) { Shard: "test_shard2", TabletType: topodatapb.TabletType_REPLICA, }, - }) { - t.Errorf("got wrong value: %v", ks) - } + }, ks) - // Only get the REPLICA targets. - ks, err = FindAllTargets(ctx, rs, "cell1", []topodatapb.TabletType{topodatapb.TabletType_REPLICA}) - if err != nil { - t.Errorf("unexpected error: %v", err) - } - if !reflect.DeepEqual(ks, []*querypb.Target{ + // Only get 1 keyspace for all types. + ks, err = FindAllTargets(ctx, rs, "cell1", []string{"test_keyspace2"}, []topodatapb.TabletType{topodatapb.TabletType_PRIMARY, topodatapb.TabletType_REPLICA}) + assert.NoError(t, err) + assert.EqualValues(t, []*querypb.Target{ + { + Cell: "cell1", + Keyspace: "test_keyspace2", + Shard: "test_shard1", + TabletType: topodatapb.TabletType_PRIMARY, + }, { Cell: "cell1", Keyspace: "test_keyspace2", Shard: "test_shard2", TabletType: topodatapb.TabletType_REPLICA, }, - }) { - t.Errorf("got wrong value: %v", ks) - } + }, ks) + + // Only get the REPLICA targets for any keyspace. + ks, err = FindAllTargets(ctx, rs, "cell1", []string{}, []topodatapb.TabletType{topodatapb.TabletType_REPLICA}) + assert.NoError(t, err) + assert.Equal(t, []*querypb.Target{ + { + Cell: "cell1", + Keyspace: "test_keyspace2", + Shard: "test_shard2", + TabletType: topodatapb.TabletType_REPLICA, + }, + }, ks) + + // Get non-existent keyspace. + ks, err = FindAllTargets(ctx, rs, "cell1", []string{"doesnt-exist"}, []topodatapb.TabletType{topodatapb.TabletType_PRIMARY, topodatapb.TabletType_REPLICA}) + assert.NoError(t, err) + assert.Len(t, ks, 0) } diff --git a/go/vt/vtgate/tabletgateway.go b/go/vt/vtgate/tabletgateway.go index b289cf3b74e..49b9dac1128 100644 --- a/go/vt/vtgate/tabletgateway.go +++ b/go/vt/vtgate/tabletgateway.go @@ -191,7 +191,7 @@ func (gw *TabletGateway) WaitForTablets(ctx context.Context, tabletTypesToWait [ } // Finds the targets to look for. - targets, err := srvtopo.FindAllTargets(ctx, gw.srvTopoServer, gw.localCell, tabletTypesToWait) + targets, err := srvtopo.FindAllTargets(ctx, gw.srvTopoServer, gw.localCell, discovery.KeyspacesToWatch, tabletTypesToWait) if err != nil { return err } From 059e50d54326a21e56fc09fffd8429efa6924f83 Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Wed, 28 Feb 2024 12:01:11 +0530 Subject: [PATCH 66/79] Fix PRS from being blocked because of misbehaving clients (#15339) Signed-off-by: Manan Gupta --- changelog/20.0/20.0.0/summary.md | 12 ++- go/flags/endtoend/vtcombo.txt | 2 +- go/flags/endtoend/vttablet.txt | 2 +- go/test/endtoend/tabletgateway/main_test.go | 15 ++-- go/test/endtoend/tabletgateway/vtgate_test.go | 39 ++++++++++ .../vtgate/transaction/restart/main_test.go | 3 + go/vt/vttablet/tabletserver/query_executor.go | 2 +- .../vttablet/tabletserver/requests_waiter.go | 78 +++++++++++++++++++ .../tabletserver/requests_waiter_test.go | 57 ++++++++++++++ go/vt/vttablet/tabletserver/state_manager.go | 72 +++++++++-------- .../tabletserver/state_manager_test.go | 3 +- .../vttablet/tabletserver/tabletenv/config.go | 3 + .../tabletserver/tabletenv/config_test.go | 3 +- go/vt/vttablet/tabletserver/tabletserver.go | 1 + .../tabletserver/tabletserver_test.go | 6 +- 15 files changed, 253 insertions(+), 45 deletions(-) create mode 100644 go/vt/vttablet/tabletserver/requests_waiter.go create mode 100644 go/vt/vttablet/tabletserver/requests_waiter_test.go diff --git a/changelog/20.0/20.0.0/summary.md b/changelog/20.0/20.0.0/summary.md index bb376c6e721..cd3b9718503 100644 --- a/changelog/20.0/20.0.0/summary.md +++ b/changelog/20.0/20.0.0/summary.md @@ -3,6 +3,8 @@ ### Table of Contents - **[Major Changes](#major-changes)** + - **[Breaking changes](#breaking-changes)** + - [`shutdown_grace_period` Default Change](#shutdown-grace-period-default) - **[Query Compatibility](#query-compatibility)** - [Vindex Hints](#vindex-hints) - [Update with Limit Support](#update-limit) @@ -16,6 +18,15 @@ ## Major Changes +### Breaking Changes + +#### `shutdown_grace_period` Default Change + +The `--shutdown_grace_period` flag, which was introduced in v2 with a default of `0 seconds`, has now been changed to default to `3 seconds`. +This makes reparenting in Vitess resilient to client errors, and prevents PlannedReparentShard from timing out. + +In order to preserve the old behaviour, the users can set the flag back to `0 seconds` causing open transactions to never be shutdown, but in that case, they run the risk of PlannedReparentShard calls timing out. + ### Query Compatibility #### Vindex Hints @@ -61,7 +72,6 @@ The `--pprof-http` flag, which was introduced in v19 with a default of `true`, h This makes HTTP `pprof` endpoints now an *opt-in* feature, rather than opt-out. To continue enabling these endpoints, explicitly set `--pprof-http` when starting up Vitess components. - ## Minor Changes ### New Stats diff --git a/go/flags/endtoend/vtcombo.txt b/go/flags/endtoend/vtcombo.txt index 04a46d9e754..26e145e6930 100644 --- a/go/flags/endtoend/vtcombo.txt +++ b/go/flags/endtoend/vtcombo.txt @@ -319,7 +319,7 @@ Flags: --service_map strings comma separated list of services to enable (or disable if prefixed with '-') Example: grpc-queryservice --serving_state_grace_period duration how long to pause after broadcasting health to vtgate, before enforcing a new serving state --shard_sync_retry_delay duration delay between retries of updates to keep the tablet and its shard record in sync (default 30s) - --shutdown_grace_period duration how long to wait for queries and transactions to complete during graceful shutdown. + --shutdown_grace_period duration how long to wait for queries and transactions to complete during graceful shutdown. (default 3s) --sql-max-length-errors int truncate queries in error logs to the given length (default unlimited) --sql-max-length-ui int truncate queries in debug UIs to the given length (default 512) (default 512) --srv_topo_cache_refresh duration how frequently to refresh the topology for cached entries (default 1s) diff --git a/go/flags/endtoend/vttablet.txt b/go/flags/endtoend/vttablet.txt index 6ff475badfa..ea023318b01 100644 --- a/go/flags/endtoend/vttablet.txt +++ b/go/flags/endtoend/vttablet.txt @@ -319,7 +319,7 @@ Flags: --service_map strings comma separated list of services to enable (or disable if prefixed with '-') Example: grpc-queryservice --serving_state_grace_period duration how long to pause after broadcasting health to vtgate, before enforcing a new serving state --shard_sync_retry_delay duration delay between retries of updates to keep the tablet and its shard record in sync (default 30s) - --shutdown_grace_period duration how long to wait for queries and transactions to complete during graceful shutdown. + --shutdown_grace_period duration how long to wait for queries and transactions to complete during graceful shutdown. (default 3s) --sql-max-length-errors int truncate queries in error logs to the given length (default unlimited) --sql-max-length-ui int truncate queries in debug UIs to the given length (default 512) (default 512) --srv_topo_cache_refresh duration how frequently to refresh the topology for cached entries (default 1s) diff --git a/go/test/endtoend/tabletgateway/main_test.go b/go/test/endtoend/tabletgateway/main_test.go index da4fe711f64..354be6969d3 100644 --- a/go/test/endtoend/tabletgateway/main_test.go +++ b/go/test/endtoend/tabletgateway/main_test.go @@ -18,6 +18,7 @@ package healthcheck import ( "flag" + "fmt" "os" "testing" @@ -26,11 +27,12 @@ import ( ) var ( - clusterInstance *cluster.LocalProcessCluster - vtParams mysql.ConnParams - keyspaceName = "commerce" - cell = "zone1" - sqlSchema = `create table product( + clusterInstance *cluster.LocalProcessCluster + vtParams mysql.ConnParams + keyspaceName = "commerce" + vtgateGrpcAddress string + cell = "zone1" + sqlSchema = `create table product( sku varbinary(128), description varbinary(128), price bigint, @@ -64,7 +66,7 @@ func TestMain(m *testing.M) { exitCode := func() int { clusterInstance = cluster.NewCluster(cell, "localhost") - clusterInstance.VtTabletExtraArgs = []string{"--health_check_interval", "1s"} + clusterInstance.VtTabletExtraArgs = []string{"--health_check_interval", "1s", "--shutdown_grace_period", "3s"} defer clusterInstance.Teardown() // Start topo server @@ -96,6 +98,7 @@ func TestMain(m *testing.M) { Host: clusterInstance.Hostname, Port: clusterInstance.VtgateMySQLPort, } + vtgateGrpcAddress = fmt.Sprintf("%s:%d", clusterInstance.Hostname, clusterInstance.VtgateGrpcPort) return m.Run() }() os.Exit(exitCode) diff --git a/go/test/endtoend/tabletgateway/vtgate_test.go b/go/test/endtoend/tabletgateway/vtgate_test.go index c48aa6c2131..d9cedc04b69 100644 --- a/go/test/endtoend/tabletgateway/vtgate_test.go +++ b/go/test/endtoend/tabletgateway/vtgate_test.go @@ -35,6 +35,7 @@ import ( "vitess.io/vitess/go/test/endtoend/cluster" "vitess.io/vitess/go/test/endtoend/utils" vtorcutils "vitess.io/vitess/go/test/endtoend/vtorc/utils" + querypb "vitess.io/vitess/go/vt/proto/query" "vitess.io/vitess/go/vt/proto/topodata" ) @@ -283,6 +284,44 @@ func TestReplicaTransactions(t *testing.T) { assert.Equal(t, `[[INT64(1) VARCHAR("email1")] [INT64(2) VARCHAR("email2")]]`, fmt.Sprintf("%v", qr4.Rows), "we are not able to reconnect after restart") } +// TestStreamingRPCStuck tests that StreamExecute calls don't get stuck on the vttablets if a client stop reading from a stream. +func TestStreamingRPCStuck(t *testing.T) { + defer cluster.PanicHandler(t) + ctx := context.Background() + vtConn, err := mysql.Connect(ctx, &vtParams) + require.NoError(t, err) + defer vtConn.Close() + + // We want the table to have enough rows such that a streaming call returns multiple packets. + // Therefore, we insert one row and keep doubling it. + utils.Exec(t, vtConn, "insert into customer(email) values('testemail')") + for i := 0; i < 15; i++ { + // Double the number of rows in customer table. + utils.Exec(t, vtConn, "insert into customer (email) select email from customer") + } + + // Connect to vtgate and run a streaming query. + vtgateConn, err := cluster.DialVTGate(ctx, t.Name(), vtgateGrpcAddress, "test_user", "") + require.NoError(t, err) + stream, err := vtgateConn.Session("", &querypb.ExecuteOptions{}).StreamExecute(ctx, "select * from customer", map[string]*querypb.BindVariable{}) + require.NoError(t, err) + + // We read packets until we see the first set of results. This ensures that the stream is working. + for { + res, err := stream.Recv() + require.NoError(t, err) + if res != nil && len(res.Rows) > 0 { + // breaking here stops reading from the stream. + break + } + } + + // We simulate a misbehaving client that doesn't read from the stream anymore. + // This however shouldn't block PlannedReparentShard calls. + err = clusterInstance.VtctldClientProcess.PlannedReparentShard(keyspaceName, "0", clusterInstance.Keyspaces[0].Shards[0].Vttablets[1].Alias) + require.NoError(t, err) +} + func getMapFromJSON(JSON map[string]any, key string) map[string]any { result := make(map[string]any) object := reflect.ValueOf(JSON[key]) diff --git a/go/test/endtoend/vtgate/transaction/restart/main_test.go b/go/test/endtoend/vtgate/transaction/restart/main_test.go index 3c7ac710e9d..de52a3e8870 100644 --- a/go/test/endtoend/vtgate/transaction/restart/main_test.go +++ b/go/test/endtoend/vtgate/transaction/restart/main_test.go @@ -60,6 +60,9 @@ func TestMain(m *testing.M) { Name: keyspaceName, SchemaSQL: schemaSQL, } + clusterInstance.VtTabletExtraArgs = append(clusterInstance.VtTabletExtraArgs, + "--shutdown_grace_period=0s", + ) err = clusterInstance.StartUnshardedKeyspace(*keyspace, 1, false) if err != nil { return 1 diff --git a/go/vt/vttablet/tabletserver/query_executor.go b/go/vt/vttablet/tabletserver/query_executor.go index 5690c209ebb..f371d62006c 100644 --- a/go/vt/vttablet/tabletserver/query_executor.go +++ b/go/vt/vttablet/tabletserver/query_executor.go @@ -1117,7 +1117,7 @@ func (qre *QueryExecutor) execStreamSQL(conn *connpool.PooledConn, isTransaction // Add query detail object into QueryExecutor TableServer list w.r.t if it is a transactional or not. Previously we were adding it // to olapql list regardless but that resulted in problems, where long-running stream queries which can be stateful (or transactional) - // weren't getting cleaned up during unserveCommon>handleShutdownGracePeriod in state_manager.go. + // weren't getting cleaned up during unserveCommon>terminateAllQueries in state_manager.go. // This change will ensure that long-running streaming stateful queries get gracefully shutdown during ServingTypeChange // once their grace period is over. qd := NewQueryDetail(qre.logStats.Ctx, conn.Conn) diff --git a/go/vt/vttablet/tabletserver/requests_waiter.go b/go/vt/vttablet/tabletserver/requests_waiter.go new file mode 100644 index 00000000000..39e08f924cc --- /dev/null +++ b/go/vt/vttablet/tabletserver/requests_waiter.go @@ -0,0 +1,78 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tabletserver + +import "sync" + +// requestsWaiter is used to wait for requests. It stores the count of the requests pending, +// and also the number of waiters currently waiting. It has a mutex as well to protects its fields. +type requestsWaiter struct { + mu sync.Mutex + wg sync.WaitGroup + // waitCounter is the number of goroutines that are waiting for wg to be empty. + // If this value is greater than zero, then we have to ensure that we don't Add to the requests + // to avoid any panics in the wait. + waitCounter int + // counter is the count of the number of outstanding requests. + counter int +} + +// newRequestsWaiter creates a new requestsWaiter. +func newRequestsWaiter() *requestsWaiter { + return &requestsWaiter{} +} + +// Add adds to the requestsWaiter. +func (r *requestsWaiter) Add(val int) { + r.mu.Lock() + defer r.mu.Unlock() + r.counter += val + r.wg.Add(val) +} + +// Done subtracts 1 from the requestsWaiter. +func (r *requestsWaiter) Done() { + r.Add(-1) +} + +// addToWaitCounter adds to the waitCounter while being protected by a mutex. +func (r *requestsWaiter) addToWaitCounter(val int) { + r.mu.Lock() + defer r.mu.Unlock() + r.waitCounter += val +} + +// WaitToBeEmpty waits for requests to be empty. It also increments and decrements the waitCounter as required. +func (r *requestsWaiter) WaitToBeEmpty() { + r.addToWaitCounter(1) + r.wg.Wait() + r.addToWaitCounter(-1) +} + +// GetWaiterCount gets the number of go routines currently waiting on the wait group. +func (r *requestsWaiter) GetWaiterCount() int { + r.mu.Lock() + defer r.mu.Unlock() + return r.waitCounter +} + +// GetOutstandingRequestsCount gets the number of requests outstanding. +func (r *requestsWaiter) GetOutstandingRequestsCount() int { + r.mu.Lock() + defer r.mu.Unlock() + return r.counter +} diff --git a/go/vt/vttablet/tabletserver/requests_waiter_test.go b/go/vt/vttablet/tabletserver/requests_waiter_test.go new file mode 100644 index 00000000000..078e32e92ca --- /dev/null +++ b/go/vt/vttablet/tabletserver/requests_waiter_test.go @@ -0,0 +1,57 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package tabletserver + +import ( + "testing" + "time" + + "github.com/stretchr/testify/require" +) + +// TestRequestWaiter tests the functionality of request waiter. +func TestRequestWaiter(t *testing.T) { + rw := newRequestsWaiter() + require.EqualValues(t, 0, rw.GetWaiterCount()) + require.EqualValues(t, 0, rw.GetOutstandingRequestsCount()) + + rw.Add(3) + require.EqualValues(t, 0, rw.GetWaiterCount()) + require.EqualValues(t, 3, rw.GetOutstandingRequestsCount()) + + rw.Done() + require.EqualValues(t, 0, rw.GetWaiterCount()) + require.EqualValues(t, 2, rw.GetOutstandingRequestsCount()) + + go func() { + rw.WaitToBeEmpty() + }() + go func() { + rw.WaitToBeEmpty() + }() + + time.Sleep(100 * time.Millisecond) + require.EqualValues(t, 2, rw.GetWaiterCount()) + require.EqualValues(t, 2, rw.GetOutstandingRequestsCount()) + + rw.Done() + rw.Done() + + time.Sleep(100 * time.Millisecond) + require.EqualValues(t, 0, rw.GetWaiterCount()) + require.EqualValues(t, 0, rw.GetOutstandingRequestsCount()) +} diff --git a/go/vt/vttablet/tabletserver/state_manager.go b/go/vt/vttablet/tabletserver/state_manager.go index 9c01610f770..60b1f1281d0 100644 --- a/go/vt/vttablet/tabletserver/state_manager.go +++ b/go/vt/vttablet/tabletserver/state_manager.go @@ -99,12 +99,8 @@ type stateManager struct { alsoAllow []topodatapb.TabletType reason string transitionErr error - // requestsWaitCounter is the number of goroutines that are waiting for requests to be empty. - // If this value is greater than zero, then we have to ensure that we don't Add to the requests - // to avoid any panics in the wait. - requestsWaitCounter int - requests sync.WaitGroup + rw *requestsWaiter // QueryList does not have an Open or Close. statelessql *QueryList @@ -358,20 +354,6 @@ func (sm *stateManager) checkMySQL() { }() } -// addRequestsWaitCounter adds to the requestsWaitCounter while being protected by a mutex. -func (sm *stateManager) addRequestsWaitCounter(val int) { - sm.mu.Lock() - defer sm.mu.Unlock() - sm.requestsWaitCounter += val -} - -// waitForRequestsToBeEmpty waits for requests to be empty. It also increments and decrements the requestsWaitCounter as required. -func (sm *stateManager) waitForRequestsToBeEmpty() { - sm.addRequestsWaitCounter(1) - sm.requests.Wait() - sm.addRequestsWaitCounter(-1) -} - func (sm *stateManager) setWantState(stateWanted servingState) { sm.mu.Lock() defer sm.mu.Unlock() @@ -410,9 +392,9 @@ func (sm *stateManager) StartRequest(ctx context.Context, target *querypb.Target } shuttingDown := sm.wantState != StateServing - // If requestsWaitCounter is not zero, then there are go-routines blocked on waiting for requests to be empty. + // If wait counter for the requests is not zero, then there are go-routines blocked on waiting for requests to be empty. // We cannot allow adding to the requests to prevent any panics from happening. - if (shuttingDown && !allowOnShutdown) || sm.requestsWaitCounter > 0 { + if (shuttingDown && !allowOnShutdown) || sm.rw.GetWaiterCount() > 0 { // This specific error string needs to be returned for vtgate buffering to work. return vterrors.New(vtrpcpb.Code_CLUSTER_EVENT, vterrors.ShuttingDown) } @@ -421,13 +403,13 @@ func (sm *stateManager) StartRequest(ctx context.Context, target *querypb.Target if err != nil { return err } - sm.requests.Add(1) + sm.rw.Add(1) return nil } // EndRequest unregisters the current request (a waitgroup) as done. func (sm *stateManager) EndRequest() { - sm.requests.Done() + sm.rw.Done() } // VerifyTarget allows requests to be executed even in non-serving state. @@ -507,7 +489,7 @@ func (sm *stateManager) unservePrimary() error { func (sm *stateManager) serveNonPrimary(wantTabletType topodatapb.TabletType) error { // We are likely transitioning from primary. We have to honor // the shutdown grace period. - cancel := sm.handleShutdownGracePeriod() + cancel := sm.terminateAllQueries(nil) defer cancel() sm.ddle.Close() @@ -560,9 +542,12 @@ func (sm *stateManager) connect(tabletType topodatapb.TabletType) error { } func (sm *stateManager) unserveCommon() { + // We create a wait group that tracks whether all the queries have been terminated or not. + wg := sync.WaitGroup{} + wg.Add(1) log.Infof("Started execution of unserveCommon") - cancel := sm.handleShutdownGracePeriod() - log.Infof("Finished execution of handleShutdownGracePeriod") + cancel := sm.terminateAllQueries(&wg) + log.Infof("Finished execution of terminateAllQueries") defer cancel() log.Infof("Started online ddl executor close") @@ -580,22 +565,45 @@ func (sm *stateManager) unserveCommon() { log.Info("Finished Killing all OLAP queries. Started tracker close") sm.tracker.Close() log.Infof("Finished tracker close. Started wait for requests") - sm.waitForRequestsToBeEmpty() - log.Infof("Finished wait for requests. Finished execution of unserveCommon") + sm.handleShutdownGracePeriod(&wg) + log.Infof("Finished handling grace period. Finished execution of unserveCommon") +} + +// handleShutdownGracePeriod checks if we have shutdwonGracePeriod specified. +// If its not, then we have to wait for all the requests to be empty. +// Otherwise, we only wait for all the queries against MySQL to be terminated. +func (sm *stateManager) handleShutdownGracePeriod(wg *sync.WaitGroup) { + // If there is no shutdown grace period specified, then we should wait for all the requests to be empty. + if sm.shutdownGracePeriod == 0 { + sm.rw.WaitToBeEmpty() + } else { + // We quickly check if the requests are empty or not. + // If they are, then we don't need to wait for the shutdown to complete. + count := sm.rw.GetOutstandingRequestsCount() + if count == 0 { + return + } + // Otherwise, we should wait for all olap queries to be killed. + // We don't need to wait for requests to be empty since we have ensured all the queries against MySQL have been killed. + wg.Wait() + } } -func (sm *stateManager) handleShutdownGracePeriod() (cancel func()) { +func (sm *stateManager) terminateAllQueries(wg *sync.WaitGroup) (cancel func()) { if sm.shutdownGracePeriod == 0 { return func() {} } ctx, cancel := context.WithCancel(context.TODO()) go func() { + if wg != nil { + defer wg.Done() + } if err := timer.SleepContext(ctx, sm.shutdownGracePeriod); err != nil { return } log.Infof("Grace Period %v exceeded. Killing all OLTP queries.", sm.shutdownGracePeriod) sm.statelessql.TerminateAll() - log.Infof("Killed all stateful OLTP queries.") + log.Infof("Killed all stateless OLTP queries.") sm.statefulql.TerminateAll() log.Infof("Killed all OLTP queries.") }() @@ -645,7 +653,7 @@ func (sm *stateManager) setState(tabletType topodatapb.TabletType, state serving log.Infof("TabletServer transition: %v -> %v for tablet %s:%s/%s", sm.stateStringLocked(sm.target.TabletType, sm.state), sm.stateStringLocked(tabletType, state), sm.target.Cell, sm.target.Keyspace, sm.target.Shard) - sm.handleGracePeriod(tabletType) + sm.handleTransitionGracePeriod(tabletType) sm.target.TabletType = tabletType if sm.state == StateNotConnected { // If we're transitioning out of StateNotConnected, we have @@ -664,7 +672,7 @@ func (sm *stateManager) stateStringLocked(tabletType topodatapb.TabletType, stat return fmt.Sprintf("%v: %v, %v", tabletType, state, sm.ptsTimestamp.Local().Format("Jan 2, 2006 at 15:04:05 (MST)")) } -func (sm *stateManager) handleGracePeriod(tabletType topodatapb.TabletType) { +func (sm *stateManager) handleTransitionGracePeriod(tabletType topodatapb.TabletType) { if tabletType != topodatapb.TabletType_PRIMARY { // We allow serving of previous type only for a primary transition. sm.alsoAllow = nil diff --git a/go/vt/vttablet/tabletserver/state_manager_test.go b/go/vt/vttablet/tabletserver/state_manager_test.go index 59909888935..a0ef3557074 100644 --- a/go/vt/vttablet/tabletserver/state_manager_test.go +++ b/go/vt/vttablet/tabletserver/state_manager_test.go @@ -721,7 +721,7 @@ func TestPanicInWait(t *testing.T) { // Simulate going to a not serving state and calling unserveCommon that waits on requests. sm.wantState = StateNotServing - sm.waitForRequestsToBeEmpty() + sm.rw.WaitToBeEmpty() } func verifySubcomponent(t *testing.T, order int64, component any, state testState) { @@ -752,6 +752,7 @@ func newTestStateManager(t *testing.T) *stateManager { ddle: &testOnlineDDLExecutor{}, throttler: &testLagThrottler{}, tableGC: &testTableGC{}, + rw: newRequestsWaiter(), } sm.Init(env, &querypb.Target{}) sm.hs.InitDBConfig(&querypb.Target{}, dbconfigs.New(fakesqldb.New(t).ConnParams())) diff --git a/go/vt/vttablet/tabletserver/tabletenv/config.go b/go/vt/vttablet/tabletserver/tabletenv/config.go index 233f8951227..72682a75e30 100644 --- a/go/vt/vttablet/tabletserver/tabletenv/config.go +++ b/go/vt/vttablet/tabletserver/tabletenv/config.go @@ -975,6 +975,9 @@ var defaultConfig = TabletConfig{ Mode: Disable, HeartbeatInterval: 250 * time.Millisecond, }, + GracePeriods: GracePeriodsConfig{ + Shutdown: 3 * time.Second, + }, HotRowProtection: HotRowProtectionConfig{ Mode: Disable, // Default value is the same as TxPool.Size. diff --git a/go/vt/vttablet/tabletserver/tabletenv/config_test.go b/go/vt/vttablet/tabletserver/tabletenv/config_test.go index 98d4cfceb21..ace094ac899 100644 --- a/go/vt/vttablet/tabletserver/tabletenv/config_test.go +++ b/go/vt/vttablet/tabletserver/tabletenv/config_test.go @@ -123,7 +123,8 @@ func TestDefaultConfig(t *testing.T) { want := `consolidator: enable consolidatorStreamQuerySize: 2097152 consolidatorStreamTotalSize: 134217728 -gracePeriods: {} +gracePeriods: + shutdownSeconds: 3s healthcheck: degradedThresholdSeconds: 30s intervalSeconds: 20s diff --git a/go/vt/vttablet/tabletserver/tabletserver.go b/go/vt/vttablet/tabletserver/tabletserver.go index dad637a6daf..8a1a45ca4a2 100644 --- a/go/vt/vttablet/tabletserver/tabletserver.go +++ b/go/vt/vttablet/tabletserver/tabletserver.go @@ -204,6 +204,7 @@ func NewTabletServer(ctx context.Context, env *vtenv.Environment, name string, c ddle: tsv.onlineDDLExecutor, throttler: tsv.lagThrottler, tableGC: tsv.tableGC, + rw: newRequestsWaiter(), } tsv.exporter.NewGaugeFunc("TabletState", "Tablet server state", func() int64 { return int64(tsv.sm.State()) }) diff --git a/go/vt/vttablet/tabletserver/tabletserver_test.go b/go/vt/vttablet/tabletserver/tabletserver_test.go index 9744b971946..df68c8b0a83 100644 --- a/go/vt/vttablet/tabletserver/tabletserver_test.go +++ b/go/vt/vttablet/tabletserver/tabletserver_test.go @@ -153,6 +153,10 @@ func TestTabletServerPrimaryToReplica(t *testing.T) { defer cancel() // Reuse code from tx_executor_test. _, tsv, db := newTestTxExecutor(t, ctx) + // This is required because the test is verifying that we rollback transactions on changing serving type, + // but that only happens immediately if the shut down grace period is not specified. + tsv.te.shutdownGracePeriod = 0 + tsv.sm.shutdownGracePeriod = 0 defer tsv.StopService() defer db.Close() target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} @@ -180,7 +184,7 @@ func TestTabletServerPrimaryToReplica(t *testing.T) { select { case <-ch: t.Fatal("ch should not fire") - case <-time.After(10 * time.Millisecond): + case <-time.After(100 * time.Millisecond): } require.EqualValues(t, 1, tsv.te.txPool.scp.active.Size(), "tsv.te.txPool.scp.active.Size()") From f4debb9e51ca38e708db1cb2f340312e1114f45e Mon Sep 17 00:00:00 2001 From: Tim Vaillancourt Date: Wed, 28 Feb 2024 12:00:35 +0100 Subject: [PATCH 67/79] Limit concurrent creation of healthcheck gRPC connections (#15053) Signed-off-by: Tim Vaillancourt --- changelog/20.0/20.0.0/summary.md | 5 ++++ go/flags/endtoend/vtcombo.txt | 1 + go/flags/endtoend/vtctld.txt | 1 + go/flags/endtoend/vtgate.txt | 1 + go/vt/discovery/healthcheck.go | 10 ++++++- go/vt/discovery/tablet_health_check.go | 37 +++++++++++++++++++++----- go/vt/grpcclient/client.go | 6 +++++ 7 files changed, 54 insertions(+), 7 deletions(-) diff --git a/changelog/20.0/20.0.0/summary.md b/changelog/20.0/20.0.0/summary.md index cd3b9718503..863de8aefec 100644 --- a/changelog/20.0/20.0.0/summary.md +++ b/changelog/20.0/20.0.0/summary.md @@ -12,6 +12,7 @@ - [Delete with Subquery Support](#delete-subquery) - **[Flag changes](#flag-changes)** - [`pprof-http` default change](#pprof-http-default) + - [New `healthcheck-dial-concurrency` flag](#healthcheck-dial-concurrency-flag) - **[Minor Changes](#minor-changes)** - **[New Stats](#new-stats)** - [VTTablet Query Cache Hits and Misses](#vttablet-query-cache-hits-and-misses) @@ -72,6 +73,10 @@ The `--pprof-http` flag, which was introduced in v19 with a default of `true`, h This makes HTTP `pprof` endpoints now an *opt-in* feature, rather than opt-out. To continue enabling these endpoints, explicitly set `--pprof-http` when starting up Vitess components. +#### New `--healthcheck-dial-concurrency` flag + +The new `--healthcheck-dial-concurrency` flag defines the maximum number of healthcheck connections that can open concurrently. This limit is to avoid hitting Go runtime panics on deployments watching enough tablets [to hit the runtime's maximum thread limit of `10000`](https://pkg.go.dev/runtime/debug#SetMaxThreads) due to blocking network syscalls. This flag applies to `vtcombo`, `vtctld` and `vtgate` only and a value less than the runtime max thread limit _(`10000`)_ is recommended. + ## Minor Changes ### New Stats diff --git a/go/flags/endtoend/vtcombo.txt b/go/flags/endtoend/vtcombo.txt index 26e145e6930..a508b78dc80 100644 --- a/go/flags/endtoend/vtcombo.txt +++ b/go/flags/endtoend/vtcombo.txt @@ -167,6 +167,7 @@ Flags: --grpc_server_keepalive_timeout duration After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that the connection is closed. (default 10s) --grpc_use_effective_callerid If set, and SSL is not used, will set the immediate caller id from the effective caller id's principal. --health_check_interval duration Interval between health checks (default 20s) + --healthcheck-dial-concurrency int Maximum concurrency of new healthcheck connections. This should be less than the golang max thread limit of 10000. (default 1024) --healthcheck_retry_delay duration health check retry delay (default 2ms) --healthcheck_timeout duration the health check timeout period (default 1m0s) --heartbeat_enable If true, vttablet records (if master) or checks (if replica) the current time of a replication heartbeat in the sidecar database's heartbeat table. The result is used to inform the serving state of the vttablet via healthchecks. diff --git a/go/flags/endtoend/vtctld.txt b/go/flags/endtoend/vtctld.txt index da60dfeb3b1..e0f552d2b00 100644 --- a/go/flags/endtoend/vtctld.txt +++ b/go/flags/endtoend/vtctld.txt @@ -84,6 +84,7 @@ Flags: --grpc_server_keepalive_enforcement_policy_permit_without_stream gRPC server permit client keepalive pings even when there are no active streams (RPCs) --grpc_server_keepalive_time duration After a duration of this time, if the server doesn't see any activity, it pings the client to see if the transport is still alive. (default 10s) --grpc_server_keepalive_timeout duration After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that the connection is closed. (default 10s) + --healthcheck-dial-concurrency int Maximum concurrency of new healthcheck connections. This should be less than the golang max thread limit of 10000. (default 1024) -h, --help help for vtctld --jaeger-agent-host string host and port to send spans to. if empty, no tracing will be done --keep_logs duration keep logs for this long (using ctime) (zero to keep forever) diff --git a/go/flags/endtoend/vtgate.txt b/go/flags/endtoend/vtgate.txt index bd9849cfd71..c9431fb43db 100644 --- a/go/flags/endtoend/vtgate.txt +++ b/go/flags/endtoend/vtgate.txt @@ -96,6 +96,7 @@ Flags: --grpc_server_keepalive_time duration After a duration of this time, if the server doesn't see any activity, it pings the client to see if the transport is still alive. (default 10s) --grpc_server_keepalive_timeout duration After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that the connection is closed. (default 10s) --grpc_use_effective_callerid If set, and SSL is not used, will set the immediate caller id from the effective caller id's principal. + --healthcheck-dial-concurrency int Maximum concurrency of new healthcheck connections. This should be less than the golang max thread limit of 10000. (default 1024) --healthcheck_retry_delay duration health check retry delay (default 2ms) --healthcheck_timeout duration the health check timeout period (default 1m0s) -h, --help help for vtgate diff --git a/go/vt/discovery/healthcheck.go b/go/vt/discovery/healthcheck.go index 6b30a794893..f37c9ad1d8b 100644 --- a/go/vt/discovery/healthcheck.go +++ b/go/vt/discovery/healthcheck.go @@ -46,6 +46,7 @@ import ( "github.com/google/safehtml/template" "github.com/google/safehtml/template/uncheckedconversions" "github.com/spf13/pflag" + "golang.org/x/sync/semaphore" "vitess.io/vitess/go/netutil" "vitess.io/vitess/go/stats" @@ -87,6 +88,9 @@ var ( // refreshKnownTablets tells us whether to process all tablets or only new tablets. refreshKnownTablets = true + // healthCheckDialConcurrency tells us how many healthcheck connections can be opened to tablets at once. This should be less than the golang max thread limit of 10000. + healthCheckDialConcurrency int64 = 1024 + // How much to sleep between each check. waitAvailableTabletInterval = 100 * time.Millisecond @@ -168,6 +172,7 @@ func registerWebUIFlags(fs *pflag.FlagSet) { fs.StringVar(&TabletURLTemplateString, "tablet_url_template", "http://{{.GetTabletHostPort}}", "Format string describing debug tablet url formatting. See getTabletDebugURL() for how to customize this.") fs.DurationVar(&refreshInterval, "tablet_refresh_interval", 1*time.Minute, "Tablet refresh interval.") fs.BoolVar(&refreshKnownTablets, "tablet_refresh_known_tablets", true, "Whether to reload the tablet's address/port map from topo in case they change.") + fs.Int64Var(&healthCheckDialConcurrency, "healthcheck-dial-concurrency", 1024, "Maximum concurrency of new healthcheck connections. This should be less than the golang max thread limit of 10000.") ParseTabletURLTemplateFromFlag() } @@ -287,6 +292,8 @@ type HealthCheckImpl struct { subscribers map[chan *TabletHealth]struct{} // loadTablets trigger is used to immediately load a new primary tablet when the current one has been demoted loadTabletsTrigger chan struct{} + // healthCheckDialSem is used to limit how many healthcheck connections can be opened to tablets at once. + healthCheckDialSem *semaphore.Weighted } // NewHealthCheck creates a new HealthCheck object. @@ -321,6 +328,7 @@ func NewHealthCheck(ctx context.Context, retryDelay, healthCheckTimeout time.Dur cell: localCell, retryDelay: retryDelay, healthCheckTimeout: healthCheckTimeout, + healthCheckDialSem: semaphore.NewWeighted(healthCheckDialConcurrency), healthByAlias: make(map[tabletAliasString]*tabletHealthCheck), healthData: make(map[KeyspaceShardTabletType]map[tabletAliasString]*TabletHealth), healthy: make(map[KeyspaceShardTabletType][]*TabletHealth), @@ -828,7 +836,7 @@ func (hc *HealthCheckImpl) TabletConnection(alias *topodata.TabletAlias, target // TODO: test that throws this error return nil, vterrors.Errorf(vtrpc.Code_NOT_FOUND, "tablet: %v is either down or nonexistent", alias) } - return thc.Connection(), nil + return thc.Connection(hc), nil } // getAliasByCell should only be called while holding hc.mu diff --git a/go/vt/discovery/tablet_health_check.go b/go/vt/discovery/tablet_health_check.go index 24496155e74..fc3ab242210 100644 --- a/go/vt/discovery/tablet_health_check.go +++ b/go/vt/discovery/tablet_health_check.go @@ -19,6 +19,7 @@ package discovery import ( "context" "fmt" + "net" "strings" "sync" "sync/atomic" @@ -33,12 +34,16 @@ import ( "vitess.io/vitess/go/vt/vttablet/queryservice" "vitess.io/vitess/go/vt/vttablet/tabletconn" + "google.golang.org/grpc" "google.golang.org/protobuf/proto" "vitess.io/vitess/go/vt/proto/query" "vitess.io/vitess/go/vt/proto/topodata" ) +// withDialerContextOnce ensures grpc.WithDialContext() is added once to the options. +var withDialerContextOnce sync.Once + // tabletHealthCheck maintains the health status of a tablet. A map of this // structure is maintained in HealthCheck. type tabletHealthCheck struct { @@ -122,8 +127,8 @@ func (thc *tabletHealthCheck) setServingState(serving bool, reason string) { } // stream streams healthcheck responses to callback. -func (thc *tabletHealthCheck) stream(ctx context.Context, callback func(*query.StreamHealthResponse) error) error { - conn := thc.Connection() +func (thc *tabletHealthCheck) stream(ctx context.Context, hc *HealthCheckImpl, callback func(*query.StreamHealthResponse) error) error { + conn := thc.Connection(hc) if conn == nil { // This signals the caller to retry return nil @@ -136,14 +141,34 @@ func (thc *tabletHealthCheck) stream(ctx context.Context, callback func(*query.S return err } -func (thc *tabletHealthCheck) Connection() queryservice.QueryService { +func (thc *tabletHealthCheck) Connection(hc *HealthCheckImpl) queryservice.QueryService { thc.connMu.Lock() defer thc.connMu.Unlock() - return thc.connectionLocked() + return thc.connectionLocked(hc) +} + +func healthCheckDialerFactory(hc *HealthCheckImpl) func(ctx context.Context, addr string) (net.Conn, error) { + return func(ctx context.Context, addr string) (net.Conn, error) { + // Limit the number of healthcheck connections opened in parallel to avoid high OS-thread + // usage due to blocking networking syscalls (eg: DNS lookups, TCP connection opens, + // etc). Without this limit it is possible for vtgates watching >10k tablets to hit + // the panic: 'runtime: program exceeds 10000-thread limit'. + if err := hc.healthCheckDialSem.Acquire(ctx, 1); err != nil { + return nil, err + } + defer hc.healthCheckDialSem.Release(1) + var dialer net.Dialer + return dialer.DialContext(ctx, "tcp", addr) + } } -func (thc *tabletHealthCheck) connectionLocked() queryservice.QueryService { +func (thc *tabletHealthCheck) connectionLocked(hc *HealthCheckImpl) queryservice.QueryService { if thc.Conn == nil { + withDialerContextOnce.Do(func() { + grpcclient.RegisterGRPCDialOptions(func(opts []grpc.DialOption) ([]grpc.DialOption, error) { + return append(opts, grpc.WithContextDialer(healthCheckDialerFactory(hc))), nil + }) + }) conn, err := tabletconn.GetDialer()(thc.Tablet, grpcclient.FailFast(true)) if err != nil { thc.LastError = err @@ -272,7 +297,7 @@ func (thc *tabletHealthCheck) checkConn(hc *HealthCheckImpl) { }() // Read stream health responses. - err := thc.stream(streamCtx, func(shr *query.StreamHealthResponse) error { + err := thc.stream(streamCtx, hc, func(shr *query.StreamHealthResponse) error { // We received a message. Reset the back-off. retryDelay = hc.retryDelay // Don't block on send to avoid deadlocks. diff --git a/go/vt/grpcclient/client.go b/go/vt/grpcclient/client.go index b2ef0d4fb28..7524298514e 100644 --- a/go/vt/grpcclient/client.go +++ b/go/vt/grpcclient/client.go @@ -21,6 +21,7 @@ package grpcclient import ( "context" "crypto/tls" + "sync" "time" grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware" @@ -39,6 +40,7 @@ import ( ) var ( + grpcDialOptionsMu sync.Mutex keepaliveTime = 10 * time.Second keepaliveTimeout = 10 * time.Second initialConnWindowSize int @@ -86,6 +88,8 @@ var grpcDialOptions []func(opts []grpc.DialOption) ([]grpc.DialOption, error) // RegisterGRPCDialOptions registers an implementation of AuthServer. func RegisterGRPCDialOptions(grpcDialOptionsFunc func(opts []grpc.DialOption) ([]grpc.DialOption, error)) { + grpcDialOptionsMu.Lock() + defer grpcDialOptionsMu.Unlock() grpcDialOptions = append(grpcDialOptions, grpcDialOptionsFunc) } @@ -134,12 +138,14 @@ func DialContext(ctx context.Context, target string, failFast FailFast, opts ... newopts = append(newopts, opts...) var err error + grpcDialOptionsMu.Lock() for _, grpcDialOptionInitializer := range grpcDialOptions { newopts, err = grpcDialOptionInitializer(newopts) if err != nil { log.Fatalf("There was an error initializing client grpc.DialOption: %v", err) } } + grpcDialOptionsMu.Unlock() newopts = append(newopts, interceptors()...) From 020036987fdef231fee47caf930c3eb412436168 Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Wed, 28 Feb 2024 15:01:36 -0500 Subject: [PATCH 68/79] delete unused code in vreplication e2e tests (#15378) Signed-off-by: Andrew Mason --- go/test/endtoend/vreplication/cluster_test.go | 3 --- go/test/endtoend/vreplication/fk_ext_test.go | 4 ---- go/test/endtoend/vreplication/performance_test.go | 2 -- 3 files changed, 9 deletions(-) diff --git a/go/test/endtoend/vreplication/cluster_test.go b/go/test/endtoend/vreplication/cluster_test.go index 7d22d063945..6fd63edb200 100644 --- a/go/test/endtoend/vreplication/cluster_test.go +++ b/go/test/endtoend/vreplication/cluster_test.go @@ -139,9 +139,6 @@ type Keyspace struct { VSchema string Schema string SidecarDBName string - - numReplicas int - numRDOnly int } // Shard represents a Vitess shard in a keyspace diff --git a/go/test/endtoend/vreplication/fk_ext_test.go b/go/test/endtoend/vreplication/fk_ext_test.go index 401b99360d8..4e493da5baf 100644 --- a/go/test/endtoend/vreplication/fk_ext_test.go +++ b/go/test/endtoend/vreplication/fk_ext_test.go @@ -32,10 +32,6 @@ import ( binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" ) -const ( - shardStatusWaitTimeout = 30 * time.Second -) - var ( //go:embed schema/fkext/source_schema.sql FKExtSourceSchema string diff --git a/go/test/endtoend/vreplication/performance_test.go b/go/test/endtoend/vreplication/performance_test.go index 6940665c842..43157c8923d 100644 --- a/go/test/endtoend/vreplication/performance_test.go +++ b/go/test/endtoend/vreplication/performance_test.go @@ -43,8 +43,6 @@ create table largebin(pid int, maindata varbinary(4096), primary key(pid)); create table customer(cid int, name varbinary(128), meta json default null, typ enum('individual','soho','enterprise'), sport set('football','cricket','baseball'),ts timestamp not null default current_timestamp, primary key(cid)) CHARSET=utf8mb4; ` - const defaultCellName = "zone1" - const sourceKs = "stress_src" const targetKs = "stress_tgt" From 15f58869c45e47875f26e95291bcc656a686a269 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20Taylor?= Date: Wed, 28 Feb 2024 21:52:44 +0100 Subject: [PATCH 69/79] Bugfix: GROUP BY/HAVING alias resolution (#15344) --- .../queries/aggregation/aggregation_test.go | 97 ++++++- go/vt/vtgate/executor_select_test.go | 12 +- .../planbuilder/testdata/aggr_cases.json | 146 ++++++---- .../planbuilder/testdata/cte_cases.json | 2 +- .../planbuilder/testdata/filter_cases.json | 4 +- .../testdata/memory_sort_cases.json | 16 +- .../planbuilder/testdata/oltp_cases.json | 4 +- .../testdata/postprocess_cases.json | 32 +-- .../planbuilder/testdata/select_cases.json | 14 +- .../planbuilder/testdata/tpcc_cases.json | 6 +- .../planbuilder/testdata/tpch_cases.json | 10 +- .../planbuilder/testdata/union_cases.json | 12 +- go/vt/vtgate/semantics/analyzer.go | 25 +- go/vt/vtgate/semantics/analyzer_test.go | 60 ++-- go/vt/vtgate/semantics/binder.go | 168 ++++++++++- go/vt/vtgate/semantics/dependencies.go | 5 +- go/vt/vtgate/semantics/early_rewriter.go | 257 +++++++++++------ go/vt/vtgate/semantics/early_rewriter_test.go | 272 +++++++++++++++--- go/vt/vtgate/semantics/errors.go | 41 ++- go/vt/vtgate/semantics/scoper.go | 35 ++- go/vt/vtgate/semantics/vtable.go | 27 +- 21 files changed, 935 insertions(+), 310 deletions(-) diff --git a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go index da2e14218fe..05a45abac69 100644 --- a/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go +++ b/go/test/endtoend/vtgate/queries/aggregation/aggregation_test.go @@ -40,7 +40,21 @@ func start(t *testing.T) (utils.MySQLCompare, func()) { deleteAll := func() { _, _ = utils.ExecAllowError(t, mcmp.VtConn, "set workload = oltp") - tables := []string{"t9", "aggr_test", "t3", "t7_xxhash", "aggr_test_dates", "t7_xxhash_idx", "t1", "t2", "t10"} + tables := []string{ + "t3", + "t3_id7_idx", + "t9", + "aggr_test", + "aggr_test_dates", + "t7_xxhash", + "t7_xxhash_idx", + "t1", + "t2", + "t10", + "emp", + "dept", + "bet_logs", + } for _, table := range tables { _, _ = mcmp.ExecAndIgnore("delete from " + table) } @@ -673,3 +687,84 @@ func TestDistinctAggregation(t *testing.T) { }) } } + +func TestHavingQueries(t *testing.T) { + mcmp, closer := start(t) + defer closer() + + inserts := []string{ + `INSERT INTO emp (empno, ename, job, mgr, hiredate, sal, comm, deptno) VALUES + (1, 'John', 'Manager', NULL, '2022-01-01', 5000, 500, 1), + (2, 'Doe', 'Analyst', 1, '2023-01-01', 4500, NULL, 1), + (3, 'Jane', 'Clerk', 1, '2023-02-01', 3000, 200, 2), + (4, 'Mary', 'Analyst', 2, '2022-03-01', 4700, NULL, 1), + (5, 'Smith', 'Salesman', 3, '2023-01-15', 3200, 300, 3)`, + "INSERT INTO dept (deptno, dname, loc) VALUES (1, 'IT', 'New York'), (2, 'HR', 'London'), (3, 'Sales', 'San Francisco')", + "INSERT INTO t1 (t1_id, name, value, shardKey) VALUES (1, 'Name1', 'Value1', 100), (2, 'Name2', 'Value2', 100), (3, 'Name1', 'Value3', 200)", + "INSERT INTO aggr_test_dates (id, val1, val2) VALUES (1, '2023-01-01', '2023-01-02'), (2, '2023-02-01', '2023-02-02'), (3, '2023-03-01', '2023-03-02')", + "INSERT INTO t10 (k, a, b) VALUES (1, 10, 20), (2, 30, 40), (3, 50, 60)", + "INSERT INTO t3 (id5, id6, id7) VALUES (1, 10, 100), (2, 20, 200), (3, 30, 300)", + "INSERT INTO t9 (id1, id2, id3) VALUES (1, 'A1', 'B1'), (2, 'A2', 'B2'), (3, 'A1', 'B3')", + "INSERT INTO aggr_test (id, val1, val2) VALUES (1, 'Test1', 100), (2, 'Test2', 200), (3, 'Test1', 300), (4, 'Test3', 400)", + "INSERT INTO t2 (id, shardKey) VALUES (1, 100), (2, 200), (3, 300)", + `INSERT INTO bet_logs (id, merchant_game_id, bet_amount, game_id) VALUES + (1, 1, 100.0, 10), + (2, 1, 200.0, 11), + (3, 2, 300.0, 10), + (4, 3, 400.0, 12)`, + } + + for _, insert := range inserts { + mcmp.Exec(insert) + } + + queries := []string{ + // The following queries are not allowed by MySQL but Vitess allows them + // SELECT ename FROM emp GROUP BY ename HAVING sal > 5000 + // SELECT val1, COUNT(val2) FROM aggr_test_dates GROUP BY val1 HAVING val2 > 5 + // SELECT k, a FROM t10 GROUP BY k HAVING b > 2 + // SELECT loc FROM dept GROUP BY loc HAVING COUNT(deptno) AND dname = 'Sales' + // SELECT AVG(val2) AS average_val2 FROM aggr_test HAVING val1 = 'Test' + + // these first queries are all failing in different ways. let's check that Vitess also fails + + "SELECT deptno, AVG(sal) AS average_salary HAVING average_salary > 5000 FROM emp", + "SELECT job, COUNT(empno) AS num_employees FROM emp HAVING num_employees > 2", + "SELECT dname, SUM(sal) FROM dept JOIN emp ON dept.deptno = emp.deptno HAVING AVG(sal) > 6000", + "SELECT COUNT(*) AS count FROM emp WHERE count > 5", + "SELECT `name`, AVG(`value`) FROM t1 GROUP BY `name` HAVING `name`", + "SELECT empno, MAX(sal) FROM emp HAVING COUNT(*) > 3", + "SELECT id, SUM(bet_amount) AS total_bets FROM bet_logs HAVING total_bets > 1000", + "SELECT merchant_game_id FROM bet_logs GROUP BY merchant_game_id HAVING SUM(bet_amount)", + "SELECT shardKey, COUNT(id) FROM t2 HAVING shardKey > 100", + "SELECT deptno FROM emp GROUP BY deptno HAVING MAX(hiredate) > '2020-01-01'", + + // These queries should not fail + "SELECT deptno, COUNT(*) AS num_employees FROM emp GROUP BY deptno HAVING num_employees > 5", + "SELECT ename, SUM(sal) FROM emp GROUP BY ename HAVING SUM(sal) > 10000", + "SELECT dname, AVG(sal) AS average_salary FROM emp JOIN dept ON emp.deptno = dept.deptno GROUP BY dname HAVING average_salary > 5000", + "SELECT dname, MAX(sal) AS max_salary FROM emp JOIN dept ON emp.deptno = dept.deptno GROUP BY dname HAVING max_salary < 10000", + "SELECT YEAR(hiredate) AS year, COUNT(*) FROM emp GROUP BY year HAVING COUNT(*) > 2", + "SELECT mgr, COUNT(empno) AS managed_employees FROM emp WHERE mgr IS NOT NULL GROUP BY mgr HAVING managed_employees >= 3", + "SELECT deptno, SUM(comm) AS total_comm FROM emp GROUP BY deptno HAVING total_comm > AVG(total_comm)", + "SELECT id2, COUNT(*) AS count FROM t9 GROUP BY id2 HAVING count > 1", + "SELECT val1, COUNT(*) FROM aggr_test GROUP BY val1 HAVING COUNT(*) > 1", + "SELECT DATE(val1) AS date, SUM(val2) FROM aggr_test_dates GROUP BY date HAVING SUM(val2) > 100", + "SELECT shardKey, AVG(`value`) FROM t1 WHERE `value` IS NOT NULL GROUP BY shardKey HAVING AVG(`value`) > 10", + "SELECT job, COUNT(*) AS job_count FROM emp GROUP BY job HAVING job_count > 3", + "SELECT b, AVG(a) AS avg_a FROM t10 GROUP BY b HAVING AVG(a) > 5", + "SELECT merchant_game_id, SUM(bet_amount) AS total_bets FROM bet_logs GROUP BY merchant_game_id HAVING total_bets > 1000", + "SELECT loc, COUNT(deptno) AS num_depts FROM dept GROUP BY loc HAVING num_depts > 1", + "SELECT `name`, COUNT(*) AS name_count FROM t1 GROUP BY `name` HAVING name_count > 2", + "SELECT COUNT(*) AS num_jobs FROM emp GROUP BY empno HAVING num_jobs > 1", + "SELECT id, COUNT(*) AS count FROM t2 GROUP BY id HAVING count > 1", + "SELECT val2, SUM(id) FROM aggr_test GROUP BY val2 HAVING SUM(id) > 10", + "SELECT game_id, COUNT(*) AS num_logs FROM bet_logs GROUP BY game_id HAVING num_logs > 5", + } + + for _, query := range queries { + mcmp.Run(query, func(mcmp *utils.MySQLCompare) { + mcmp.ExecAllowAndCompareError(query) + }) + } +} diff --git a/go/vt/vtgate/executor_select_test.go b/go/vt/vtgate/executor_select_test.go index d73445e4160..8f3e436deb8 100644 --- a/go/vt/vtgate/executor_select_test.go +++ b/go/vt/vtgate/executor_select_test.go @@ -1932,7 +1932,7 @@ func TestSelectScatterOrderBy(t *testing.T) { require.NoError(t, err) wantQueries := []*querypb.BoundQuery{{ - Sql: "select col1, col2, weight_string(col2) from `user` order by col2 desc", + Sql: "select col1, col2, weight_string(col2) from `user` order by `user`.col2 desc", BindVariables: map[string]*querypb.BindVariable{}, }} for _, conn := range conns { @@ -2005,7 +2005,7 @@ func TestSelectScatterOrderByVarChar(t *testing.T) { require.NoError(t, err) wantQueries := []*querypb.BoundQuery{{ - Sql: "select col1, textcol, weight_string(textcol) from `user` order by textcol desc", + Sql: "select col1, textcol, weight_string(textcol) from `user` order by `user`.textcol desc", BindVariables: map[string]*querypb.BindVariable{}, }} for _, conn := range conns { @@ -2071,7 +2071,7 @@ func TestStreamSelectScatterOrderBy(t *testing.T) { require.NoError(t, err) wantQueries := []*querypb.BoundQuery{{ - Sql: "select id, col, weight_string(col) from `user` order by col desc", + Sql: "select id, col, weight_string(col) from `user` order by `user`.col desc", BindVariables: map[string]*querypb.BindVariable{}, }} for _, conn := range conns { @@ -2133,7 +2133,7 @@ func TestStreamSelectScatterOrderByVarChar(t *testing.T) { require.NoError(t, err) wantQueries := []*querypb.BoundQuery{{ - Sql: "select id, textcol, weight_string(textcol) from `user` order by textcol desc", + Sql: "select id, textcol, weight_string(textcol) from `user` order by `user`.textcol desc", BindVariables: map[string]*querypb.BindVariable{}, }} for _, conn := range conns { @@ -2329,7 +2329,7 @@ func TestSelectScatterLimit(t *testing.T) { require.NoError(t, err) wantQueries := []*querypb.BoundQuery{{ - Sql: "select col1, col2, weight_string(col2) from `user` order by col2 desc limit :__upper_limit", + Sql: "select col1, col2, weight_string(col2) from `user` order by `user`.col2 desc limit :__upper_limit", BindVariables: map[string]*querypb.BindVariable{"__upper_limit": sqltypes.Int64BindVariable(3)}, }} for _, conn := range conns { @@ -2401,7 +2401,7 @@ func TestStreamSelectScatterLimit(t *testing.T) { require.NoError(t, err) wantQueries := []*querypb.BoundQuery{{ - Sql: "select col1, col2, weight_string(col2) from `user` order by col2 desc limit :__upper_limit", + Sql: "select col1, col2, weight_string(col2) from `user` order by `user`.col2 desc limit :__upper_limit", BindVariables: map[string]*querypb.BindVariable{"__upper_limit": sqltypes.Int64BindVariable(3)}, }} for _, conn := range conns { diff --git a/go/vt/vtgate/planbuilder/testdata/aggr_cases.json b/go/vt/vtgate/planbuilder/testdata/aggr_cases.json index 5acbfbe61bc..e98f53bb4cf 100644 --- a/go/vt/vtgate/planbuilder/testdata/aggr_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/aggr_cases.json @@ -675,10 +675,15 @@ } }, { - "comment": "scatter aggregate group by aggregate function", + "comment": "scatter aggregate group by aggregate function - since we don't have authoratative columns for user, we can't be sure that the user isn't referring a column named b", "query": "select count(*) b from user group by b", "plan": "VT03005: cannot group on 'count(*)'" }, + { + "comment": "scatter aggregate group by aggregate function with column information", + "query": "select count(*) b from authoritative group by b", + "plan": "VT03005: cannot group on 'b'" + }, { "comment": "scatter aggregate multiple group by (columns)", "query": "select a, b, count(*) from user group by a, b", @@ -893,7 +898,7 @@ }, "FieldQuery": "select a, b, c, d, count(*), weight_string(a), weight_string(b), weight_string(c) from `user` where 1 != 1 group by a, b, c, weight_string(a), weight_string(b), weight_string(c)", "OrderBy": "(0|5) ASC, (1|6) ASC, (2|7) ASC", - "Query": "select a, b, c, d, count(*), weight_string(a), weight_string(b), weight_string(c) from `user` group by a, b, c, weight_string(a), weight_string(b), weight_string(c) order by a asc, b asc, c asc", + "Query": "select a, b, c, d, count(*), weight_string(a), weight_string(b), weight_string(c) from `user` group by a, b, c, weight_string(a), weight_string(b), weight_string(c) order by `user`.a asc, `user`.b asc, `user`.c asc", "Table": "`user`" } ] @@ -925,7 +930,7 @@ }, "FieldQuery": "select a, b, c, d, count(*), weight_string(d), weight_string(b), weight_string(a), weight_string(c) from `user` where 1 != 1 group by d, b, a, c, weight_string(d), weight_string(b), weight_string(a), weight_string(c)", "OrderBy": "(3|5) ASC, (1|6) ASC, (0|7) ASC, (2|8) ASC", - "Query": "select a, b, c, d, count(*), weight_string(d), weight_string(b), weight_string(a), weight_string(c) from `user` group by d, b, a, c, weight_string(d), weight_string(b), weight_string(a), weight_string(c) order by d asc, b asc, a asc, c asc", + "Query": "select a, b, c, d, count(*), weight_string(d), weight_string(b), weight_string(a), weight_string(c) from `user` group by d, b, a, c, weight_string(d), weight_string(b), weight_string(a), weight_string(c) order by `user`.d asc, `user`.b asc, `user`.a asc, `user`.c asc", "Table": "`user`" } ] @@ -957,7 +962,7 @@ }, "FieldQuery": "select a, b, c, d, count(*), weight_string(d), weight_string(b), weight_string(a), weight_string(c) from `user` where 1 != 1 group by d, b, a, c, weight_string(d), weight_string(b), weight_string(a), weight_string(c)", "OrderBy": "(3|5) ASC, (1|6) ASC, (0|7) ASC, (2|8) ASC", - "Query": "select a, b, c, d, count(*), weight_string(d), weight_string(b), weight_string(a), weight_string(c) from `user` group by d, b, a, c, weight_string(d), weight_string(b), weight_string(a), weight_string(c) order by d asc, b asc, a asc, c asc", + "Query": "select a, b, c, d, count(*), weight_string(d), weight_string(b), weight_string(a), weight_string(c) from `user` group by d, b, a, c, weight_string(d), weight_string(b), weight_string(a), weight_string(c) order by `user`.d asc, `user`.b asc, `user`.a asc, `user`.c asc", "Table": "`user`" } ] @@ -989,7 +994,7 @@ }, "FieldQuery": "select a, b, c, count(*), weight_string(a), weight_string(c), weight_string(b) from `user` where 1 != 1 group by a, c, b, weight_string(a), weight_string(c), weight_string(b)", "OrderBy": "(0|4) DESC, (2|5) DESC, (1|6) ASC", - "Query": "select a, b, c, count(*), weight_string(a), weight_string(c), weight_string(b) from `user` group by a, c, b, weight_string(a), weight_string(c), weight_string(b) order by a desc, c desc, b asc", + "Query": "select a, b, c, count(*), weight_string(a), weight_string(c), weight_string(b) from `user` group by a, c, b, weight_string(a), weight_string(c), weight_string(b) order by a desc, c desc, `user`.b asc", "Table": "`user`" } ] @@ -1041,32 +1046,6 @@ ] } }, - { - "comment": "Group by with collate operator", - "query": "select user.col1 as a from user where user.id = 5 group by a collate utf8_general_ci", - "plan": { - "QueryType": "SELECT", - "Original": "select user.col1 as a from user where user.id = 5 group by a collate utf8_general_ci", - "Instructions": { - "OperatorType": "Route", - "Variant": "EqualUnique", - "Keyspace": { - "Name": "user", - "Sharded": true - }, - "FieldQuery": "select `user`.col1 as a from `user` where 1 != 1 group by `user`.col1 collate utf8_general_ci", - "Query": "select `user`.col1 as a from `user` where `user`.id = 5 group by `user`.col1 collate utf8_general_ci", - "Table": "`user`", - "Values": [ - "5" - ], - "Vindex": "user_index" - }, - "TablesUsed": [ - "user.user" - ] - } - }, { "comment": "routing rules for aggregates", "query": "select id, count(*) from route2 group by id", @@ -1103,7 +1082,7 @@ "Sharded": true }, "FieldQuery": "select col from ref where 1 != 1", - "Query": "select col from ref order by col asc", + "Query": "select col from ref order by ref.col asc", "Table": "ref" }, "TablesUsed": [ @@ -1584,10 +1563,10 @@ }, { "comment": "weight_string addition to group by", - "query": "select lower(textcol1) as v, count(*) from user group by v", + "query": "select lower(col1) as v, count(*) from authoritative group by v", "plan": { "QueryType": "SELECT", - "Original": "select lower(textcol1) as v, count(*) from user group by v", + "Original": "select lower(col1) as v, count(*) from authoritative group by v", "Instructions": { "OperatorType": "Aggregate", "Variant": "Ordered", @@ -1602,24 +1581,24 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select lower(textcol1) as v, count(*), weight_string(lower(textcol1)) from `user` where 1 != 1 group by lower(textcol1), weight_string(lower(textcol1))", + "FieldQuery": "select lower(col1) as v, count(*), weight_string(lower(col1)) from authoritative where 1 != 1 group by lower(col1), weight_string(lower(col1))", "OrderBy": "(0|2) ASC", - "Query": "select lower(textcol1) as v, count(*), weight_string(lower(textcol1)) from `user` group by lower(textcol1), weight_string(lower(textcol1)) order by lower(textcol1) asc", - "Table": "`user`" + "Query": "select lower(col1) as v, count(*), weight_string(lower(col1)) from authoritative group by lower(col1), weight_string(lower(col1)) order by lower(col1) asc", + "Table": "authoritative" } ] }, "TablesUsed": [ - "user.user" + "user.authoritative" ] } }, { "comment": "weight_string addition to group by when also there in order by", - "query": "select char_length(texcol1) as a, count(*) from user group by a order by a", + "query": "select char_length(col1) as a, count(*) from authoritative group by a order by a", "plan": { "QueryType": "SELECT", - "Original": "select char_length(texcol1) as a, count(*) from user group by a order by a", + "Original": "select char_length(col1) as a, count(*) from authoritative group by a order by a", "Instructions": { "OperatorType": "Aggregate", "Variant": "Ordered", @@ -1634,15 +1613,15 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select char_length(texcol1) as a, count(*), weight_string(char_length(texcol1)) from `user` where 1 != 1 group by char_length(texcol1), weight_string(char_length(texcol1))", + "FieldQuery": "select char_length(col1) as a, count(*), weight_string(char_length(col1)) from authoritative where 1 != 1 group by char_length(col1), weight_string(char_length(col1))", "OrderBy": "(0|2) ASC", - "Query": "select char_length(texcol1) as a, count(*), weight_string(char_length(texcol1)) from `user` group by char_length(texcol1), weight_string(char_length(texcol1)) order by char_length(texcol1) asc", - "Table": "`user`" + "Query": "select char_length(col1) as a, count(*), weight_string(char_length(col1)) from authoritative group by char_length(col1), weight_string(char_length(col1)) order by char_length(authoritative.col1) asc", + "Table": "authoritative" } ] }, "TablesUsed": [ - "user.user" + "user.authoritative" ] } }, @@ -1699,7 +1678,7 @@ }, "FieldQuery": "select col, id, weight_string(id) from `user` where 1 != 1", "OrderBy": "(1|2) ASC", - "Query": "select col, id, weight_string(id) from `user` order by id asc", + "Query": "select col, id, weight_string(id) from `user` order by `user`.id asc", "ResultColumns": 2, "Table": "`user`" }, @@ -2009,19 +1988,20 @@ }, { "comment": "Less Equal filter on scatter with grouping", - "query": "select col, count(*) a from user group by col having a <= 10", + "query": "select col1, count(*) a from user group by col1 having a <= 10", "plan": { "QueryType": "SELECT", - "Original": "select col, count(*) a from user group by col having a <= 10", + "Original": "select col1, count(*) a from user group by col1 having a <= 10", "Instructions": { "OperatorType": "Filter", "Predicate": "count(*) <= 10", + "ResultColumns": 2, "Inputs": [ { "OperatorType": "Aggregate", "Variant": "Ordered", "Aggregates": "sum_count_star(1) AS a", - "GroupBy": "0", + "GroupBy": "(0|2)", "Inputs": [ { "OperatorType": "Route", @@ -2030,9 +2010,9 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select col, count(*) as a from `user` where 1 != 1 group by col", - "OrderBy": "0 ASC", - "Query": "select col, count(*) as a from `user` group by col order by col asc", + "FieldQuery": "select col1, count(*) as a, weight_string(col1) from `user` where 1 != 1 group by col1, weight_string(col1)", + "OrderBy": "(0|2) ASC", + "Query": "select col1, count(*) as a, weight_string(col1) from `user` group by col1, weight_string(col1) order by col1 asc", "Table": "`user`" } ] @@ -2046,10 +2026,10 @@ }, { "comment": "We should be able to find grouping keys on ordered aggregates", - "query": "select count(*) as a, val1 from user group by val1 having a = 1.00", + "query": "select count(*) as a, col2 from user group by col2 having a = 1.00", "plan": { "QueryType": "SELECT", - "Original": "select count(*) as a, val1 from user group by val1 having a = 1.00", + "Original": "select count(*) as a, col2 from user group by col2 having a = 1.00", "Instructions": { "OperatorType": "Filter", "Predicate": "count(*) = 1.00", @@ -2068,9 +2048,9 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select count(*) as a, val1, weight_string(val1) from `user` where 1 != 1 group by val1, weight_string(val1)", + "FieldQuery": "select count(*) as a, col2, weight_string(col2) from `user` where 1 != 1 group by col2, weight_string(col2)", "OrderBy": "(1|2) ASC", - "Query": "select count(*) as a, val1, weight_string(val1) from `user` group by val1, weight_string(val1) order by val1 asc", + "Query": "select count(*) as a, col2, weight_string(col2) from `user` group by col2, weight_string(col2) order by col2 asc", "Table": "`user`" } ] @@ -2620,10 +2600,10 @@ }, { "comment": "group by column alias", - "query": "select ascii(val1) as a, count(*) from user group by a", + "query": "select ascii(col2) as a, count(*) from user group by a", "plan": { "QueryType": "SELECT", - "Original": "select ascii(val1) as a, count(*) from user group by a", + "Original": "select ascii(col2) as a, count(*) from user group by a", "Instructions": { "OperatorType": "Aggregate", "Variant": "Ordered", @@ -2638,9 +2618,9 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select ascii(val1) as a, count(*), weight_string(ascii(val1)) from `user` where 1 != 1 group by ascii(val1), weight_string(ascii(val1))", + "FieldQuery": "select ascii(col2) as a, count(*), weight_string(ascii(col2)) from `user` where 1 != 1 group by ascii(col2), weight_string(ascii(col2))", "OrderBy": "(0|2) ASC", - "Query": "select ascii(val1) as a, count(*), weight_string(ascii(val1)) from `user` group by ascii(val1), weight_string(ascii(val1)) order by ascii(val1) asc", + "Query": "select ascii(col2) as a, count(*), weight_string(ascii(col2)) from `user` group by ascii(col2), weight_string(ascii(col2)) order by ascii(col2) asc", "Table": "`user`" } ] @@ -2984,7 +2964,7 @@ "Original": "select foo, sum(foo) as fooSum, sum(bar) as barSum from user group by foo having fooSum+sum(bar) = 42", "Instructions": { "OperatorType": "Filter", - "Predicate": "sum(foo) + sum(bar) = 42", + "Predicate": "sum(`user`.foo) + sum(bar) = 42", "ResultColumns": 3, "Inputs": [ { @@ -3328,10 +3308,10 @@ }, { "comment": "group by and ',' joins", - "query": "select user.id from user, user_extra group by id", + "query": "select user.id from user, user_extra group by user.id", "plan": { "QueryType": "SELECT", - "Original": "select user.id from user, user_extra group by id", + "Original": "select user.id from user, user_extra group by user.id", "Instructions": { "OperatorType": "Aggregate", "Variant": "Ordered", @@ -3555,7 +3535,7 @@ }, "FieldQuery": "select x.id, x.val1, 1, weight_string(x.val1) from (select id, val1 from `user` where 1 != 1) as x where 1 != 1", "OrderBy": "(1|3) ASC", - "Query": "select x.id, x.val1, 1, weight_string(x.val1) from (select id, val1 from `user` where val2 < 4) as x order by val1 asc limit :__upper_limit", + "Query": "select x.id, x.val1, 1, weight_string(x.val1) from (select id, val1 from `user` where val2 < 4) as x order by `user`.val1 asc limit :__upper_limit", "Table": "`user`" } ] @@ -6938,5 +6918,45 @@ "user.user" ] } + }, + { + "comment": "col is a column on user, but the HAVING is referring to an alias", + "query": "select sum(x) col from user where x > 0 having col = 2", + "plan": { + "QueryType": "SELECT", + "Original": "select sum(x) col from user where x > 0 having col = 2", + "Instructions": { + "OperatorType": "Filter", + "Predicate": "sum(`user`.x) = 2", + "Inputs": [ + { + "OperatorType": "Aggregate", + "Variant": "Scalar", + "Aggregates": "sum(0) AS col", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select sum(x) as col from `user` where 1 != 1", + "Query": "select sum(x) as col from `user` where x > 0", + "Table": "`user`" + } + ] + } + ] + }, + "TablesUsed": [ + "user.user" + ] + } + }, + { + "comment": "baz in the HAVING clause can't be accessed because of the GROUP BY", + "query": "select foo, count(bar) as x from user group by foo having baz > avg(baz) order by x", + "plan": "Unknown column 'baz' in 'having clause'" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/cte_cases.json b/go/vt/vtgate/planbuilder/testdata/cte_cases.json index a7027f80348..0d7d9020ac2 100644 --- a/go/vt/vtgate/planbuilder/testdata/cte_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/cte_cases.json @@ -348,7 +348,7 @@ }, "FieldQuery": "select x.id, x.val1, 1, weight_string(x.val1) from (select id, val1 from `user` where 1 != 1) as x where 1 != 1", "OrderBy": "(1|3) ASC", - "Query": "select x.id, x.val1, 1, weight_string(x.val1) from (select id, val1 from `user` where val2 < 4) as x order by val1 asc limit :__upper_limit", + "Query": "select x.id, x.val1, 1, weight_string(x.val1) from (select id, val1 from `user` where val2 < 4) as x order by `user`.val1 asc limit :__upper_limit", "Table": "`user`" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/filter_cases.json b/go/vt/vtgate/planbuilder/testdata/filter_cases.json index 4353f31fd48..d144da2441d 100644 --- a/go/vt/vtgate/planbuilder/testdata/filter_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/filter_cases.json @@ -4018,7 +4018,7 @@ "Sharded": true }, "FieldQuery": "select a + 2 as a from `user` where 1 != 1", - "Query": "select a + 2 as a from `user` where a + 2 = 42", + "Query": "select a + 2 as a from `user` where `user`.a + 2 = 42", "Table": "`user`" }, "TablesUsed": [ @@ -4041,7 +4041,7 @@ }, "FieldQuery": "select a + 2 as a, weight_string(a + 2) from `user` where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select a + 2 as a, weight_string(a + 2) from `user` order by a + 2 asc", + "Query": "select a + 2 as a, weight_string(a + 2) from `user` order by `user`.a + 2 asc", "ResultColumns": 1, "Table": "`user`" }, diff --git a/go/vt/vtgate/planbuilder/testdata/memory_sort_cases.json b/go/vt/vtgate/planbuilder/testdata/memory_sort_cases.json index 3ca7e1059e4..4a879997925 100644 --- a/go/vt/vtgate/planbuilder/testdata/memory_sort_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/memory_sort_cases.json @@ -24,9 +24,9 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select a, b, count(*), weight_string(a), weight_string(b) from `user` where 1 != 1 group by a, weight_string(a)", + "FieldQuery": "select a, b, count(*), weight_string(a), weight_string(`user`.b) from `user` where 1 != 1 group by a, weight_string(a)", "OrderBy": "(0|3) ASC", - "Query": "select a, b, count(*), weight_string(a), weight_string(b) from `user` group by a, weight_string(a) order by a asc", + "Query": "select a, b, count(*), weight_string(a), weight_string(`user`.b) from `user` group by a, weight_string(a) order by a asc", "Table": "`user`" } ] @@ -102,9 +102,9 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select a, b, count(*) as k, weight_string(a), weight_string(b) from `user` where 1 != 1 group by a, weight_string(a)", + "FieldQuery": "select a, b, count(*) as k, weight_string(a), weight_string(`user`.b) from `user` where 1 != 1 group by a, weight_string(a)", "OrderBy": "(0|3) ASC", - "Query": "select a, b, count(*) as k, weight_string(a), weight_string(b) from `user` group by a, weight_string(a) order by a asc", + "Query": "select a, b, count(*) as k, weight_string(a), weight_string(`user`.b) from `user` group by a, weight_string(a) order by a asc", "Table": "`user`" } ] @@ -259,7 +259,7 @@ }, "FieldQuery": "select id, weight_string(id) from (select `user`.id, `user`.col from `user` where 1 != 1) as t where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select id, weight_string(id) from (select `user`.id, `user`.col from `user`) as t order by id asc", + "Query": "select id, weight_string(id) from (select `user`.id, `user`.col from `user`) as t order by t.id asc", "Table": "`user`" }, { @@ -552,9 +552,9 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select a, convert(a, binary), weight_string(convert(a, binary)) from `user` where 1 != 1", + "FieldQuery": "select a, convert(`user`.a, binary), weight_string(convert(`user`.a, binary)) from `user` where 1 != 1", "OrderBy": "(1|2) DESC", - "Query": "select a, convert(a, binary), weight_string(convert(a, binary)) from `user` order by convert(a, binary) desc", + "Query": "select a, convert(`user`.a, binary), weight_string(convert(`user`.a, binary)) from `user` order by convert(`user`.a, binary) desc", "ResultColumns": 1, "Table": "`user`" }, @@ -624,7 +624,7 @@ }, "FieldQuery": "select id, intcol from `user` where 1 != 1", "OrderBy": "1 ASC", - "Query": "select id, intcol from `user` order by intcol asc", + "Query": "select id, intcol from `user` order by `user`.intcol asc", "Table": "`user`" }, "TablesUsed": [ diff --git a/go/vt/vtgate/planbuilder/testdata/oltp_cases.json b/go/vt/vtgate/planbuilder/testdata/oltp_cases.json index 3af909415f9..45f1ac8c618 100644 --- a/go/vt/vtgate/planbuilder/testdata/oltp_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/oltp_cases.json @@ -91,7 +91,7 @@ }, "FieldQuery": "select c from sbtest1 where 1 != 1", "OrderBy": "0 ASC COLLATE latin1_swedish_ci", - "Query": "select c from sbtest1 where id between 50 and 235 order by c asc", + "Query": "select c from sbtest1 where id between 50 and 235 order by sbtest1.c asc", "Table": "sbtest1" }, "TablesUsed": [ @@ -119,7 +119,7 @@ }, "FieldQuery": "select c from sbtest30 where 1 != 1 group by c", "OrderBy": "0 ASC COLLATE latin1_swedish_ci", - "Query": "select c from sbtest30 where id between 1 and 10 group by c order by c asc", + "Query": "select c from sbtest30 where id between 1 and 10 group by c order by sbtest30.c asc", "Table": "sbtest30" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json b/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json index 0b0c0658175..53d9a136b23 100644 --- a/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/postprocess_cases.json @@ -145,7 +145,7 @@ "Sharded": true }, "FieldQuery": "select id from `user` where 1 != 1", - "Query": "select id from `user` where :__sq_has_values and id in ::__vals", + "Query": "select id from `user` where :__sq_has_values and `user`.id in ::__vals", "Table": "`user`", "Values": [ "::__sq1" @@ -226,7 +226,7 @@ }, "FieldQuery": "select col from `user` where 1 != 1", "OrderBy": "0 ASC", - "Query": "select col from `user` order by col asc", + "Query": "select col from `user` order by `user`.col asc", "Table": "`user`" }, "TablesUsed": [ @@ -249,7 +249,7 @@ }, "FieldQuery": "select user_id, col1, col2, weight_string(user_id) from authoritative where 1 != 1", "OrderBy": "(0|3) ASC", - "Query": "select user_id, col1, col2, weight_string(user_id) from authoritative order by user_id asc", + "Query": "select user_id, col1, col2, weight_string(user_id) from authoritative order by authoritative.user_id asc", "ResultColumns": 3, "Table": "authoritative" }, @@ -273,7 +273,7 @@ }, "FieldQuery": "select user_id, col1, col2 from authoritative where 1 != 1", "OrderBy": "1 ASC COLLATE latin1_swedish_ci", - "Query": "select user_id, col1, col2 from authoritative order by col1 asc", + "Query": "select user_id, col1, col2 from authoritative order by authoritative.col1 asc", "Table": "authoritative" }, "TablesUsed": [ @@ -296,7 +296,7 @@ }, "FieldQuery": "select a, textcol1, b, weight_string(a), weight_string(b) from `user` where 1 != 1", "OrderBy": "(0|3) ASC, 1 ASC COLLATE latin1_swedish_ci, (2|4) ASC", - "Query": "select a, textcol1, b, weight_string(a), weight_string(b) from `user` order by a asc, textcol1 asc, b asc", + "Query": "select a, textcol1, b, weight_string(a), weight_string(b) from `user` order by `user`.a asc, `user`.textcol1 asc, `user`.b asc", "ResultColumns": 3, "Table": "`user`" }, @@ -320,7 +320,7 @@ }, "FieldQuery": "select a, `user`.textcol1, b, weight_string(a), weight_string(b) from `user` where 1 != 1", "OrderBy": "(0|3) ASC, 1 ASC COLLATE latin1_swedish_ci, (2|4) ASC", - "Query": "select a, `user`.textcol1, b, weight_string(a), weight_string(b) from `user` order by a asc, `user`.textcol1 asc, b asc", + "Query": "select a, `user`.textcol1, b, weight_string(a), weight_string(b) from `user` order by `user`.a asc, `user`.textcol1 asc, `user`.b asc", "ResultColumns": 3, "Table": "`user`" }, @@ -344,7 +344,7 @@ }, "FieldQuery": "select a, textcol1, b, textcol2, weight_string(a), weight_string(b), weight_string(textcol2) from `user` where 1 != 1", "OrderBy": "(0|4) ASC, 1 ASC COLLATE latin1_swedish_ci, (2|5) ASC, (3|6) ASC COLLATE ", - "Query": "select a, textcol1, b, textcol2, weight_string(a), weight_string(b), weight_string(textcol2) from `user` order by a asc, textcol1 asc, b asc, textcol2 asc", + "Query": "select a, textcol1, b, textcol2, weight_string(a), weight_string(b), weight_string(textcol2) from `user` order by `user`.a asc, `user`.textcol1 asc, `user`.b asc, `user`.textcol2 asc", "ResultColumns": 4, "Table": "`user`" }, @@ -440,7 +440,7 @@ }, "FieldQuery": "select col from `user` where 1 != 1", "OrderBy": "0 ASC", - "Query": "select col from `user` where :__sq_has_values and col in ::__sq1 order by col asc", + "Query": "select col from `user` where :__sq_has_values and col in ::__sq1 order by `user`.col asc", "Table": "`user`" } ] @@ -1079,7 +1079,7 @@ "Sharded": true }, "FieldQuery": "select col from `user` as route1 where 1 != 1", - "Query": "select col from `user` as route1 where id = 1 order by col asc", + "Query": "select col from `user` as route1 where id = 1 order by route1.col asc", "Table": "`user`", "Values": [ "1" @@ -1365,7 +1365,7 @@ }, "FieldQuery": "select id as foo, weight_string(id) from music where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select id as foo, weight_string(id) from music order by id asc", + "Query": "select id as foo, weight_string(id) from music order by music.id asc", "ResultColumns": 1, "Table": "music" }, @@ -1389,7 +1389,7 @@ }, "FieldQuery": "select id as foo, id2 as id, weight_string(id2) from music where 1 != 1", "OrderBy": "(1|2) ASC", - "Query": "select id as foo, id2 as id, weight_string(id2) from music order by id2 asc", + "Query": "select id as foo, id2 as id, weight_string(id2) from music order by music.id2 asc", "ResultColumns": 2, "Table": "music" }, @@ -1419,7 +1419,7 @@ }, "FieldQuery": "select `name`, weight_string(`name`) from `user` where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select `name`, weight_string(`name`) from `user` order by `name` asc", + "Query": "select `name`, weight_string(`name`) from `user` order by `user`.`name` asc", "Table": "`user`" }, { @@ -1606,7 +1606,7 @@ }, "FieldQuery": "select `name`, weight_string(`name`) from `user` where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select `name`, weight_string(`name`) from `user` order by `name` asc", + "Query": "select `name`, weight_string(`name`) from `user` order by `user`.`name` asc", "Table": "`user`" }, { @@ -1645,7 +1645,7 @@ }, "FieldQuery": "select id, id, weight_string(id) from `user` where 1 != 1", "OrderBy": "(0|2) ASC", - "Query": "select id, id, weight_string(id) from `user` order by id asc", + "Query": "select id, id, weight_string(id) from `user` order by `user`.id asc", "ResultColumns": 2, "Table": "`user`" }, @@ -2095,7 +2095,7 @@ }, "FieldQuery": "select col from `user` where 1 != 1 group by col", "OrderBy": "0 ASC", - "Query": "select col from `user` where id between :vtg1 and :vtg2 group by col order by col asc", + "Query": "select col from `user` where id between :vtg1 and :vtg2 group by col order by `user`.col asc", "Table": "`user`" } ] @@ -2126,7 +2126,7 @@ }, "FieldQuery": "select foo, col, weight_string(foo) from `user` where 1 != 1 group by col, foo, weight_string(foo)", "OrderBy": "1 ASC, (0|2) ASC", - "Query": "select foo, col, weight_string(foo) from `user` where id between :vtg1 and :vtg2 group by col, foo, weight_string(foo) order by col asc, foo asc", + "Query": "select foo, col, weight_string(foo) from `user` where id between :vtg1 and :vtg2 group by col, foo, weight_string(foo) order by `user`.col asc, foo asc", "Table": "`user`" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/select_cases.json b/go/vt/vtgate/planbuilder/testdata/select_cases.json index 0ef10b5247f..4a5f85b249d 100644 --- a/go/vt/vtgate/planbuilder/testdata/select_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/select_cases.json @@ -1078,7 +1078,7 @@ }, "FieldQuery": "select user_id, weight_string(user_id) from music where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select user_id, weight_string(user_id) from music order by user_id asc limit :__upper_limit", + "Query": "select user_id, weight_string(user_id) from music order by music.user_id asc limit :__upper_limit", "ResultColumns": 1, "Table": "music" } @@ -1884,7 +1884,7 @@ }, "FieldQuery": "select user_id, count(id), weight_string(user_id) from music where 1 != 1 group by user_id", "OrderBy": "(0|2) ASC", - "Query": "select user_id, count(id), weight_string(user_id) from music group by user_id having count(user_id) = 1 order by user_id asc limit :__upper_limit", + "Query": "select user_id, count(id), weight_string(user_id) from music group by user_id having count(user_id) = 1 order by music.user_id asc limit :__upper_limit", "ResultColumns": 2, "Table": "music" } @@ -2414,7 +2414,7 @@ }, "FieldQuery": "select col, `user`.id from `user` where 1 != 1", "OrderBy": "0 ASC", - "Query": "select col, `user`.id from `user` order by col asc", + "Query": "select col, `user`.id from `user` order by `user`.col asc", "Table": "`user`" }, { @@ -2840,7 +2840,7 @@ }, "FieldQuery": "select id, weight_string(id) from `user` where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select id, weight_string(id) from `user` order by id asc limit :__upper_limit", + "Query": "select id, weight_string(id) from `user` order by `user`.id asc limit :__upper_limit", "Table": "`user`" } ] @@ -2853,8 +2853,8 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select :__sq1 as `(select id from ``user`` order by id asc limit 1)` from user_extra where 1 != 1", - "Query": "select :__sq1 as `(select id from ``user`` order by id asc limit 1)` from user_extra", + "FieldQuery": "select :__sq1 as `(select id from ``user`` order by ``user``.id asc limit 1)` from user_extra where 1 != 1", + "Query": "select :__sq1 as `(select id from ``user`` order by ``user``.id asc limit 1)` from user_extra", "Table": "user_extra" } ] @@ -3330,7 +3330,7 @@ }, "FieldQuery": "select id, `name`, weight_string(id) from `user` where 1 != 1", "OrderBy": "(0|2) ASC", - "Query": "select id, `name`, weight_string(id) from `user` where `name` = 'aa' order by id asc limit :__upper_limit", + "Query": "select id, `name`, weight_string(id) from `user` where `name` = 'aa' order by `user`.id asc limit :__upper_limit", "ResultColumns": 2, "Table": "`user`" } diff --git a/go/vt/vtgate/planbuilder/testdata/tpcc_cases.json b/go/vt/vtgate/planbuilder/testdata/tpcc_cases.json index ee38e7d0538..f6072bcd9a5 100644 --- a/go/vt/vtgate/planbuilder/testdata/tpcc_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/tpcc_cases.json @@ -556,7 +556,7 @@ "Sharded": true }, "FieldQuery": "select c_balance, c_first, c_middle, c_id from customer1 where 1 != 1", - "Query": "select c_balance, c_first, c_middle, c_id from customer1 where c_w_id = 840 and c_d_id = 1 and c_last = 'test' order by c_first asc", + "Query": "select c_balance, c_first, c_middle, c_id from customer1 where c_w_id = 840 and c_d_id = 1 and c_last = 'test' order by customer1.c_first asc", "Table": "customer1", "Values": [ "840" @@ -608,7 +608,7 @@ "Sharded": true }, "FieldQuery": "select o_id, o_carrier_id, o_entry_d from orders1 where 1 != 1", - "Query": "select o_id, o_carrier_id, o_entry_d from orders1 where o_w_id = 9894 and o_d_id = 3 and o_c_id = 159 order by o_id desc", + "Query": "select o_id, o_carrier_id, o_entry_d from orders1 where o_w_id = 9894 and o_d_id = 3 and o_c_id = 159 order by orders1.o_id desc", "Table": "orders1", "Values": [ "9894" @@ -660,7 +660,7 @@ "Sharded": true }, "FieldQuery": "select no_o_id from new_orders1 where 1 != 1", - "Query": "select no_o_id from new_orders1 where no_d_id = 689 and no_w_id = 15 order by no_o_id asc limit 1 for update", + "Query": "select no_o_id from new_orders1 where no_d_id = 689 and no_w_id = 15 order by new_orders1.no_o_id asc limit 1 for update", "Table": "new_orders1", "Values": [ "15" diff --git a/go/vt/vtgate/planbuilder/testdata/tpch_cases.json b/go/vt/vtgate/planbuilder/testdata/tpch_cases.json index 2d225808992..609285c4bfe 100644 --- a/go/vt/vtgate/planbuilder/testdata/tpch_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/tpch_cases.json @@ -35,7 +35,7 @@ }, "FieldQuery": "select l_returnflag, l_linestatus, sum(l_quantity) as sum_qty, sum(l_extendedprice) as sum_base_price, sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, sum(l_quantity) as avg_qty, sum(l_extendedprice) as avg_price, sum(l_discount) as avg_disc, count(*) as count_order, count(l_quantity), count(l_extendedprice), count(l_discount), weight_string(l_returnflag), weight_string(l_linestatus) from lineitem where 1 != 1 group by l_returnflag, l_linestatus, weight_string(l_returnflag), weight_string(l_linestatus)", "OrderBy": "(0|13) ASC, (1|14) ASC", - "Query": "select l_returnflag, l_linestatus, sum(l_quantity) as sum_qty, sum(l_extendedprice) as sum_base_price, sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, sum(l_quantity) as avg_qty, sum(l_extendedprice) as avg_price, sum(l_discount) as avg_disc, count(*) as count_order, count(l_quantity), count(l_extendedprice), count(l_discount), weight_string(l_returnflag), weight_string(l_linestatus) from lineitem where l_shipdate <= '1998-12-01' - interval '108' day group by l_returnflag, l_linestatus, weight_string(l_returnflag), weight_string(l_linestatus) order by l_returnflag asc, l_linestatus asc", + "Query": "select l_returnflag, l_linestatus, sum(l_quantity) as sum_qty, sum(l_extendedprice) as sum_base_price, sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, sum(l_quantity) as avg_qty, sum(l_extendedprice) as avg_price, sum(l_discount) as avg_disc, count(*) as count_order, count(l_quantity), count(l_extendedprice), count(l_discount), weight_string(l_returnflag), weight_string(l_linestatus) from lineitem where l_shipdate <= '1998-12-01' - interval '108' day group by l_returnflag, l_linestatus, weight_string(l_returnflag), weight_string(l_linestatus) order by lineitem.l_returnflag asc, lineitem.l_linestatus asc", "Table": "lineitem" } ] @@ -213,7 +213,7 @@ }, "FieldQuery": "select o_orderpriority, count(*) as order_count, o_orderkey, weight_string(o_orderpriority) from orders where 1 != 1 group by o_orderpriority, o_orderkey, weight_string(o_orderpriority)", "OrderBy": "(0|3) ASC", - "Query": "select o_orderpriority, count(*) as order_count, o_orderkey, weight_string(o_orderpriority) from orders where o_orderdate >= date('1993-07-01') and o_orderdate < date('1993-07-01') + interval '3' month group by o_orderpriority, o_orderkey, weight_string(o_orderpriority) order by o_orderpriority asc", + "Query": "select o_orderpriority, count(*) as order_count, o_orderkey, weight_string(o_orderpriority) from orders where o_orderdate >= date('1993-07-01') and o_orderdate < date('1993-07-01') + interval '3' month group by o_orderpriority, o_orderkey, weight_string(o_orderpriority) order by orders.o_orderpriority asc", "Table": "orders" }, { @@ -631,9 +631,9 @@ "Name": "main", "Sharded": true }, - "FieldQuery": "select sum(volume) as revenue, l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year), supp_nation, weight_string(supp_nation), cust_nation, weight_string(cust_nation) from (select extract(year from l_shipdate) as l_year, l_extendedprice * (1 - l_discount) as volume, l_suppkey as l_suppkey, l_orderkey as l_orderkey from lineitem where 1 != 1) as shipping where 1 != 1 group by l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year)", + "FieldQuery": "select sum(volume) as revenue, l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year), shipping.supp_nation, weight_string(shipping.supp_nation), shipping.cust_nation, weight_string(shipping.cust_nation) from (select extract(year from l_shipdate) as l_year, l_extendedprice * (1 - l_discount) as volume, l_suppkey as l_suppkey, l_orderkey as l_orderkey from lineitem where 1 != 1) as shipping where 1 != 1 group by l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year)", "OrderBy": "(5|6) ASC, (7|8) ASC, (1|4) ASC", - "Query": "select sum(volume) as revenue, l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year), supp_nation, weight_string(supp_nation), cust_nation, weight_string(cust_nation) from (select extract(year from l_shipdate) as l_year, l_extendedprice * (1 - l_discount) as volume, l_suppkey as l_suppkey, l_orderkey as l_orderkey from lineitem where l_shipdate between date('1995-01-01') and date('1996-12-31')) as shipping group by l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year) order by supp_nation asc, cust_nation asc, l_year asc", + "Query": "select sum(volume) as revenue, l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year), shipping.supp_nation, weight_string(shipping.supp_nation), shipping.cust_nation, weight_string(shipping.cust_nation) from (select extract(year from l_shipdate) as l_year, l_extendedprice * (1 - l_discount) as volume, l_suppkey as l_suppkey, l_orderkey as l_orderkey from lineitem where l_shipdate between date('1995-01-01') and date('1996-12-31')) as shipping group by l_year, shipping.l_suppkey, shipping.l_orderkey, weight_string(l_year) order by shipping.supp_nation asc, shipping.cust_nation asc, shipping.l_year asc", "Table": "lineitem" }, { @@ -1518,7 +1518,7 @@ }, "FieldQuery": "select s_suppkey, s_name, s_address, s_phone, total_revenue, weight_string(s_suppkey) from supplier, revenue0 where 1 != 1", "OrderBy": "(0|5) ASC", - "Query": "select s_suppkey, s_name, s_address, s_phone, total_revenue, weight_string(s_suppkey) from supplier, revenue0 where s_suppkey = supplier_no and total_revenue = :__sq1 order by s_suppkey asc", + "Query": "select s_suppkey, s_name, s_address, s_phone, total_revenue, weight_string(s_suppkey) from supplier, revenue0 where s_suppkey = supplier_no and total_revenue = :__sq1 order by supplier.s_suppkey asc", "ResultColumns": 5, "Table": "revenue0, supplier" } diff --git a/go/vt/vtgate/planbuilder/testdata/union_cases.json b/go/vt/vtgate/planbuilder/testdata/union_cases.json index 9ac8db73be7..7c225862235 100644 --- a/go/vt/vtgate/planbuilder/testdata/union_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/union_cases.json @@ -128,7 +128,7 @@ }, "FieldQuery": "select id, weight_string(id) from `user` where 1 != 1", "OrderBy": "(0|1) DESC", - "Query": "select id, weight_string(id) from `user` order by id desc limit :__upper_limit", + "Query": "select id, weight_string(id) from `user` order by `user`.id desc limit :__upper_limit", "Table": "`user`" } ] @@ -146,7 +146,7 @@ }, "FieldQuery": "select id, weight_string(id) from music where 1 != 1", "OrderBy": "(0|1) DESC", - "Query": "select id, weight_string(id) from music order by id desc limit :__upper_limit", + "Query": "select id, weight_string(id) from music order by music.id desc limit :__upper_limit", "Table": "music" } ] @@ -258,7 +258,7 @@ }, "FieldQuery": "select id, weight_string(id) from `user` where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select id, weight_string(id) from `user` order by id asc limit :__upper_limit", + "Query": "select id, weight_string(id) from `user` order by `user`.id asc limit :__upper_limit", "Table": "`user`" } ] @@ -276,7 +276,7 @@ }, "FieldQuery": "select id, weight_string(id) from music where 1 != 1", "OrderBy": "(0|1) DESC", - "Query": "select id, weight_string(id) from music order by id desc limit :__upper_limit", + "Query": "select id, weight_string(id) from music order by music.id desc limit :__upper_limit", "Table": "music" } ] @@ -962,7 +962,7 @@ }, "FieldQuery": "select id, weight_string(id) from `user` where 1 != 1", "OrderBy": "(0|1) ASC", - "Query": "select id, weight_string(id) from `user` order by id asc limit :__upper_limit", + "Query": "select id, weight_string(id) from `user` order by `user`.id asc limit :__upper_limit", "Table": "`user`" } ] @@ -980,7 +980,7 @@ }, "FieldQuery": "select id, weight_string(id) from `user` where 1 != 1", "OrderBy": "(0|1) DESC", - "Query": "select id, weight_string(id) from `user` order by id desc limit :__upper_limit", + "Query": "select id, weight_string(id) from `user` order by `user`.id desc limit :__upper_limit", "Table": "`user`" } ] diff --git a/go/vt/vtgate/semantics/analyzer.go b/go/vt/vtgate/semantics/analyzer.go index 0fe9f4a934e..f289438a1c9 100644 --- a/go/vt/vtgate/semantics/analyzer.go +++ b/go/vt/vtgate/semantics/analyzer.go @@ -37,6 +37,7 @@ type analyzer struct { sig QuerySignature si SchemaInformation currentDb string + recheck bool err error inProjection int @@ -74,7 +75,8 @@ func (a *analyzer) lateInit() { expandedColumns: map[sqlparser.TableName][]*sqlparser.ColName{}, env: a.si.Environment(), aliasMapCache: map[*sqlparser.Select]map[string]exprContainer{}, - reAnalyze: a.lateAnalyze, + reAnalyze: a.reAnalyze, + tables: a.tables, } } @@ -249,9 +251,12 @@ func (a *analyzer) analyzeUp(cursor *sqlparser.Cursor) bool { return false } - if err := a.rewriter.up(cursor); err != nil { - a.setError(err) - return true + if !a.recheck { + // no need to run the rewriter on rechecking + if err := a.rewriter.up(cursor); err != nil { + a.setError(err) + return true + } } if err := a.scoper.up(cursor); err != nil { @@ -359,6 +364,14 @@ func (a *analyzer) lateAnalyze(statement sqlparser.SQLNode) error { return a.err } +func (a *analyzer) reAnalyze(statement sqlparser.SQLNode) error { + a.recheck = true + defer func() { + a.recheck = false + }() + return a.lateAnalyze(statement) +} + // canShortCut checks if we are dealing with a single unsharded keyspace and no tables that have managed foreign keys // if so, we can stop the analyzer early func (a *analyzer) canShortCut(statement sqlparser.Statement) (canShortCut bool) { @@ -639,6 +652,10 @@ type ShardedError struct { Inner error } +func (p ShardedError) Unwrap() error { + return p.Inner +} + func (p ShardedError) Error() string { return p.Inner.Error() } diff --git a/go/vt/vtgate/semantics/analyzer_test.go b/go/vt/vtgate/semantics/analyzer_test.go index a7c173ccc96..27a34a427f1 100644 --- a/go/vt/vtgate/semantics/analyzer_test.go +++ b/go/vt/vtgate/semantics/analyzer_test.go @@ -722,7 +722,10 @@ func TestGroupByBinding(t *testing.T) { TS1, }, { "select a.id from t as a, t1 group by id", - TS0, + // since we have authoritative info on t1, we know that it does have an `id` column, + // and we are missing column info for `t`, we just assume this is coming from t1. + // we really need schema tracking here + TS1, }, { "select a.id from t, t1 as a group by id", TS1, @@ -740,44 +743,47 @@ func TestGroupByBinding(t *testing.T) { func TestHavingBinding(t *testing.T) { tcases := []struct { - sql string - deps TableSet + sql, err string + deps TableSet }{{ - "select col from tabl having col = 1", - TS0, + sql: "select col from tabl having col = 1", + deps: TS0, }, { - "select col from tabl having tabl.col = 1", - TS0, + sql: "select col from tabl having tabl.col = 1", + deps: TS0, }, { - "select col from tabl having d.tabl.col = 1", - TS0, + sql: "select col from tabl having d.tabl.col = 1", + deps: TS0, }, { - "select tabl.col as x from tabl having x = 1", - TS0, + sql: "select tabl.col as x from tabl having col = 1", + deps: TS0, }, { - "select tabl.col as x from tabl having col", - TS0, + sql: "select tabl.col as x from tabl having x = 1", + deps: TS0, }, { - "select col from tabl having 1 = 1", - NoTables, + sql: "select tabl.col as x from tabl having col", + deps: TS0, }, { - "select col as c from tabl having c = 1", - TS0, + sql: "select col from tabl having 1 = 1", + deps: NoTables, }, { - "select 1 as c from tabl having c = 1", - NoTables, + sql: "select col as c from tabl having c = 1", + deps: TS0, }, { - "select t1.id from t1, t2 having id = 1", - TS0, + sql: "select 1 as c from tabl having c = 1", + deps: NoTables, }, { - "select t.id from t, t1 having id = 1", - TS0, + sql: "select t1.id from t1, t2 having id = 1", + deps: TS0, }, { - "select t.id, count(*) as a from t, t1 group by t.id having a = 1", - MergeTableSets(TS0, TS1), + sql: "select t.id from t, t1 having id = 1", + deps: TS0, }, { - "select t.id, sum(t2.name) as a from t, t2 group by t.id having a = 1", - TS1, + sql: "select t.id, count(*) as a from t, t1 group by t.id having a = 1", + deps: MergeTableSets(TS0, TS1), + }, { + sql: "select t.id, sum(t2.name) as a from t, t2 group by t.id having a = 1", + deps: TS1, }, { sql: "select u2.a, u1.a from u1, u2 having u2.a = 2", deps: TS1, diff --git a/go/vt/vtgate/semantics/binder.go b/go/vt/vtgate/semantics/binder.go index b010649e067..9d91f6523cf 100644 --- a/go/vt/vtgate/semantics/binder.go +++ b/go/vt/vtgate/semantics/binder.go @@ -228,28 +228,32 @@ func (b *binder) setSubQueryDependencies(subq *sqlparser.Subquery, currScope *sc } func (b *binder) resolveColumn(colName *sqlparser.ColName, current *scope, allowMulti, singleTableFallBack bool) (dependency, error) { + if !current.stmtScope && current.inGroupBy { + return b.resolveColInGroupBy(colName, current, allowMulti, singleTableFallBack) + } + if !current.stmtScope && current.inHaving && !current.inHavingAggr { + return b.resolveColumnInHaving(colName, current, allowMulti) + } + var thisDeps dependencies first := true var tableName *sqlparser.TableName + for current != nil { var err error thisDeps, err = b.resolveColumnInScope(current, colName, allowMulti) if err != nil { - err = makeAmbiguousError(colName, err) - if thisDeps == nil { - return dependency{}, err - } + return dependency{}, makeAmbiguousError(colName, err) } if !thisDeps.empty() { - deps, thisErr := thisDeps.get() - if thisErr != nil { - err = makeAmbiguousError(colName, thisErr) - } - return deps, err - } else if err != nil { - return dependency{}, err + deps, err := thisDeps.get() + return deps, makeAmbiguousError(colName, err) } - if current.parent == nil && len(current.tables) == 1 && first && colName.Qualifier.IsEmpty() && singleTableFallBack { + if current.parent == nil && + len(current.tables) == 1 && + first && + colName.Qualifier.IsEmpty() && + singleTableFallBack { // if this is the top scope, and we still haven't been able to find a match, we know we are about to fail // we can check this last scope and see if there is a single table. if there is just one table in the scope // we assume that the column is meant to come from this table. @@ -267,6 +271,146 @@ func (b *binder) resolveColumn(colName *sqlparser.ColName, current *scope, allow return dependency{}, ShardedError{ColumnNotFoundError{Column: colName, Table: tableName}} } +func isColumnNotFound(err error) bool { + switch err := err.(type) { + case ColumnNotFoundError: + return true + case ShardedError: + return isColumnNotFound(err.Inner) + default: + return false + } +} + +func (b *binder) resolveColumnInHaving(colName *sqlparser.ColName, current *scope, allowMulti bool) (dependency, error) { + if current.inHavingAggr { + // when inside an aggregation, we'll search the FROM clause before the SELECT expressions + deps, err := b.resolveColumn(colName, current.parent, allowMulti, true) + if deps.direct.NotEmpty() || (err != nil && !isColumnNotFound(err)) { + return deps, err + } + } + + // Here we are searching among the SELECT expressions for a match + thisDeps, err := b.resolveColumnInScope(current, colName, allowMulti) + if err != nil { + return dependency{}, makeAmbiguousError(colName, err) + } + + if !thisDeps.empty() { + // we found something! let's return it + deps, err := thisDeps.get() + if err != nil { + err = makeAmbiguousError(colName, err) + } + return deps, err + } + + notFoundErr := &ColumnNotFoundClauseError{Column: colName.Name.String(), Clause: "having clause"} + if current.inHavingAggr { + // if we are inside an aggregation, we've already looked everywhere. now it's time to give up + return dependency{}, notFoundErr + } + + // Now we'll search the FROM clause, but with a twist. If we find it in the FROM clause, the column must also + // exist as a standalone expression in the SELECT list + deps, err := b.resolveColumn(colName, current.parent, allowMulti, true) + if deps.direct.IsEmpty() { + return dependency{}, notFoundErr + } + + sel := current.stmt.(*sqlparser.Select) // we can be sure of this, since HAVING doesn't exist on UNION + if selDeps := b.searchInSelectExpressions(colName, deps, sel); selDeps.direct.NotEmpty() { + return selDeps, nil + } + + if !current.inHavingAggr && len(sel.GroupBy) == 0 { + // if we are not inside an aggregation, and there is no GROUP BY, we consider the FROM clause before failing + if deps.direct.NotEmpty() || (err != nil && !isColumnNotFound(err)) { + return deps, err + } + } + + return dependency{}, notFoundErr +} + +// searchInSelectExpressions searches for the ColName among the SELECT and GROUP BY expressions +// It used dependency information to match the columns +func (b *binder) searchInSelectExpressions(colName *sqlparser.ColName, deps dependency, stmt *sqlparser.Select) dependency { + for _, selectExpr := range stmt.SelectExprs { + ae, ok := selectExpr.(*sqlparser.AliasedExpr) + if !ok { + continue + } + selectCol, ok := ae.Expr.(*sqlparser.ColName) + if !ok || !selectCol.Name.Equal(colName.Name) { + continue + } + + _, direct, _ := b.org.depsForExpr(selectCol) + if deps.direct == direct { + // we have found the ColName in the SELECT expressions, so it's safe to use here + direct, recursive, typ := b.org.depsForExpr(ae.Expr) + return dependency{certain: true, direct: direct, recursive: recursive, typ: typ} + } + } + + for _, gb := range stmt.GroupBy { + selectCol, ok := gb.(*sqlparser.ColName) + if !ok || !selectCol.Name.Equal(colName.Name) { + continue + } + + _, direct, _ := b.org.depsForExpr(selectCol) + if deps.direct == direct { + // we have found the ColName in the GROUP BY expressions, so it's safe to use here + direct, recursive, typ := b.org.depsForExpr(gb) + return dependency{certain: true, direct: direct, recursive: recursive, typ: typ} + } + } + return dependency{} +} + +// resolveColInGroupBy handles the special rules we have when binding on the GROUP BY column +func (b *binder) resolveColInGroupBy( + colName *sqlparser.ColName, + current *scope, + allowMulti bool, + singleTableFallBack bool, +) (dependency, error) { + if current.parent == nil { + return dependency{}, vterrors.VT13001("did not expect this to be the last scope") + } + // if we are in GROUP BY, we have to search the FROM clause before we search the SELECT expressions + deps, firstErr := b.resolveColumn(colName, current.parent, allowMulti, false) + if firstErr == nil { + return deps, nil + } + + // either we didn't find the column on a table, or it was ambiguous. + // in either case, next step is to search the SELECT expressions + if colName.Qualifier.NonEmpty() { + // if the col name has a qualifier, none of the SELECT expressions are going to match + return dependency{}, nil + } + vtbl, ok := current.tables[0].(*vTableInfo) + if !ok { + return dependency{}, vterrors.VT13001("expected the table info to be a *vTableInfo") + } + + dependencies, err := vtbl.dependenciesInGroupBy(colName.Name.String(), b.org) + if err != nil { + return dependency{}, err + } + if dependencies.empty() { + if isColumnNotFound(firstErr) { + return dependency{}, &ColumnNotFoundClauseError{Column: colName.Name.String(), Clause: "group statement"} + } + return deps, firstErr + } + return dependencies.get() +} + func (b *binder) resolveColumnInScope(current *scope, expr *sqlparser.ColName, allowMulti bool) (dependencies, error) { var deps dependencies = ¬hing{} for _, table := range current.tables { diff --git a/go/vt/vtgate/semantics/dependencies.go b/go/vt/vtgate/semantics/dependencies.go index e68c5100ef5..714fa97c2c4 100644 --- a/go/vt/vtgate/semantics/dependencies.go +++ b/go/vt/vtgate/semantics/dependencies.go @@ -32,6 +32,7 @@ type ( merge(other dependencies, allowMulti bool) dependencies } dependency struct { + certain bool direct TableSet recursive TableSet typ evalengine.Type @@ -52,6 +53,7 @@ var ambigousErr = vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "ambiguous") func createCertain(direct TableSet, recursive TableSet, qt evalengine.Type) *certain { c := &certain{ dependency: dependency{ + certain: true, direct: direct, recursive: recursive, }, @@ -65,6 +67,7 @@ func createCertain(direct TableSet, recursive TableSet, qt evalengine.Type) *cer func createUncertain(direct TableSet, recursive TableSet) *uncertain { return &uncertain{ dependency: dependency{ + certain: false, direct: direct, recursive: recursive, }, @@ -131,7 +134,7 @@ func (n *nothing) empty() bool { } func (n *nothing) get() (dependency, error) { - return dependency{}, nil + return dependency{certain: true}, nil } func (n *nothing) merge(d dependencies, _ bool) dependencies { diff --git a/go/vt/vtgate/semantics/early_rewriter.go b/go/vt/vtgate/semantics/early_rewriter.go index 646b5b71e41..db3c8cff396 100644 --- a/go/vt/vtgate/semantics/early_rewriter.go +++ b/go/vt/vtgate/semantics/early_rewriter.go @@ -35,6 +35,7 @@ type earlyRewriter struct { expandedColumns map[sqlparser.TableName][]*sqlparser.ColName env *vtenv.Environment aliasMapCache map[*sqlparser.Select]map[string]exprContainer + tables *tableCollector // reAnalyze is used when we are running in the late stage, after the other parts of semantic analysis // have happened, and we are introducing or changing the AST. We invoke it so all parts of the query have been @@ -44,8 +45,6 @@ type earlyRewriter struct { func (r *earlyRewriter) down(cursor *sqlparser.Cursor) error { switch node := cursor.Node().(type) { - case *sqlparser.Where: - return r.handleWhereClause(node, cursor.Parent()) case sqlparser.SelectExprs: return r.handleSelectExprs(cursor, node) case *sqlparser.JoinTableExpr: @@ -56,13 +55,6 @@ func (r *earlyRewriter) down(cursor *sqlparser.Cursor) error { rewriteAndExpr(r.env, cursor, node) case *sqlparser.NotExpr: rewriteNotExpr(cursor, node) - case sqlparser.GroupBy: - r.clause = "group clause" - iter := &exprIterator{ - node: node, - idx: -1, - } - return r.handleGroupBy(cursor.Parent(), iter) case *sqlparser.ComparisonExpr: return handleComparisonExpr(cursor, node) case *sqlparser.With: @@ -83,6 +75,13 @@ func (r *earlyRewriter) up(cursor *sqlparser.Cursor) error { // this rewriting is done in the `up` phase, because we need the vindex hints to have been // processed while collecting the tables. return removeVindexHints(node) + case sqlparser.GroupBy: + r.clause = "group clause" + iter := &exprIterator{ + node: node, + idx: -1, + } + return r.handleGroupBy(cursor.Parent(), iter) case sqlparser.OrderBy: r.clause = "order clause" iter := &orderByIterator{ @@ -91,6 +90,11 @@ func (r *earlyRewriter) up(cursor *sqlparser.Cursor) error { r: r, } return r.handleOrderBy(cursor.Parent(), iter) + case *sqlparser.Where: + if node.Type == sqlparser.HavingClause { + return r.handleHavingClause(node, cursor.Parent()) + } + } return nil } @@ -196,22 +200,18 @@ func removeVindexHints(node *sqlparser.AliasedTableExpr) error { return nil } -// handleWhereClause processes WHERE clauses, specifically the HAVING clause. -func (r *earlyRewriter) handleWhereClause(node *sqlparser.Where, parent sqlparser.SQLNode) error { +// handleHavingClause processes the HAVING clause +func (r *earlyRewriter) handleHavingClause(node *sqlparser.Where, parent sqlparser.SQLNode) error { sel, ok := parent.(*sqlparser.Select) if !ok { return nil } - if node.Type != sqlparser.HavingClause { - return nil - } - expr, err := r.rewriteAliasesInHavingAndGroupBy(node.Expr, sel) + expr, err := r.rewriteAliasesInHaving(node.Expr, sel) if err != nil { return err } - node.Expr = expr - return nil + return r.reAnalyze(expr) } // handleSelectExprs expands * in SELECT expressions. @@ -290,7 +290,7 @@ func (r *earlyRewriter) replaceLiteralsInOrderBy(e sqlparser.Expr, iter iterator return false, nil } - newExpr, recheck, err := r.rewriteOrderByExpr(lit) + newExpr, recheck, err := r.rewriteOrderByLiteral(lit) if err != nil { return false, err } @@ -328,15 +328,15 @@ func (r *earlyRewriter) replaceLiteralsInOrderBy(e sqlparser.Expr, iter iterator return true, nil } -func (r *earlyRewriter) replaceLiteralsInGroupBy(e sqlparser.Expr, iter iterator) (bool, error) { +func (r *earlyRewriter) replaceLiteralsInGroupBy(e sqlparser.Expr) (sqlparser.Expr, error) { lit := getIntLiteral(e) if lit == nil { - return false, nil + return nil, nil } newExpr, err := r.rewriteGroupByExpr(lit) if err != nil { - return false, err + return nil, err } if getIntLiteral(newExpr) == nil { @@ -359,8 +359,7 @@ func (r *earlyRewriter) replaceLiteralsInGroupBy(e sqlparser.Expr, iter iterator newExpr = sqlparser.NewStrLiteral("") } - err = iter.replace(newExpr) - return true, err + return newExpr, nil } func getIntLiteral(e sqlparser.Expr) *sqlparser.Literal { @@ -426,19 +425,23 @@ func (r *earlyRewriter) handleGroupBy(parent sqlparser.SQLNode, iter iterator) e sel := sqlparser.GetFirstSelect(stmt) for e := iter.next(); e != nil; e = iter.next() { - lit, err := r.replaceLiteralsInGroupBy(e, iter) + expr, err := r.replaceLiteralsInGroupBy(e) if err != nil { return err } - if lit { - continue + if expr == nil { + expr, err = r.rewriteAliasesInGroupBy(e, sel) + if err != nil { + return err + } + } - expr, err := r.rewriteAliasesInHavingAndGroupBy(e, sel) + err = iter.replace(expr) if err != nil { return err } - err = iter.replace(expr) - if err != nil { + + if err = r.reAnalyze(expr); err != nil { return err } } @@ -452,35 +455,14 @@ func (r *earlyRewriter) handleGroupBy(parent sqlparser.SQLNode, iter iterator) e // in SELECT points to that expression, not any table column. // - However, if the aliased expression is an aggregation and the column identifier in // the HAVING/ORDER BY clause is inside an aggregation function, the rule does not apply. -func (r *earlyRewriter) rewriteAliasesInHavingAndGroupBy(node sqlparser.Expr, sel *sqlparser.Select) (expr sqlparser.Expr, err error) { +func (r *earlyRewriter) rewriteAliasesInGroupBy(node sqlparser.Expr, sel *sqlparser.Select) (expr sqlparser.Expr, err error) { type ExprContainer struct { expr sqlparser.Expr ambiguous bool } - aliases := map[string]ExprContainer{} - for _, e := range sel.SelectExprs { - ae, ok := e.(*sqlparser.AliasedExpr) - if !ok { - continue - } - - var alias string - - item := ExprContainer{expr: ae.Expr} - if ae.As.NotEmpty() { - alias = ae.As.Lowered() - } else if col, ok := ae.Expr.(*sqlparser.ColName); ok { - alias = col.Name.Lowered() - } - - if old, alreadyExists := aliases[alias]; alreadyExists && !sqlparser.Equals.Expr(old.expr, item.expr) { - item.ambiguous = true - } - - aliases[alias] = item - } - + currentScope := r.scoper.currentScope() + aliases := r.getAliasMap(sel) insideAggr := false downF := func(node, _ sqlparser.SQLNode) bool { switch node.(type) { @@ -498,7 +480,7 @@ func (r *earlyRewriter) rewriteAliasesInHavingAndGroupBy(node sqlparser.Expr, se case sqlparser.AggrFunc: insideAggr = false case *sqlparser.ColName: - if !col.Qualifier.IsEmpty() { + if col.Qualifier.NonEmpty() { // we are only interested in columns not qualified by table names break } @@ -508,43 +490,111 @@ func (r *earlyRewriter) rewriteAliasesInHavingAndGroupBy(node sqlparser.Expr, se break } + isColumnOnTable, sure := r.isColumnOnTable(col, currentScope) + if found && isColumnOnTable { + r.warning = fmt.Sprintf("Column '%s' in group statement is ambiguous", sqlparser.String(col)) + } + + if isColumnOnTable && sure { + break + } + + if !sure { + r.warning = "Missing table info, so not binding to anything on the FROM clause" + } + if item.ambiguous { err = &AmbiguousColumnError{Column: sqlparser.String(col)} + } else if insideAggr && sqlparser.ContainsAggregation(item.expr) { + err = &InvalidUseOfGroupFunction{} + } + if err != nil { cursor.StopTreeWalk() return } - if insideAggr && sqlparser.ContainsAggregation(item.expr) { - // I'm not sure about this, but my experiments point to this being the behaviour mysql has - // mysql> select min(name) as name from user order by min(name); - // 1 row in set (0.00 sec) - // - // mysql> select id % 2, min(name) as name from user group by id % 2 order by min(name); - // 2 rows in set (0.00 sec) - // - // mysql> select id % 2, 'foobar' as name from user group by id % 2 order by min(name); - // 2 rows in set (0.00 sec) - // - // mysql> select id % 2 from user group by id % 2 order by min(min(name)); - // ERROR 1111 (HY000): Invalid use of group function - // - // mysql> select id % 2, min(name) as k from user group by id % 2 order by min(k); - // ERROR 1111 (HY000): Invalid use of group function - // - // mysql> select id % 2, -id as name from user group by id % 2, -id order by min(name); - // 6 rows in set (0.01 sec) - break + cursor.Replace(sqlparser.CloneExpr(item.expr)) + } + }, nil) + + expr = output.(sqlparser.Expr) + return +} + +func (r *earlyRewriter) rewriteAliasesInHaving(node sqlparser.Expr, sel *sqlparser.Select) (expr sqlparser.Expr, err error) { + currentScope := r.scoper.currentScope() + if currentScope.isUnion { + // It is not safe to rewrite order by clauses in unions. + return node, nil + } + + aliases := r.getAliasMap(sel) + insideAggr := false + dontEnterSubquery := func(node, _ sqlparser.SQLNode) bool { + switch node.(type) { + case *sqlparser.Subquery: + return false + case sqlparser.AggrFunc: + insideAggr = true + } + + return true + } + output := sqlparser.CopyOnRewrite(node, dontEnterSubquery, func(cursor *sqlparser.CopyOnWriteCursor) { + var col *sqlparser.ColName + + switch node := cursor.Node().(type) { + case sqlparser.AggrFunc: + insideAggr = false + return + case *sqlparser.ColName: + col = node + default: + return + } + + if col.Qualifier.NonEmpty() { + // we are only interested in columns not qualified by table names + return + } + + item, found := aliases[col.Name.Lowered()] + if insideAggr { + // inside aggregations, we want to first look for columns in the FROM clause + isColumnOnTable, sure := r.isColumnOnTable(col, currentScope) + if isColumnOnTable { + if found && sure { + r.warning = fmt.Sprintf("Column '%s' in having clause is ambiguous", sqlparser.String(col)) + } + return } + } else if !found { + // if outside aggregations, we don't care about FROM columns + // if there is no matching alias, there is no rewriting needed + return + } - cursor.Replace(sqlparser.CloneExpr(item.expr)) + // If we get here, it means we have found an alias and want to use it + if item.ambiguous { + err = &AmbiguousColumnError{Column: sqlparser.String(col)} + } else if insideAggr && sqlparser.ContainsAggregation(item.expr) { + err = &InvalidUseOfGroupFunction{} } + if err != nil { + cursor.StopTreeWalk() + return + } + + newColName := sqlparser.CopyOnRewrite(item.expr, nil, r.fillInQualifiers, nil) + + cursor.Replace(newColName) }, nil) expr = output.(sqlparser.Expr) return } -// rewriteAliasesInOrderBy rewrites columns in the ORDER BY and HAVING clauses to use aliases +// rewriteAliasesInOrderBy rewrites columns in the ORDER BY to use aliases // from the SELECT expressions when applicable, following MySQL scoping rules: // - A column identifier without a table qualifier that matches an alias introduced // in SELECT points to that expression, not any table column. @@ -567,8 +617,7 @@ func (r *earlyRewriter) rewriteAliasesInOrderBy(node sqlparser.Expr, sel *sqlpar insideAggr = true } - _, isSubq := node.(*sqlparser.Subquery) - return !isSubq + return true } output := sqlparser.CopyOnRewrite(node, dontEnterSubquery, func(cursor *sqlparser.CopyOnWriteCursor) { var col *sqlparser.ColName @@ -583,46 +632,80 @@ func (r *earlyRewriter) rewriteAliasesInOrderBy(node sqlparser.Expr, sel *sqlpar return } - if !col.Qualifier.IsEmpty() { + if col.Qualifier.NonEmpty() { // we are only interested in columns not qualified by table names return } - item, found := aliases[col.Name.Lowered()] + var item exprContainer + var found bool + + item, found = aliases[col.Name.Lowered()] if !found { // if there is no matching alias, there is no rewriting needed return } + isColumnOnTable, sure := r.isColumnOnTable(col, currentScope) + if found && isColumnOnTable && sure { + r.warning = fmt.Sprintf("Column '%s' in order by statement is ambiguous", sqlparser.String(col)) + } topLevel := col == node - if !topLevel && r.isColumnOnTable(col, currentScope) { + if isColumnOnTable && sure && !topLevel { // we only want to replace columns that are not coming from the table return } + if !sure { + r.warning = "Missing table info, so not binding to anything on the FROM clause" + } + if item.ambiguous { err = &AmbiguousColumnError{Column: sqlparser.String(col)} } else if insideAggr && sqlparser.ContainsAggregation(item.expr) { - err = &InvalidUserOfGroupFunction{} + err = &InvalidUseOfGroupFunction{} } if err != nil { cursor.StopTreeWalk() return } - cursor.Replace(sqlparser.CloneExpr(item.expr)) + newColName := sqlparser.CopyOnRewrite(item.expr, nil, r.fillInQualifiers, nil) + + cursor.Replace(newColName) }, nil) expr = output.(sqlparser.Expr) return } -func (r *earlyRewriter) isColumnOnTable(col *sqlparser.ColName, currentScope *scope) bool { +// fillInQualifiers adds qualifiers to any columns we have rewritten +func (r *earlyRewriter) fillInQualifiers(cursor *sqlparser.CopyOnWriteCursor) { + col, ok := cursor.Node().(*sqlparser.ColName) + if !ok || col.Qualifier.NonEmpty() { + return + } + ts, found := r.binder.direct[col] + if !found { + panic("uh oh") + } + tbl := r.tables.Tables[ts.TableOffset()] + tblName, err := tbl.Name() + if err != nil { + panic(err) + } + cursor.Replace(sqlparser.NewColNameWithQualifier(col.Name.String(), tblName)) +} + +func (r *earlyRewriter) isColumnOnTable(col *sqlparser.ColName, currentScope *scope) (isColumn bool, isCertain bool) { if !currentScope.stmtScope && currentScope.parent != nil { currentScope = currentScope.parent } - _, err := r.binder.resolveColumn(col, currentScope, false, false) - return err == nil + deps, err := r.binder.resolveColumn(col, currentScope, false, false) + if err != nil { + return false, true + } + return true, deps.certain } func (r *earlyRewriter) getAliasMap(sel *sqlparser.Select) (aliases map[string]exprContainer) { @@ -661,7 +744,7 @@ type exprContainer struct { ambiguous bool } -func (r *earlyRewriter) rewriteOrderByExpr(node *sqlparser.Literal) (expr sqlparser.Expr, needReAnalysis bool, err error) { +func (r *earlyRewriter) rewriteOrderByLiteral(node *sqlparser.Literal) (expr sqlparser.Expr, needReAnalysis bool, err error) { scope, found := r.scoper.specialExprScopes[node] if !found { return node, false, nil diff --git a/go/vt/vtgate/semantics/early_rewriter_test.go b/go/vt/vtgate/semantics/early_rewriter_test.go index cf93a52447c..a5c16ba6b78 100644 --- a/go/vt/vtgate/semantics/early_rewriter_test.go +++ b/go/vt/vtgate/semantics/early_rewriter_test.go @@ -172,8 +172,8 @@ func TestExpandStar(t *testing.T) { sql: "select * from t1 join t5 using (b) having b = 12", expSQL: "select t1.b as b, t1.a as a, t1.c as c, t5.a as a from t1 join t5 on t1.b = t5.b having t1.b = 12", }, { - sql: "select 1 from t1 join t5 using (b) having b = 12", - expSQL: "select 1 from t1 join t5 on t1.b = t5.b having t1.b = 12", + sql: "select 1 from t1 join t5 using (b) where b = 12", + expSQL: "select 1 from t1 join t5 on t1.b = t5.b where t1.b = 12", }, { sql: "select * from (select 12) as t", expSQL: "select `12` from (select 12 from dual) as t", @@ -304,6 +304,90 @@ func TestRewriteJoinUsingColumns(t *testing.T) { } +func TestGroupByColumnName(t *testing.T) { + schemaInfo := &FakeSI{ + Tables: map[string]*vindexes.Table{ + "t1": { + Name: sqlparser.NewIdentifierCS("t1"), + Columns: []vindexes.Column{{ + Name: sqlparser.NewIdentifierCI("id"), + Type: sqltypes.Int32, + }, { + Name: sqlparser.NewIdentifierCI("col1"), + Type: sqltypes.Int32, + }}, + ColumnListAuthoritative: true, + }, + "t2": { + Name: sqlparser.NewIdentifierCS("t2"), + Columns: []vindexes.Column{{ + Name: sqlparser.NewIdentifierCI("id"), + Type: sqltypes.Int32, + }, { + Name: sqlparser.NewIdentifierCI("col2"), + Type: sqltypes.Int32, + }}, + ColumnListAuthoritative: true, + }, + }, + } + cDB := "db" + tcases := []struct { + sql string + expSQL string + expDeps TableSet + expErr string + warning string + }{{ + sql: "select t3.col from t3 group by kj", + expSQL: "select t3.col from t3 group by kj", + expDeps: TS0, + }, { + sql: "select t2.col2 as xyz from t2 group by xyz", + expSQL: "select t2.col2 as xyz from t2 group by t2.col2", + expDeps: TS0, + }, { + sql: "select id from t1 group by unknown", + expErr: "Unknown column 'unknown' in 'group statement'", + }, { + sql: "select t1.c as x, sum(t2.id) as x from t1 join t2 group by x", + expErr: "VT03005: cannot group on 'x'", + }, { + sql: "select t1.col1, sum(t2.id) as col1 from t1 join t2 group by col1", + expSQL: "select t1.col1, sum(t2.id) as col1 from t1 join t2 group by col1", + expDeps: TS0, + warning: "Column 'col1' in group statement is ambiguous", + }, { + sql: "select t2.col2 as id, sum(t2.id) as x from t1 join t2 group by id", + expSQL: "select t2.col2 as id, sum(t2.id) as x from t1 join t2 group by t2.col2", + expDeps: TS1, + }, { + sql: "select sum(t2.col2) as id, sum(t2.id) as x from t1 join t2 group by id", + expErr: "VT03005: cannot group on 'id'", + }, { + sql: "select count(*) as x from t1 group by x", + expErr: "VT03005: cannot group on 'x'", + }} + for _, tcase := range tcases { + t.Run(tcase.sql, func(t *testing.T) { + ast, err := sqlparser.NewTestParser().Parse(tcase.sql) + require.NoError(t, err) + selectStatement := ast.(*sqlparser.Select) + st, err := AnalyzeStrict(selectStatement, cDB, schemaInfo) + if tcase.expErr == "" { + require.NoError(t, err) + assert.Equal(t, tcase.expSQL, sqlparser.String(selectStatement)) + gb := selectStatement.GroupBy + deps := st.RecursiveDeps(gb[0]) + assert.Equal(t, tcase.expDeps, deps) + assert.Equal(t, tcase.warning, st.Warning) + } else { + require.EqualError(t, err, tcase.expErr) + } + }) + } +} + func TestGroupByLiteral(t *testing.T) { schemaInfo := &FakeSI{ Tables: map[string]*vindexes.Table{}, @@ -432,33 +516,89 @@ func TestOrderByLiteral(t *testing.T) { } func TestHavingColumnName(t *testing.T) { - schemaInfo := &FakeSI{ - Tables: map[string]*vindexes.Table{}, - } + schemaInfo := getSchemaWithKnownColumns() cDB := "db" tcases := []struct { - sql string - expSQL string - expErr string + sql string + expSQL string + expDeps TableSet + expErr string + warning string }{{ - sql: "select id, sum(foo) as sumOfFoo from t1 having sumOfFoo > 1", - expSQL: "select id, sum(foo) as sumOfFoo from t1 having sum(foo) > 1", + sql: "select id, sum(foo) as sumOfFoo from t1 having sumOfFoo > 1", + expSQL: "select id, sum(foo) as sumOfFoo from t1 having sum(t1.foo) > 1", + expDeps: TS0, + }, { + sql: "select id as X, sum(foo) as X from t1 having X > 1", + expErr: "Column 'X' in field list is ambiguous", + }, { + sql: "select id, sum(t1.foo) as foo from t1 having sum(foo) > 1", + expSQL: "select id, sum(t1.foo) as foo from t1 having sum(foo) > 1", + expDeps: TS0, + warning: "Column 'foo' in having clause is ambiguous", + }, { + sql: "select id, sum(t1.foo) as XYZ from t1 having sum(XYZ) > 1", + expErr: "Invalid use of group function", + }, { + sql: "select foo + 2 as foo from t1 having foo = 42", + expSQL: "select foo + 2 as foo from t1 having t1.foo + 2 = 42", + expDeps: TS0, + }, { + sql: "select count(*), ename from emp group by ename having comm > 1000", + expErr: "Unknown column 'comm' in 'having clause'", + }, { + sql: "select sal, ename from emp having empno > 1000", + expSQL: "select sal, ename from emp having empno > 1000", + expDeps: TS0, + }, { + sql: "select foo, count(*) foo from t1 group by foo having foo > 1000", + expErr: "Column 'foo' in field list is ambiguous", + }, { + sql: "select foo, count(*) foo from t1, emp group by foo having sum(sal) > 1000", + expSQL: "select foo, count(*) as foo from t1, emp group by foo having sum(sal) > 1000", + expDeps: TS1, + warning: "Column 'foo' in group statement is ambiguous", + }, { + sql: "select foo as X, sal as foo from t1, emp having sum(X) > 1000", + expSQL: "select foo as X, sal as foo from t1, emp having sum(t1.foo) > 1000", + expDeps: TS0, + }, { + sql: "select count(*) a from someTable having a = 10", + expSQL: "select count(*) as a from someTable having count(*) = 10", + expDeps: TS0, + }, { + sql: "select count(*) from emp having ename = 10", + expSQL: "select count(*) from emp having ename = 10", + expDeps: TS0, + }, { + sql: "select sum(sal) empno from emp where ename > 0 having empno = 2", + expSQL: "select sum(sal) as empno from emp where ename > 0 having sum(emp.sal) = 2", + expDeps: TS0, }, { - sql: "select id, sum(foo) as foo from t1 having sum(foo) > 1", - expSQL: "select id, sum(foo) as foo from t1 having sum(foo) > 1", + // test with missing schema info + sql: "select foo, count(bar) as x from someTable group by foo having id > avg(baz)", + expErr: "Unknown column 'id' in 'having clause'", }, { - sql: "select foo + 2 as foo from t1 having foo = 42", - expSQL: "select foo + 2 as foo from t1 having foo + 2 = 42", + sql: "select t1.foo as alias, count(bar) as x from t1 group by foo having foo+54 = 56", + expSQL: "select t1.foo as alias, count(bar) as x from t1 group by foo having foo + 54 = 56", + expDeps: TS0, + }, { + sql: "select 1 from t1 group by foo having foo = 1 and count(*) > 1", + expSQL: "select 1 from t1 group by foo having foo = 1 and count(*) > 1", + expDeps: TS0, }} + for _, tcase := range tcases { t.Run(tcase.sql, func(t *testing.T) { ast, err := sqlparser.NewTestParser().Parse(tcase.sql) require.NoError(t, err) - selectStatement := ast.(sqlparser.SelectStatement) - _, err = Analyze(selectStatement, cDB, schemaInfo) + selectStatement := ast.(*sqlparser.Select) + semTbl, err := AnalyzeStrict(selectStatement, cDB, schemaInfo) if tcase.expErr == "" { require.NoError(t, err) assert.Equal(t, tcase.expSQL, sqlparser.String(selectStatement)) + assert.Equal(t, tcase.expDeps, semTbl.RecursiveDeps(selectStatement.Having.Expr)) + assert.Equal(t, tcase.warning, semTbl.Warning, "warning") } else { require.EqualError(t, err, tcase.expErr) } @@ -466,7 +606,7 @@ func TestHavingColumnName(t *testing.T) { } } -func TestOrderByColumnName(t *testing.T) { +func getSchemaWithKnownColumns() *FakeSI { schemaInfo := &FakeSI{ Tables: map[string]*vindexes.Table{ "t1": { @@ -484,66 +624,114 @@ func TestOrderByColumnName(t *testing.T) { }}, ColumnListAuthoritative: true, }, + "emp": { + Keyspace: &vindexes.Keyspace{Name: "ks", Sharded: true}, + Name: sqlparser.NewIdentifierCS("emp"), + Columns: []vindexes.Column{{ + Name: sqlparser.NewIdentifierCI("empno"), + Type: sqltypes.Int64, + }, { + Name: sqlparser.NewIdentifierCI("ename"), + Type: sqltypes.VarChar, + }, { + Name: sqlparser.NewIdentifierCI("sal"), + Type: sqltypes.Int64, + }}, + ColumnListAuthoritative: true, + }, }, } + return schemaInfo +} + +func TestOrderByColumnName(t *testing.T) { + schemaInfo := getSchemaWithKnownColumns() cDB := "db" tcases := []struct { - sql string - expSQL string - expErr string + sql string + expSQL string + expErr string + warning string + deps TableSet }{{ sql: "select id, sum(foo) as sumOfFoo from t1 order by sumOfFoo", - expSQL: "select id, sum(foo) as sumOfFoo from t1 order by sum(foo) asc", + expSQL: "select id, sum(foo) as sumOfFoo from t1 order by sum(t1.foo) asc", + deps: TS0, }, { sql: "select id, sum(foo) as sumOfFoo from t1 order by sumOfFoo + 1", - expSQL: "select id, sum(foo) as sumOfFoo from t1 order by sum(foo) + 1 asc", + expSQL: "select id, sum(foo) as sumOfFoo from t1 order by sum(t1.foo) + 1 asc", + deps: TS0, }, { sql: "select id, sum(foo) as sumOfFoo from t1 order by abs(sumOfFoo)", - expSQL: "select id, sum(foo) as sumOfFoo from t1 order by abs(sum(foo)) asc", + expSQL: "select id, sum(foo) as sumOfFoo from t1 order by abs(sum(t1.foo)) asc", + deps: TS0, }, { sql: "select id, sum(foo) as sumOfFoo from t1 order by max(sumOfFoo)", expErr: "Invalid use of group function", }, { - sql: "select id, sum(foo) as foo from t1 order by foo + 1", - expSQL: "select id, sum(foo) as foo from t1 order by foo + 1 asc", + sql: "select id, sum(foo) as foo from t1 order by foo + 1", + expSQL: "select id, sum(foo) as foo from t1 order by foo + 1 asc", + deps: TS0, + warning: "Column 'foo' in order by statement is ambiguous", }, { - sql: "select id, sum(foo) as foo from t1 order by foo", - expSQL: "select id, sum(foo) as foo from t1 order by sum(foo) asc", + sql: "select id, sum(foo) as foo from t1 order by foo", + expSQL: "select id, sum(foo) as foo from t1 order by sum(t1.foo) asc", + deps: TS0, + warning: "Column 'foo' in order by statement is ambiguous", }, { - sql: "select id, lower(min(foo)) as foo from t1 order by min(foo)", - expSQL: "select id, lower(min(foo)) as foo from t1 order by min(foo) asc", + sql: "select id, lower(min(foo)) as foo from t1 order by min(foo)", + expSQL: "select id, lower(min(foo)) as foo from t1 order by min(foo) asc", + deps: TS0, + warning: "Column 'foo' in order by statement is ambiguous", }, { - sql: "select id, lower(min(foo)) as foo from t1 order by foo", - expSQL: "select id, lower(min(foo)) as foo from t1 order by lower(min(foo)) asc", + sql: "select id, lower(min(foo)) as foo from t1 order by foo", + expSQL: "select id, lower(min(foo)) as foo from t1 order by lower(min(t1.foo)) asc", + deps: TS0, + warning: "Column 'foo' in order by statement is ambiguous", }, { - sql: "select id, lower(min(foo)) as foo from t1 order by abs(foo)", - expSQL: "select id, lower(min(foo)) as foo from t1 order by abs(foo) asc", + sql: "select id, lower(min(foo)) as foo from t1 order by abs(foo)", + expSQL: "select id, lower(min(foo)) as foo from t1 order by abs(foo) asc", + deps: TS0, + warning: "Column 'foo' in order by statement is ambiguous", }, { - sql: "select id, t1.bar as foo from t1 group by id order by min(foo)", - expSQL: "select id, t1.bar as foo from t1 group by id order by min(foo) asc", + sql: "select id, t1.bar as foo from t1 group by id order by min(foo)", + expSQL: "select id, t1.bar as foo from t1 group by id order by min(foo) asc", + deps: TS0, + warning: "Column 'foo' in order by statement is ambiguous", }, { sql: "select id, bar as id, count(*) from t1 order by id", expErr: "Column 'id' in field list is ambiguous", }, { - sql: "select id, id, count(*) from t1 order by id", - expSQL: "select id, id, count(*) from t1 order by id asc", + sql: "select id, id, count(*) from t1 order by id", + expSQL: "select id, id, count(*) from t1 order by t1.id asc", + deps: TS0, + warning: "Column 'id' in order by statement is ambiguous", }, { - sql: "select id, count(distinct foo) k from t1 group by id order by k", - expSQL: "select id, count(distinct foo) as k from t1 group by id order by count(distinct foo) asc", + sql: "select id, count(distinct foo) k from t1 group by id order by k", + expSQL: "select id, count(distinct foo) as k from t1 group by id order by count(distinct t1.foo) asc", + deps: TS0, + warning: "Column 'id' in group statement is ambiguous", }, { sql: "select user.id as foo from user union select col from user_extra order by foo", expSQL: "select `user`.id as foo from `user` union select col from user_extra order by foo asc", - }, - } + deps: MergeTableSets(TS0, TS1), + }, { + sql: "select foo as X, sal as foo from t1, emp order by sum(X)", + expSQL: "select foo as X, sal as foo from t1, emp order by sum(t1.foo) asc", + deps: TS0, + }} for _, tcase := range tcases { t.Run(tcase.sql, func(t *testing.T) { ast, err := sqlparser.NewTestParser().Parse(tcase.sql) require.NoError(t, err) selectStatement := ast.(sqlparser.SelectStatement) - _, err = Analyze(selectStatement, cDB, schemaInfo) + semTable, err := AnalyzeStrict(selectStatement, cDB, schemaInfo) if tcase.expErr == "" { require.NoError(t, err) assert.Equal(t, tcase.expSQL, sqlparser.String(selectStatement)) + orderByExpr := selectStatement.GetOrderBy()[0].Expr + assert.Equal(t, tcase.deps, semTable.RecursiveDeps(orderByExpr)) + assert.Equal(t, tcase.warning, semTable.Warning) } else { require.EqualError(t, err, tcase.expErr) } diff --git a/go/vt/vtgate/semantics/errors.go b/go/vt/vtgate/semantics/errors.go index a903408ba9d..297f2b9613e 100644 --- a/go/vt/vtgate/semantics/errors.go +++ b/go/vt/vtgate/semantics/errors.go @@ -52,7 +52,8 @@ type ( SubqueryColumnCountError struct{ Expected int } ColumnsMissingInSchemaError struct{} CantUseMultipleVindexHints struct{ Table string } - InvalidUserOfGroupFunction struct{} + InvalidUseOfGroupFunction struct{} + CantGroupOn struct{ Column string } NoSuchVindexFound struct { Table string @@ -71,6 +72,10 @@ type ( Column *sqlparser.ColName Table *sqlparser.TableName } + ColumnNotFoundClauseError struct { + Column string + Clause string + } ) func eprintf(e error, format string, args ...any) string { @@ -289,15 +294,41 @@ func (c *NoSuchVindexFound) ErrorCode() vtrpcpb.Code { return vtrpcpb.Code_FAILED_PRECONDITION } -// InvalidUserOfGroupFunction -func (*InvalidUserOfGroupFunction) Error() string { +// InvalidUseOfGroupFunction +func (*InvalidUseOfGroupFunction) Error() string { return "Invalid use of group function" } -func (*InvalidUserOfGroupFunction) ErrorCode() vtrpcpb.Code { +func (*InvalidUseOfGroupFunction) ErrorCode() vtrpcpb.Code { return vtrpcpb.Code_INVALID_ARGUMENT } -func (*InvalidUserOfGroupFunction) ErrorState() vterrors.State { +func (*InvalidUseOfGroupFunction) ErrorState() vterrors.State { return vterrors.InvalidGroupFuncUse } + +// CantGroupOn +func (e *CantGroupOn) Error() string { + return vterrors.VT03005(e.Column).Error() +} + +func (*CantGroupOn) ErrorCode() vtrpcpb.Code { + return vtrpcpb.Code_INVALID_ARGUMENT +} + +func (e *CantGroupOn) ErrorState() vterrors.State { + return vterrors.VT03005(e.Column).State +} + +// ColumnNotFoundInGroupByError +func (e *ColumnNotFoundClauseError) Error() string { + return fmt.Sprintf("Unknown column '%s' in '%s'", e.Column, e.Clause) +} + +func (*ColumnNotFoundClauseError) ErrorCode() vtrpcpb.Code { + return vtrpcpb.Code_INVALID_ARGUMENT +} + +func (e *ColumnNotFoundClauseError) ErrorState() vterrors.State { + return vterrors.BadFieldError +} diff --git a/go/vt/vtgate/semantics/scoper.go b/go/vt/vtgate/semantics/scoper.go index faef930b488..3a6fbe4c35c 100644 --- a/go/vt/vtgate/semantics/scoper.go +++ b/go/vt/vtgate/semantics/scoper.go @@ -40,13 +40,16 @@ type ( } scope struct { - parent *scope - stmt sqlparser.Statement - tables []TableInfo - isUnion bool - joinUsing map[string]TableSet - stmtScope bool - ctes map[string]*sqlparser.CommonTableExpr + parent *scope + stmt sqlparser.Statement + tables []TableInfo + isUnion bool + joinUsing map[string]TableSet + stmtScope bool + ctes map[string]*sqlparser.CommonTableExpr + inGroupBy bool + inHaving bool + inHavingAggr bool } ) @@ -76,9 +79,19 @@ func (s *scoper) down(cursor *sqlparser.Cursor) error { return s.addColumnInfoForOrderBy(cursor, node) case sqlparser.GroupBy: return s.addColumnInfoForGroupBy(cursor, node) + case sqlparser.AggrFunc: + if !s.currentScope().inHaving { + break + } + s.currentScope().inHavingAggr = true case *sqlparser.Where: if node.Type == sqlparser.HavingClause { - return s.createSpecialScopePostProjection(cursor.Parent()) + err := s.createSpecialScopePostProjection(cursor.Parent()) + if err != nil { + return err + } + s.currentScope().inHaving = true + return nil } } return nil @@ -97,10 +110,12 @@ func (s *scoper) addColumnInfoForGroupBy(cursor *sqlparser.Cursor, node sqlparse if err != nil { return err } + currentScope := s.currentScope() + currentScope.inGroupBy = true for _, expr := range node { lit := keepIntLiteral(expr) if lit != nil { - s.specialExprScopes[lit] = s.currentScope() + s.specialExprScopes[lit] = currentScope } } return nil @@ -210,6 +225,8 @@ func (s *scoper) up(cursor *sqlparser.Cursor) error { break } s.popScope() + case sqlparser.AggrFunc: + s.currentScope().inHavingAggr = false case sqlparser.TableExpr: if isParentSelect(cursor) { curScope := s.currentScope() diff --git a/go/vt/vtgate/semantics/vtable.go b/go/vt/vtgate/semantics/vtable.go index 133e38ff505..81f81de3813 100644 --- a/go/vt/vtgate/semantics/vtable.go +++ b/go/vt/vtgate/semantics/vtable.go @@ -42,10 +42,25 @@ func (v *vTableInfo) dependencies(colName string, org originable) (dependencies, if name != colName { continue } - directDeps, recursiveDeps, qt := org.depsForExpr(v.cols[i]) + deps = deps.merge(v.createCertainForCol(org, i), false) + } + if deps.empty() && v.hasStar() { + return createUncertain(v.tables, v.tables), nil + } + return deps, nil +} - newDeps := createCertain(directDeps, recursiveDeps, qt) - deps = deps.merge(newDeps, false) +func (v *vTableInfo) dependenciesInGroupBy(colName string, org originable) (dependencies, error) { + // this method is consciously very similar to vTableInfo.dependencies and should remain so + var deps dependencies = ¬hing{} + for i, name := range v.columnNames { + if name != colName { + continue + } + if sqlparser.ContainsAggregation(v.cols[i]) { + return nil, &CantGroupOn{name} + } + deps = deps.merge(v.createCertainForCol(org, i), false) } if deps.empty() && v.hasStar() { return createUncertain(v.tables, v.tables), nil @@ -53,6 +68,12 @@ func (v *vTableInfo) dependencies(colName string, org originable) (dependencies, return deps, nil } +func (v *vTableInfo) createCertainForCol(org originable, i int) *certain { + directDeps, recursiveDeps, qt := org.depsForExpr(v.cols[i]) + newDeps := createCertain(directDeps, recursiveDeps, qt) + return newDeps +} + // IsInfSchema implements the TableInfo interface func (v *vTableInfo) IsInfSchema() bool { return false From 45ae25eec4818c655c71d678d205101a9914052b Mon Sep 17 00:00:00 2001 From: Andrew Mason Date: Thu, 29 Feb 2024 10:53:58 -0500 Subject: [PATCH 70/79] [vtctldclient] Add GetShardReplication (#15389) Signed-off-by: Andrew Mason --- go/cmd/vtctldclient/command/shards.go | 39 + go/flags/endtoend/vtctldclient.txt | 1 + go/vt/proto/vtctldata/vtctldata.pb.go | 4875 +++++++++-------- go/vt/proto/vtctldata/vtctldata_vtproto.pb.go | 532 ++ go/vt/proto/vtctlservice/vtctlservice.pb.go | 1602 +++--- .../vtctlservice/vtctlservice_grpc.pb.go | 38 + go/vt/vtctl/grpcvtctldclient/client_gen.go | 9 + go/vt/vtctl/grpcvtctldserver/server.go | 37 + go/vt/vtctl/grpcvtctldserver/server_test.go | 205 + go/vt/vtctl/localvtctldclient/client_gen.go | 5 + proto/vtctldata.proto | 12 + proto/vtctlservice.proto | 2 + web/vtadmin/src/proto/vtadmin.d.ts | 206 + web/vtadmin/src/proto/vtadmin.js | 512 ++ 14 files changed, 4924 insertions(+), 3151 deletions(-) diff --git a/go/cmd/vtctldclient/command/shards.go b/go/cmd/vtctldclient/command/shards.go index a33ea187f62..1a3288a30b8 100644 --- a/go/cmd/vtctldclient/command/shards.go +++ b/go/cmd/vtctldclient/command/shards.go @@ -93,6 +93,14 @@ that shard.`, Args: cobra.ExactArgs(1), RunE: commandGetShard, } + // GetShardReplication makes a GetShardReplication gRPC request to a vtctld. + GetShardReplication = &cobra.Command{ + Use: "GetShardReplication [cell1 [cell2...]]", + Short: "Returns information about the replication relationships for a shard in the given cell(s).", + DisableFlagsInUseLine: true, + Args: cobra.MinimumNArgs(1), + RunE: commandGetShardReplication, + } // RemoveShardCell makes a RemoveShardCell gRPC request to a vtctld. RemoveShardCell = &cobra.Command{ Use: "RemoveShardCell [--force|-f] [--recursive|-r] ", @@ -286,6 +294,36 @@ func commandGetShard(cmd *cobra.Command, args []string) error { return nil } +func commandGetShardReplication(cmd *cobra.Command, args []string) error { + keyspace, shard, err := topoproto.ParseKeyspaceShard(cmd.Flags().Arg(0)) + if err != nil { + return err + } + + cells := cmd.Flags().Args()[1:] + + cli.FinishedParsing(cmd) + + resp, err := client.GetShardReplication(commandCtx, &vtctldatapb.GetShardReplicationRequest{ + Keyspace: keyspace, + Shard: shard, + Cells: cells, + }) + if err != nil { + return err + } + + data, err := cli.MarshalJSON(resp) + if err != nil { + return err + } + + fmt.Printf("%s\n", data) + + return nil + +} + var removeShardCellOptions = struct { Force bool Recursive bool @@ -624,6 +662,7 @@ func init() { Root.AddCommand(DeleteShards) Root.AddCommand(GetShard) + Root.AddCommand(GetShardReplication) Root.AddCommand(GenerateShardRanges) RemoveShardCell.Flags().BoolVarP(&removeShardCellOptions.Force, "force", "f", false, "Proceed even if the cell's topology server cannot be reached. The assumption is that you turned down the entire cell, and just need to update the global topo data.") diff --git a/go/flags/endtoend/vtctldclient.txt b/go/flags/endtoend/vtctldclient.txt index 86c1bb3bfa2..be0e49b856c 100644 --- a/go/flags/endtoend/vtctldclient.txt +++ b/go/flags/endtoend/vtctldclient.txt @@ -43,6 +43,7 @@ Available Commands: GetRoutingRules Displays the VSchema routing rules. GetSchema Displays the full schema for a tablet, optionally restricted to the specified tables/views. GetShard Returns information about a shard in the topology. + GetShardReplication Returns information about the replication relationships for a shard in the given cell(s). GetShardRoutingRules Displays the currently active shard routing rules as a JSON document. GetSrvKeyspaceNames Outputs a JSON mapping of cell=>keyspace names served in that cell. Omit to query all cells. GetSrvKeyspaces Returns the SrvKeyspaces for the given keyspace in one or more cells. diff --git a/go/vt/proto/vtctldata/vtctldata.pb.go b/go/vt/proto/vtctldata/vtctldata.pb.go index bec6a89d360..2d9de4cc19d 100644 --- a/go/vt/proto/vtctldata/vtctldata.pb.go +++ b/go/vt/proto/vtctldata/vtctldata.pb.go @@ -5568,6 +5568,118 @@ func (x *GetSchemaMigrationsResponse) GetMigrations() []*SchemaMigration { return nil } +type GetShardReplicationRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"` + Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"` + // Cells is the list of cells to fetch data for. Omit to fetch data from all + // cells. + Cells []string `protobuf:"bytes,3,rep,name=cells,proto3" json:"cells,omitempty"` +} + +func (x *GetShardReplicationRequest) Reset() { + *x = GetShardReplicationRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_vtctldata_proto_msgTypes[81] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetShardReplicationRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetShardReplicationRequest) ProtoMessage() {} + +func (x *GetShardReplicationRequest) ProtoReflect() protoreflect.Message { + mi := &file_vtctldata_proto_msgTypes[81] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetShardReplicationRequest.ProtoReflect.Descriptor instead. +func (*GetShardReplicationRequest) Descriptor() ([]byte, []int) { + return file_vtctldata_proto_rawDescGZIP(), []int{81} +} + +func (x *GetShardReplicationRequest) GetKeyspace() string { + if x != nil { + return x.Keyspace + } + return "" +} + +func (x *GetShardReplicationRequest) GetShard() string { + if x != nil { + return x.Shard + } + return "" +} + +func (x *GetShardReplicationRequest) GetCells() []string { + if x != nil { + return x.Cells + } + return nil +} + +type GetShardReplicationResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ShardReplicationByCell map[string]*topodata.ShardReplication `protobuf:"bytes,1,rep,name=shard_replication_by_cell,json=shardReplicationByCell,proto3" json:"shard_replication_by_cell,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *GetShardReplicationResponse) Reset() { + *x = GetShardReplicationResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_vtctldata_proto_msgTypes[82] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetShardReplicationResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetShardReplicationResponse) ProtoMessage() {} + +func (x *GetShardReplicationResponse) ProtoReflect() protoreflect.Message { + mi := &file_vtctldata_proto_msgTypes[82] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetShardReplicationResponse.ProtoReflect.Descriptor instead. +func (*GetShardReplicationResponse) Descriptor() ([]byte, []int) { + return file_vtctldata_proto_rawDescGZIP(), []int{82} +} + +func (x *GetShardReplicationResponse) GetShardReplicationByCell() map[string]*topodata.ShardReplication { + if x != nil { + return x.ShardReplicationByCell + } + return nil +} + type GetShardRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -5580,7 +5692,7 @@ type GetShardRequest struct { func (x *GetShardRequest) Reset() { *x = GetShardRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[81] + mi := &file_vtctldata_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5593,7 +5705,7 @@ func (x *GetShardRequest) String() string { func (*GetShardRequest) ProtoMessage() {} func (x *GetShardRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[81] + mi := &file_vtctldata_proto_msgTypes[83] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5606,7 +5718,7 @@ func (x *GetShardRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetShardRequest.ProtoReflect.Descriptor instead. func (*GetShardRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{81} + return file_vtctldata_proto_rawDescGZIP(), []int{83} } func (x *GetShardRequest) GetKeyspace() string { @@ -5634,7 +5746,7 @@ type GetShardResponse struct { func (x *GetShardResponse) Reset() { *x = GetShardResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[82] + mi := &file_vtctldata_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5647,7 +5759,7 @@ func (x *GetShardResponse) String() string { func (*GetShardResponse) ProtoMessage() {} func (x *GetShardResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[82] + mi := &file_vtctldata_proto_msgTypes[84] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5660,7 +5772,7 @@ func (x *GetShardResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetShardResponse.ProtoReflect.Descriptor instead. func (*GetShardResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{82} + return file_vtctldata_proto_rawDescGZIP(), []int{84} } func (x *GetShardResponse) GetShard() *Shard { @@ -5679,7 +5791,7 @@ type GetShardRoutingRulesRequest struct { func (x *GetShardRoutingRulesRequest) Reset() { *x = GetShardRoutingRulesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[83] + mi := &file_vtctldata_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5692,7 +5804,7 @@ func (x *GetShardRoutingRulesRequest) String() string { func (*GetShardRoutingRulesRequest) ProtoMessage() {} func (x *GetShardRoutingRulesRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[83] + mi := &file_vtctldata_proto_msgTypes[85] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5705,7 +5817,7 @@ func (x *GetShardRoutingRulesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetShardRoutingRulesRequest.ProtoReflect.Descriptor instead. func (*GetShardRoutingRulesRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{83} + return file_vtctldata_proto_rawDescGZIP(), []int{85} } type GetShardRoutingRulesResponse struct { @@ -5719,7 +5831,7 @@ type GetShardRoutingRulesResponse struct { func (x *GetShardRoutingRulesResponse) Reset() { *x = GetShardRoutingRulesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[84] + mi := &file_vtctldata_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5732,7 +5844,7 @@ func (x *GetShardRoutingRulesResponse) String() string { func (*GetShardRoutingRulesResponse) ProtoMessage() {} func (x *GetShardRoutingRulesResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[84] + mi := &file_vtctldata_proto_msgTypes[86] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5745,7 +5857,7 @@ func (x *GetShardRoutingRulesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetShardRoutingRulesResponse.ProtoReflect.Descriptor instead. func (*GetShardRoutingRulesResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{84} + return file_vtctldata_proto_rawDescGZIP(), []int{86} } func (x *GetShardRoutingRulesResponse) GetShardRoutingRules() *vschema.ShardRoutingRules { @@ -5766,7 +5878,7 @@ type GetSrvKeyspaceNamesRequest struct { func (x *GetSrvKeyspaceNamesRequest) Reset() { *x = GetSrvKeyspaceNamesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[85] + mi := &file_vtctldata_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5779,7 +5891,7 @@ func (x *GetSrvKeyspaceNamesRequest) String() string { func (*GetSrvKeyspaceNamesRequest) ProtoMessage() {} func (x *GetSrvKeyspaceNamesRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[85] + mi := &file_vtctldata_proto_msgTypes[87] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5792,7 +5904,7 @@ func (x *GetSrvKeyspaceNamesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvKeyspaceNamesRequest.ProtoReflect.Descriptor instead. func (*GetSrvKeyspaceNamesRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{85} + return file_vtctldata_proto_rawDescGZIP(), []int{87} } func (x *GetSrvKeyspaceNamesRequest) GetCells() []string { @@ -5814,7 +5926,7 @@ type GetSrvKeyspaceNamesResponse struct { func (x *GetSrvKeyspaceNamesResponse) Reset() { *x = GetSrvKeyspaceNamesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[86] + mi := &file_vtctldata_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5827,7 +5939,7 @@ func (x *GetSrvKeyspaceNamesResponse) String() string { func (*GetSrvKeyspaceNamesResponse) ProtoMessage() {} func (x *GetSrvKeyspaceNamesResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[86] + mi := &file_vtctldata_proto_msgTypes[88] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5840,7 +5952,7 @@ func (x *GetSrvKeyspaceNamesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvKeyspaceNamesResponse.ProtoReflect.Descriptor instead. func (*GetSrvKeyspaceNamesResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{86} + return file_vtctldata_proto_rawDescGZIP(), []int{88} } func (x *GetSrvKeyspaceNamesResponse) GetNames() map[string]*GetSrvKeyspaceNamesResponse_NameList { @@ -5864,7 +5976,7 @@ type GetSrvKeyspacesRequest struct { func (x *GetSrvKeyspacesRequest) Reset() { *x = GetSrvKeyspacesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[87] + mi := &file_vtctldata_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5877,7 +5989,7 @@ func (x *GetSrvKeyspacesRequest) String() string { func (*GetSrvKeyspacesRequest) ProtoMessage() {} func (x *GetSrvKeyspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[87] + mi := &file_vtctldata_proto_msgTypes[89] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5890,7 +6002,7 @@ func (x *GetSrvKeyspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvKeyspacesRequest.ProtoReflect.Descriptor instead. func (*GetSrvKeyspacesRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{87} + return file_vtctldata_proto_rawDescGZIP(), []int{89} } func (x *GetSrvKeyspacesRequest) GetKeyspace() string { @@ -5919,7 +6031,7 @@ type GetSrvKeyspacesResponse struct { func (x *GetSrvKeyspacesResponse) Reset() { *x = GetSrvKeyspacesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[88] + mi := &file_vtctldata_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5932,7 +6044,7 @@ func (x *GetSrvKeyspacesResponse) String() string { func (*GetSrvKeyspacesResponse) ProtoMessage() {} func (x *GetSrvKeyspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[88] + mi := &file_vtctldata_proto_msgTypes[90] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5945,7 +6057,7 @@ func (x *GetSrvKeyspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvKeyspacesResponse.ProtoReflect.Descriptor instead. func (*GetSrvKeyspacesResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{88} + return file_vtctldata_proto_rawDescGZIP(), []int{90} } func (x *GetSrvKeyspacesResponse) GetSrvKeyspaces() map[string]*topodata.SrvKeyspace { @@ -5982,7 +6094,7 @@ type UpdateThrottlerConfigRequest struct { func (x *UpdateThrottlerConfigRequest) Reset() { *x = UpdateThrottlerConfigRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[89] + mi := &file_vtctldata_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5995,7 +6107,7 @@ func (x *UpdateThrottlerConfigRequest) String() string { func (*UpdateThrottlerConfigRequest) ProtoMessage() {} func (x *UpdateThrottlerConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[89] + mi := &file_vtctldata_proto_msgTypes[91] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6008,7 +6120,7 @@ func (x *UpdateThrottlerConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateThrottlerConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateThrottlerConfigRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{89} + return file_vtctldata_proto_rawDescGZIP(), []int{91} } func (x *UpdateThrottlerConfigRequest) GetKeyspace() string { @@ -6083,7 +6195,7 @@ type UpdateThrottlerConfigResponse struct { func (x *UpdateThrottlerConfigResponse) Reset() { *x = UpdateThrottlerConfigResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[90] + mi := &file_vtctldata_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6096,7 +6208,7 @@ func (x *UpdateThrottlerConfigResponse) String() string { func (*UpdateThrottlerConfigResponse) ProtoMessage() {} func (x *UpdateThrottlerConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[90] + mi := &file_vtctldata_proto_msgTypes[92] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6109,7 +6221,7 @@ func (x *UpdateThrottlerConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateThrottlerConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateThrottlerConfigResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{90} + return file_vtctldata_proto_rawDescGZIP(), []int{92} } type GetSrvVSchemaRequest struct { @@ -6123,7 +6235,7 @@ type GetSrvVSchemaRequest struct { func (x *GetSrvVSchemaRequest) Reset() { *x = GetSrvVSchemaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[91] + mi := &file_vtctldata_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6136,7 +6248,7 @@ func (x *GetSrvVSchemaRequest) String() string { func (*GetSrvVSchemaRequest) ProtoMessage() {} func (x *GetSrvVSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[91] + mi := &file_vtctldata_proto_msgTypes[93] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6149,7 +6261,7 @@ func (x *GetSrvVSchemaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvVSchemaRequest.ProtoReflect.Descriptor instead. func (*GetSrvVSchemaRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{91} + return file_vtctldata_proto_rawDescGZIP(), []int{93} } func (x *GetSrvVSchemaRequest) GetCell() string { @@ -6170,7 +6282,7 @@ type GetSrvVSchemaResponse struct { func (x *GetSrvVSchemaResponse) Reset() { *x = GetSrvVSchemaResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[92] + mi := &file_vtctldata_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6183,7 +6295,7 @@ func (x *GetSrvVSchemaResponse) String() string { func (*GetSrvVSchemaResponse) ProtoMessage() {} func (x *GetSrvVSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[92] + mi := &file_vtctldata_proto_msgTypes[94] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6196,7 +6308,7 @@ func (x *GetSrvVSchemaResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvVSchemaResponse.ProtoReflect.Descriptor instead. func (*GetSrvVSchemaResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{92} + return file_vtctldata_proto_rawDescGZIP(), []int{94} } func (x *GetSrvVSchemaResponse) GetSrvVSchema() *vschema.SrvVSchema { @@ -6217,7 +6329,7 @@ type GetSrvVSchemasRequest struct { func (x *GetSrvVSchemasRequest) Reset() { *x = GetSrvVSchemasRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[93] + mi := &file_vtctldata_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6230,7 +6342,7 @@ func (x *GetSrvVSchemasRequest) String() string { func (*GetSrvVSchemasRequest) ProtoMessage() {} func (x *GetSrvVSchemasRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[93] + mi := &file_vtctldata_proto_msgTypes[95] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6243,7 +6355,7 @@ func (x *GetSrvVSchemasRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvVSchemasRequest.ProtoReflect.Descriptor instead. func (*GetSrvVSchemasRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{93} + return file_vtctldata_proto_rawDescGZIP(), []int{95} } func (x *GetSrvVSchemasRequest) GetCells() []string { @@ -6265,7 +6377,7 @@ type GetSrvVSchemasResponse struct { func (x *GetSrvVSchemasResponse) Reset() { *x = GetSrvVSchemasResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[94] + mi := &file_vtctldata_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6278,7 +6390,7 @@ func (x *GetSrvVSchemasResponse) String() string { func (*GetSrvVSchemasResponse) ProtoMessage() {} func (x *GetSrvVSchemasResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[94] + mi := &file_vtctldata_proto_msgTypes[96] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6291,7 +6403,7 @@ func (x *GetSrvVSchemasResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSrvVSchemasResponse.ProtoReflect.Descriptor instead. func (*GetSrvVSchemasResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{94} + return file_vtctldata_proto_rawDescGZIP(), []int{96} } func (x *GetSrvVSchemasResponse) GetSrvVSchemas() map[string]*vschema.SrvVSchema { @@ -6312,7 +6424,7 @@ type GetTabletRequest struct { func (x *GetTabletRequest) Reset() { *x = GetTabletRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[95] + mi := &file_vtctldata_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6325,7 +6437,7 @@ func (x *GetTabletRequest) String() string { func (*GetTabletRequest) ProtoMessage() {} func (x *GetTabletRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[95] + mi := &file_vtctldata_proto_msgTypes[97] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6338,7 +6450,7 @@ func (x *GetTabletRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTabletRequest.ProtoReflect.Descriptor instead. func (*GetTabletRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{95} + return file_vtctldata_proto_rawDescGZIP(), []int{97} } func (x *GetTabletRequest) GetTabletAlias() *topodata.TabletAlias { @@ -6359,7 +6471,7 @@ type GetTabletResponse struct { func (x *GetTabletResponse) Reset() { *x = GetTabletResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[96] + mi := &file_vtctldata_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6372,7 +6484,7 @@ func (x *GetTabletResponse) String() string { func (*GetTabletResponse) ProtoMessage() {} func (x *GetTabletResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[96] + mi := &file_vtctldata_proto_msgTypes[98] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6385,7 +6497,7 @@ func (x *GetTabletResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTabletResponse.ProtoReflect.Descriptor instead. func (*GetTabletResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{96} + return file_vtctldata_proto_rawDescGZIP(), []int{98} } func (x *GetTabletResponse) GetTablet() *topodata.Tablet { @@ -6427,7 +6539,7 @@ type GetTabletsRequest struct { func (x *GetTabletsRequest) Reset() { *x = GetTabletsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[97] + mi := &file_vtctldata_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6440,7 +6552,7 @@ func (x *GetTabletsRequest) String() string { func (*GetTabletsRequest) ProtoMessage() {} func (x *GetTabletsRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[97] + mi := &file_vtctldata_proto_msgTypes[99] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6453,7 +6565,7 @@ func (x *GetTabletsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTabletsRequest.ProtoReflect.Descriptor instead. func (*GetTabletsRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{97} + return file_vtctldata_proto_rawDescGZIP(), []int{99} } func (x *GetTabletsRequest) GetKeyspace() string { @@ -6509,7 +6621,7 @@ type GetTabletsResponse struct { func (x *GetTabletsResponse) Reset() { *x = GetTabletsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[98] + mi := &file_vtctldata_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6522,7 +6634,7 @@ func (x *GetTabletsResponse) String() string { func (*GetTabletsResponse) ProtoMessage() {} func (x *GetTabletsResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[98] + mi := &file_vtctldata_proto_msgTypes[100] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6535,7 +6647,7 @@ func (x *GetTabletsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTabletsResponse.ProtoReflect.Descriptor instead. func (*GetTabletsResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{98} + return file_vtctldata_proto_rawDescGZIP(), []int{100} } func (x *GetTabletsResponse) GetTablets() []*topodata.Tablet { @@ -6556,7 +6668,7 @@ type GetTopologyPathRequest struct { func (x *GetTopologyPathRequest) Reset() { *x = GetTopologyPathRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[99] + mi := &file_vtctldata_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6569,7 +6681,7 @@ func (x *GetTopologyPathRequest) String() string { func (*GetTopologyPathRequest) ProtoMessage() {} func (x *GetTopologyPathRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[99] + mi := &file_vtctldata_proto_msgTypes[101] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6582,7 +6694,7 @@ func (x *GetTopologyPathRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTopologyPathRequest.ProtoReflect.Descriptor instead. func (*GetTopologyPathRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{99} + return file_vtctldata_proto_rawDescGZIP(), []int{101} } func (x *GetTopologyPathRequest) GetPath() string { @@ -6603,7 +6715,7 @@ type GetTopologyPathResponse struct { func (x *GetTopologyPathResponse) Reset() { *x = GetTopologyPathResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[100] + mi := &file_vtctldata_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6616,7 +6728,7 @@ func (x *GetTopologyPathResponse) String() string { func (*GetTopologyPathResponse) ProtoMessage() {} func (x *GetTopologyPathResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[100] + mi := &file_vtctldata_proto_msgTypes[102] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6629,7 +6741,7 @@ func (x *GetTopologyPathResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTopologyPathResponse.ProtoReflect.Descriptor instead. func (*GetTopologyPathResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{100} + return file_vtctldata_proto_rawDescGZIP(), []int{102} } func (x *GetTopologyPathResponse) GetCell() *TopologyCell { @@ -6655,7 +6767,7 @@ type TopologyCell struct { func (x *TopologyCell) Reset() { *x = TopologyCell{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[101] + mi := &file_vtctldata_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6668,7 +6780,7 @@ func (x *TopologyCell) String() string { func (*TopologyCell) ProtoMessage() {} func (x *TopologyCell) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[101] + mi := &file_vtctldata_proto_msgTypes[103] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6681,7 +6793,7 @@ func (x *TopologyCell) ProtoReflect() protoreflect.Message { // Deprecated: Use TopologyCell.ProtoReflect.Descriptor instead. func (*TopologyCell) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{101} + return file_vtctldata_proto_rawDescGZIP(), []int{103} } func (x *TopologyCell) GetName() string { @@ -6723,7 +6835,7 @@ type GetVSchemaRequest struct { func (x *GetVSchemaRequest) Reset() { *x = GetVSchemaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[102] + mi := &file_vtctldata_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6736,7 +6848,7 @@ func (x *GetVSchemaRequest) String() string { func (*GetVSchemaRequest) ProtoMessage() {} func (x *GetVSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[102] + mi := &file_vtctldata_proto_msgTypes[104] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6749,7 +6861,7 @@ func (x *GetVSchemaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetVSchemaRequest.ProtoReflect.Descriptor instead. func (*GetVSchemaRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{102} + return file_vtctldata_proto_rawDescGZIP(), []int{104} } func (x *GetVSchemaRequest) GetKeyspace() string { @@ -6770,7 +6882,7 @@ type GetVersionRequest struct { func (x *GetVersionRequest) Reset() { *x = GetVersionRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[103] + mi := &file_vtctldata_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6783,7 +6895,7 @@ func (x *GetVersionRequest) String() string { func (*GetVersionRequest) ProtoMessage() {} func (x *GetVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[103] + mi := &file_vtctldata_proto_msgTypes[105] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6796,7 +6908,7 @@ func (x *GetVersionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetVersionRequest.ProtoReflect.Descriptor instead. func (*GetVersionRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{103} + return file_vtctldata_proto_rawDescGZIP(), []int{105} } func (x *GetVersionRequest) GetTabletAlias() *topodata.TabletAlias { @@ -6817,7 +6929,7 @@ type GetVersionResponse struct { func (x *GetVersionResponse) Reset() { *x = GetVersionResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[104] + mi := &file_vtctldata_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6830,7 +6942,7 @@ func (x *GetVersionResponse) String() string { func (*GetVersionResponse) ProtoMessage() {} func (x *GetVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[104] + mi := &file_vtctldata_proto_msgTypes[106] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6843,7 +6955,7 @@ func (x *GetVersionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetVersionResponse.ProtoReflect.Descriptor instead. func (*GetVersionResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{104} + return file_vtctldata_proto_rawDescGZIP(), []int{106} } func (x *GetVersionResponse) GetVersion() string { @@ -6864,7 +6976,7 @@ type GetVSchemaResponse struct { func (x *GetVSchemaResponse) Reset() { *x = GetVSchemaResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[105] + mi := &file_vtctldata_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6877,7 +6989,7 @@ func (x *GetVSchemaResponse) String() string { func (*GetVSchemaResponse) ProtoMessage() {} func (x *GetVSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[105] + mi := &file_vtctldata_proto_msgTypes[107] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6890,7 +7002,7 @@ func (x *GetVSchemaResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetVSchemaResponse.ProtoReflect.Descriptor instead. func (*GetVSchemaResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{105} + return file_vtctldata_proto_rawDescGZIP(), []int{107} } func (x *GetVSchemaResponse) GetVSchema() *vschema.Keyspace { @@ -6917,7 +7029,7 @@ type GetWorkflowsRequest struct { func (x *GetWorkflowsRequest) Reset() { *x = GetWorkflowsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[106] + mi := &file_vtctldata_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6930,7 +7042,7 @@ func (x *GetWorkflowsRequest) String() string { func (*GetWorkflowsRequest) ProtoMessage() {} func (x *GetWorkflowsRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[106] + mi := &file_vtctldata_proto_msgTypes[108] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6943,7 +7055,7 @@ func (x *GetWorkflowsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkflowsRequest.ProtoReflect.Descriptor instead. func (*GetWorkflowsRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{106} + return file_vtctldata_proto_rawDescGZIP(), []int{108} } func (x *GetWorkflowsRequest) GetKeyspace() string { @@ -6999,7 +7111,7 @@ type GetWorkflowsResponse struct { func (x *GetWorkflowsResponse) Reset() { *x = GetWorkflowsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[107] + mi := &file_vtctldata_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7012,7 +7124,7 @@ func (x *GetWorkflowsResponse) String() string { func (*GetWorkflowsResponse) ProtoMessage() {} func (x *GetWorkflowsResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[107] + mi := &file_vtctldata_proto_msgTypes[109] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7025,7 +7137,7 @@ func (x *GetWorkflowsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkflowsResponse.ProtoReflect.Descriptor instead. func (*GetWorkflowsResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{107} + return file_vtctldata_proto_rawDescGZIP(), []int{109} } func (x *GetWorkflowsResponse) GetWorkflows() []*Workflow { @@ -7050,7 +7162,7 @@ type InitShardPrimaryRequest struct { func (x *InitShardPrimaryRequest) Reset() { *x = InitShardPrimaryRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[108] + mi := &file_vtctldata_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7063,7 +7175,7 @@ func (x *InitShardPrimaryRequest) String() string { func (*InitShardPrimaryRequest) ProtoMessage() {} func (x *InitShardPrimaryRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[108] + mi := &file_vtctldata_proto_msgTypes[110] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7076,7 +7188,7 @@ func (x *InitShardPrimaryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use InitShardPrimaryRequest.ProtoReflect.Descriptor instead. func (*InitShardPrimaryRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{108} + return file_vtctldata_proto_rawDescGZIP(), []int{110} } func (x *InitShardPrimaryRequest) GetKeyspace() string { @@ -7125,7 +7237,7 @@ type InitShardPrimaryResponse struct { func (x *InitShardPrimaryResponse) Reset() { *x = InitShardPrimaryResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[109] + mi := &file_vtctldata_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7138,7 +7250,7 @@ func (x *InitShardPrimaryResponse) String() string { func (*InitShardPrimaryResponse) ProtoMessage() {} func (x *InitShardPrimaryResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[109] + mi := &file_vtctldata_proto_msgTypes[111] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7151,7 +7263,7 @@ func (x *InitShardPrimaryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use InitShardPrimaryResponse.ProtoReflect.Descriptor instead. func (*InitShardPrimaryResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{109} + return file_vtctldata_proto_rawDescGZIP(), []int{111} } func (x *InitShardPrimaryResponse) GetEvents() []*logutil.Event { @@ -7173,7 +7285,7 @@ type LaunchSchemaMigrationRequest struct { func (x *LaunchSchemaMigrationRequest) Reset() { *x = LaunchSchemaMigrationRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[110] + mi := &file_vtctldata_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7186,7 +7298,7 @@ func (x *LaunchSchemaMigrationRequest) String() string { func (*LaunchSchemaMigrationRequest) ProtoMessage() {} func (x *LaunchSchemaMigrationRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[110] + mi := &file_vtctldata_proto_msgTypes[112] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7199,7 +7311,7 @@ func (x *LaunchSchemaMigrationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LaunchSchemaMigrationRequest.ProtoReflect.Descriptor instead. func (*LaunchSchemaMigrationRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{110} + return file_vtctldata_proto_rawDescGZIP(), []int{112} } func (x *LaunchSchemaMigrationRequest) GetKeyspace() string { @@ -7227,7 +7339,7 @@ type LaunchSchemaMigrationResponse struct { func (x *LaunchSchemaMigrationResponse) Reset() { *x = LaunchSchemaMigrationResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[111] + mi := &file_vtctldata_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7240,7 +7352,7 @@ func (x *LaunchSchemaMigrationResponse) String() string { func (*LaunchSchemaMigrationResponse) ProtoMessage() {} func (x *LaunchSchemaMigrationResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[111] + mi := &file_vtctldata_proto_msgTypes[113] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7253,7 +7365,7 @@ func (x *LaunchSchemaMigrationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LaunchSchemaMigrationResponse.ProtoReflect.Descriptor instead. func (*LaunchSchemaMigrationResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{111} + return file_vtctldata_proto_rawDescGZIP(), []int{113} } func (x *LaunchSchemaMigrationResponse) GetRowsAffectedByShard() map[string]uint64 { @@ -7280,7 +7392,7 @@ type LookupVindexCreateRequest struct { func (x *LookupVindexCreateRequest) Reset() { *x = LookupVindexCreateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[112] + mi := &file_vtctldata_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7293,7 +7405,7 @@ func (x *LookupVindexCreateRequest) String() string { func (*LookupVindexCreateRequest) ProtoMessage() {} func (x *LookupVindexCreateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[112] + mi := &file_vtctldata_proto_msgTypes[114] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7306,7 +7418,7 @@ func (x *LookupVindexCreateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupVindexCreateRequest.ProtoReflect.Descriptor instead. func (*LookupVindexCreateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{112} + return file_vtctldata_proto_rawDescGZIP(), []int{114} } func (x *LookupVindexCreateRequest) GetKeyspace() string { @@ -7367,7 +7479,7 @@ type LookupVindexCreateResponse struct { func (x *LookupVindexCreateResponse) Reset() { *x = LookupVindexCreateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[113] + mi := &file_vtctldata_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7380,7 +7492,7 @@ func (x *LookupVindexCreateResponse) String() string { func (*LookupVindexCreateResponse) ProtoMessage() {} func (x *LookupVindexCreateResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[113] + mi := &file_vtctldata_proto_msgTypes[115] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7393,7 +7505,7 @@ func (x *LookupVindexCreateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupVindexCreateResponse.ProtoReflect.Descriptor instead. func (*LookupVindexCreateResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{113} + return file_vtctldata_proto_rawDescGZIP(), []int{115} } type LookupVindexExternalizeRequest struct { @@ -7412,7 +7524,7 @@ type LookupVindexExternalizeRequest struct { func (x *LookupVindexExternalizeRequest) Reset() { *x = LookupVindexExternalizeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[114] + mi := &file_vtctldata_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7425,7 +7537,7 @@ func (x *LookupVindexExternalizeRequest) String() string { func (*LookupVindexExternalizeRequest) ProtoMessage() {} func (x *LookupVindexExternalizeRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[114] + mi := &file_vtctldata_proto_msgTypes[116] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7438,7 +7550,7 @@ func (x *LookupVindexExternalizeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupVindexExternalizeRequest.ProtoReflect.Descriptor instead. func (*LookupVindexExternalizeRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{114} + return file_vtctldata_proto_rawDescGZIP(), []int{116} } func (x *LookupVindexExternalizeRequest) GetKeyspace() string { @@ -7474,7 +7586,7 @@ type LookupVindexExternalizeResponse struct { func (x *LookupVindexExternalizeResponse) Reset() { *x = LookupVindexExternalizeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[115] + mi := &file_vtctldata_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7487,7 +7599,7 @@ func (x *LookupVindexExternalizeResponse) String() string { func (*LookupVindexExternalizeResponse) ProtoMessage() {} func (x *LookupVindexExternalizeResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[115] + mi := &file_vtctldata_proto_msgTypes[117] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7500,7 +7612,7 @@ func (x *LookupVindexExternalizeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LookupVindexExternalizeResponse.ProtoReflect.Descriptor instead. func (*LookupVindexExternalizeResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{115} + return file_vtctldata_proto_rawDescGZIP(), []int{117} } func (x *LookupVindexExternalizeResponse) GetWorkflowDeleted() bool { @@ -7521,7 +7633,7 @@ type MaterializeCreateRequest struct { func (x *MaterializeCreateRequest) Reset() { *x = MaterializeCreateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[116] + mi := &file_vtctldata_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7534,7 +7646,7 @@ func (x *MaterializeCreateRequest) String() string { func (*MaterializeCreateRequest) ProtoMessage() {} func (x *MaterializeCreateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[116] + mi := &file_vtctldata_proto_msgTypes[118] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7547,7 +7659,7 @@ func (x *MaterializeCreateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MaterializeCreateRequest.ProtoReflect.Descriptor instead. func (*MaterializeCreateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{116} + return file_vtctldata_proto_rawDescGZIP(), []int{118} } func (x *MaterializeCreateRequest) GetSettings() *MaterializeSettings { @@ -7566,7 +7678,7 @@ type MaterializeCreateResponse struct { func (x *MaterializeCreateResponse) Reset() { *x = MaterializeCreateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[117] + mi := &file_vtctldata_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7579,7 +7691,7 @@ func (x *MaterializeCreateResponse) String() string { func (*MaterializeCreateResponse) ProtoMessage() {} func (x *MaterializeCreateResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[117] + mi := &file_vtctldata_proto_msgTypes[119] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7592,7 +7704,7 @@ func (x *MaterializeCreateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MaterializeCreateResponse.ProtoReflect.Descriptor instead. func (*MaterializeCreateResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{117} + return file_vtctldata_proto_rawDescGZIP(), []int{119} } type MigrateCreateRequest struct { @@ -7631,7 +7743,7 @@ type MigrateCreateRequest struct { func (x *MigrateCreateRequest) Reset() { *x = MigrateCreateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[118] + mi := &file_vtctldata_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7644,7 +7756,7 @@ func (x *MigrateCreateRequest) String() string { func (*MigrateCreateRequest) ProtoMessage() {} func (x *MigrateCreateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[118] + mi := &file_vtctldata_proto_msgTypes[120] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7657,7 +7769,7 @@ func (x *MigrateCreateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MigrateCreateRequest.ProtoReflect.Descriptor instead. func (*MigrateCreateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{118} + return file_vtctldata_proto_rawDescGZIP(), []int{120} } func (x *MigrateCreateRequest) GetWorkflow() string { @@ -7795,7 +7907,7 @@ type MigrateCompleteRequest struct { func (x *MigrateCompleteRequest) Reset() { *x = MigrateCompleteRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[119] + mi := &file_vtctldata_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7808,7 +7920,7 @@ func (x *MigrateCompleteRequest) String() string { func (*MigrateCompleteRequest) ProtoMessage() {} func (x *MigrateCompleteRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[119] + mi := &file_vtctldata_proto_msgTypes[121] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7821,7 +7933,7 @@ func (x *MigrateCompleteRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MigrateCompleteRequest.ProtoReflect.Descriptor instead. func (*MigrateCompleteRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{119} + return file_vtctldata_proto_rawDescGZIP(), []int{121} } func (x *MigrateCompleteRequest) GetWorkflow() string { @@ -7878,7 +7990,7 @@ type MigrateCompleteResponse struct { func (x *MigrateCompleteResponse) Reset() { *x = MigrateCompleteResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[120] + mi := &file_vtctldata_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7891,7 +8003,7 @@ func (x *MigrateCompleteResponse) String() string { func (*MigrateCompleteResponse) ProtoMessage() {} func (x *MigrateCompleteResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[120] + mi := &file_vtctldata_proto_msgTypes[122] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7904,7 +8016,7 @@ func (x *MigrateCompleteResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MigrateCompleteResponse.ProtoReflect.Descriptor instead. func (*MigrateCompleteResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{120} + return file_vtctldata_proto_rawDescGZIP(), []int{122} } func (x *MigrateCompleteResponse) GetSummary() string { @@ -7935,7 +8047,7 @@ type MountRegisterRequest struct { func (x *MountRegisterRequest) Reset() { *x = MountRegisterRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[121] + mi := &file_vtctldata_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7948,7 +8060,7 @@ func (x *MountRegisterRequest) String() string { func (*MountRegisterRequest) ProtoMessage() {} func (x *MountRegisterRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[121] + mi := &file_vtctldata_proto_msgTypes[123] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7961,7 +8073,7 @@ func (x *MountRegisterRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MountRegisterRequest.ProtoReflect.Descriptor instead. func (*MountRegisterRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{121} + return file_vtctldata_proto_rawDescGZIP(), []int{123} } func (x *MountRegisterRequest) GetTopoType() string { @@ -8001,7 +8113,7 @@ type MountRegisterResponse struct { func (x *MountRegisterResponse) Reset() { *x = MountRegisterResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[122] + mi := &file_vtctldata_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8014,7 +8126,7 @@ func (x *MountRegisterResponse) String() string { func (*MountRegisterResponse) ProtoMessage() {} func (x *MountRegisterResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[122] + mi := &file_vtctldata_proto_msgTypes[124] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8027,7 +8139,7 @@ func (x *MountRegisterResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MountRegisterResponse.ProtoReflect.Descriptor instead. func (*MountRegisterResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{122} + return file_vtctldata_proto_rawDescGZIP(), []int{124} } type MountUnregisterRequest struct { @@ -8041,7 +8153,7 @@ type MountUnregisterRequest struct { func (x *MountUnregisterRequest) Reset() { *x = MountUnregisterRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[123] + mi := &file_vtctldata_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8054,7 +8166,7 @@ func (x *MountUnregisterRequest) String() string { func (*MountUnregisterRequest) ProtoMessage() {} func (x *MountUnregisterRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[123] + mi := &file_vtctldata_proto_msgTypes[125] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8067,7 +8179,7 @@ func (x *MountUnregisterRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MountUnregisterRequest.ProtoReflect.Descriptor instead. func (*MountUnregisterRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{123} + return file_vtctldata_proto_rawDescGZIP(), []int{125} } func (x *MountUnregisterRequest) GetName() string { @@ -8086,7 +8198,7 @@ type MountUnregisterResponse struct { func (x *MountUnregisterResponse) Reset() { *x = MountUnregisterResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[124] + mi := &file_vtctldata_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8099,7 +8211,7 @@ func (x *MountUnregisterResponse) String() string { func (*MountUnregisterResponse) ProtoMessage() {} func (x *MountUnregisterResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[124] + mi := &file_vtctldata_proto_msgTypes[126] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8112,7 +8224,7 @@ func (x *MountUnregisterResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MountUnregisterResponse.ProtoReflect.Descriptor instead. func (*MountUnregisterResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{124} + return file_vtctldata_proto_rawDescGZIP(), []int{126} } type MountShowRequest struct { @@ -8126,7 +8238,7 @@ type MountShowRequest struct { func (x *MountShowRequest) Reset() { *x = MountShowRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[125] + mi := &file_vtctldata_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8139,7 +8251,7 @@ func (x *MountShowRequest) String() string { func (*MountShowRequest) ProtoMessage() {} func (x *MountShowRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[125] + mi := &file_vtctldata_proto_msgTypes[127] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8152,7 +8264,7 @@ func (x *MountShowRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MountShowRequest.ProtoReflect.Descriptor instead. func (*MountShowRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{125} + return file_vtctldata_proto_rawDescGZIP(), []int{127} } func (x *MountShowRequest) GetName() string { @@ -8176,7 +8288,7 @@ type MountShowResponse struct { func (x *MountShowResponse) Reset() { *x = MountShowResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[126] + mi := &file_vtctldata_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8189,7 +8301,7 @@ func (x *MountShowResponse) String() string { func (*MountShowResponse) ProtoMessage() {} func (x *MountShowResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[126] + mi := &file_vtctldata_proto_msgTypes[128] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8202,7 +8314,7 @@ func (x *MountShowResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MountShowResponse.ProtoReflect.Descriptor instead. func (*MountShowResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{126} + return file_vtctldata_proto_rawDescGZIP(), []int{128} } func (x *MountShowResponse) GetTopoType() string { @@ -8242,7 +8354,7 @@ type MountListRequest struct { func (x *MountListRequest) Reset() { *x = MountListRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[127] + mi := &file_vtctldata_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8255,7 +8367,7 @@ func (x *MountListRequest) String() string { func (*MountListRequest) ProtoMessage() {} func (x *MountListRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[127] + mi := &file_vtctldata_proto_msgTypes[129] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8268,7 +8380,7 @@ func (x *MountListRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MountListRequest.ProtoReflect.Descriptor instead. func (*MountListRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{127} + return file_vtctldata_proto_rawDescGZIP(), []int{129} } type MountListResponse struct { @@ -8282,7 +8394,7 @@ type MountListResponse struct { func (x *MountListResponse) Reset() { *x = MountListResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[128] + mi := &file_vtctldata_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8295,7 +8407,7 @@ func (x *MountListResponse) String() string { func (*MountListResponse) ProtoMessage() {} func (x *MountListResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[128] + mi := &file_vtctldata_proto_msgTypes[130] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8308,7 +8420,7 @@ func (x *MountListResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MountListResponse.ProtoReflect.Descriptor instead. func (*MountListResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{128} + return file_vtctldata_proto_rawDescGZIP(), []int{130} } func (x *MountListResponse) GetNames() []string { @@ -8358,7 +8470,7 @@ type MoveTablesCreateRequest struct { func (x *MoveTablesCreateRequest) Reset() { *x = MoveTablesCreateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[129] + mi := &file_vtctldata_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8371,7 +8483,7 @@ func (x *MoveTablesCreateRequest) String() string { func (*MoveTablesCreateRequest) ProtoMessage() {} func (x *MoveTablesCreateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[129] + mi := &file_vtctldata_proto_msgTypes[131] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8384,7 +8496,7 @@ func (x *MoveTablesCreateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MoveTablesCreateRequest.ProtoReflect.Descriptor instead. func (*MoveTablesCreateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{129} + return file_vtctldata_proto_rawDescGZIP(), []int{131} } func (x *MoveTablesCreateRequest) GetWorkflow() string { @@ -8532,7 +8644,7 @@ type MoveTablesCreateResponse struct { func (x *MoveTablesCreateResponse) Reset() { *x = MoveTablesCreateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[130] + mi := &file_vtctldata_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8545,7 +8657,7 @@ func (x *MoveTablesCreateResponse) String() string { func (*MoveTablesCreateResponse) ProtoMessage() {} func (x *MoveTablesCreateResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[130] + mi := &file_vtctldata_proto_msgTypes[132] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8558,7 +8670,7 @@ func (x *MoveTablesCreateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MoveTablesCreateResponse.ProtoReflect.Descriptor instead. func (*MoveTablesCreateResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{130} + return file_vtctldata_proto_rawDescGZIP(), []int{132} } func (x *MoveTablesCreateResponse) GetSummary() string { @@ -8592,7 +8704,7 @@ type MoveTablesCompleteRequest struct { func (x *MoveTablesCompleteRequest) Reset() { *x = MoveTablesCompleteRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[131] + mi := &file_vtctldata_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8605,7 +8717,7 @@ func (x *MoveTablesCompleteRequest) String() string { func (*MoveTablesCompleteRequest) ProtoMessage() {} func (x *MoveTablesCompleteRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[131] + mi := &file_vtctldata_proto_msgTypes[133] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8618,7 +8730,7 @@ func (x *MoveTablesCompleteRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MoveTablesCompleteRequest.ProtoReflect.Descriptor instead. func (*MoveTablesCompleteRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{131} + return file_vtctldata_proto_rawDescGZIP(), []int{133} } func (x *MoveTablesCompleteRequest) GetWorkflow() string { @@ -8682,7 +8794,7 @@ type MoveTablesCompleteResponse struct { func (x *MoveTablesCompleteResponse) Reset() { *x = MoveTablesCompleteResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[132] + mi := &file_vtctldata_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8695,7 +8807,7 @@ func (x *MoveTablesCompleteResponse) String() string { func (*MoveTablesCompleteResponse) ProtoMessage() {} func (x *MoveTablesCompleteResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[132] + mi := &file_vtctldata_proto_msgTypes[134] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8708,7 +8820,7 @@ func (x *MoveTablesCompleteResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MoveTablesCompleteResponse.ProtoReflect.Descriptor instead. func (*MoveTablesCompleteResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{132} + return file_vtctldata_proto_rawDescGZIP(), []int{134} } func (x *MoveTablesCompleteResponse) GetSummary() string { @@ -8736,7 +8848,7 @@ type PingTabletRequest struct { func (x *PingTabletRequest) Reset() { *x = PingTabletRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[133] + mi := &file_vtctldata_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8749,7 +8861,7 @@ func (x *PingTabletRequest) String() string { func (*PingTabletRequest) ProtoMessage() {} func (x *PingTabletRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[133] + mi := &file_vtctldata_proto_msgTypes[135] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8762,7 +8874,7 @@ func (x *PingTabletRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PingTabletRequest.ProtoReflect.Descriptor instead. func (*PingTabletRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{133} + return file_vtctldata_proto_rawDescGZIP(), []int{135} } func (x *PingTabletRequest) GetTabletAlias() *topodata.TabletAlias { @@ -8781,7 +8893,7 @@ type PingTabletResponse struct { func (x *PingTabletResponse) Reset() { *x = PingTabletResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[134] + mi := &file_vtctldata_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8794,7 +8906,7 @@ func (x *PingTabletResponse) String() string { func (*PingTabletResponse) ProtoMessage() {} func (x *PingTabletResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[134] + mi := &file_vtctldata_proto_msgTypes[136] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8807,7 +8919,7 @@ func (x *PingTabletResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PingTabletResponse.ProtoReflect.Descriptor instead. func (*PingTabletResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{134} + return file_vtctldata_proto_rawDescGZIP(), []int{136} } type PlannedReparentShardRequest struct { @@ -8846,7 +8958,7 @@ type PlannedReparentShardRequest struct { func (x *PlannedReparentShardRequest) Reset() { *x = PlannedReparentShardRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[135] + mi := &file_vtctldata_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8859,7 +8971,7 @@ func (x *PlannedReparentShardRequest) String() string { func (*PlannedReparentShardRequest) ProtoMessage() {} func (x *PlannedReparentShardRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[135] + mi := &file_vtctldata_proto_msgTypes[137] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8872,7 +8984,7 @@ func (x *PlannedReparentShardRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PlannedReparentShardRequest.ProtoReflect.Descriptor instead. func (*PlannedReparentShardRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{135} + return file_vtctldata_proto_rawDescGZIP(), []int{137} } func (x *PlannedReparentShardRequest) GetKeyspace() string { @@ -8937,7 +9049,7 @@ type PlannedReparentShardResponse struct { func (x *PlannedReparentShardResponse) Reset() { *x = PlannedReparentShardResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[136] + mi := &file_vtctldata_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8950,7 +9062,7 @@ func (x *PlannedReparentShardResponse) String() string { func (*PlannedReparentShardResponse) ProtoMessage() {} func (x *PlannedReparentShardResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[136] + mi := &file_vtctldata_proto_msgTypes[138] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8963,7 +9075,7 @@ func (x *PlannedReparentShardResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PlannedReparentShardResponse.ProtoReflect.Descriptor instead. func (*PlannedReparentShardResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{136} + return file_vtctldata_proto_rawDescGZIP(), []int{138} } func (x *PlannedReparentShardResponse) GetKeyspace() string { @@ -9009,7 +9121,7 @@ type RebuildKeyspaceGraphRequest struct { func (x *RebuildKeyspaceGraphRequest) Reset() { *x = RebuildKeyspaceGraphRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[137] + mi := &file_vtctldata_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9022,7 +9134,7 @@ func (x *RebuildKeyspaceGraphRequest) String() string { func (*RebuildKeyspaceGraphRequest) ProtoMessage() {} func (x *RebuildKeyspaceGraphRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[137] + mi := &file_vtctldata_proto_msgTypes[139] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9035,7 +9147,7 @@ func (x *RebuildKeyspaceGraphRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RebuildKeyspaceGraphRequest.ProtoReflect.Descriptor instead. func (*RebuildKeyspaceGraphRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{137} + return file_vtctldata_proto_rawDescGZIP(), []int{139} } func (x *RebuildKeyspaceGraphRequest) GetKeyspace() string { @@ -9068,7 +9180,7 @@ type RebuildKeyspaceGraphResponse struct { func (x *RebuildKeyspaceGraphResponse) Reset() { *x = RebuildKeyspaceGraphResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[138] + mi := &file_vtctldata_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9081,7 +9193,7 @@ func (x *RebuildKeyspaceGraphResponse) String() string { func (*RebuildKeyspaceGraphResponse) ProtoMessage() {} func (x *RebuildKeyspaceGraphResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[138] + mi := &file_vtctldata_proto_msgTypes[140] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9094,7 +9206,7 @@ func (x *RebuildKeyspaceGraphResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RebuildKeyspaceGraphResponse.ProtoReflect.Descriptor instead. func (*RebuildKeyspaceGraphResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{138} + return file_vtctldata_proto_rawDescGZIP(), []int{140} } type RebuildVSchemaGraphRequest struct { @@ -9110,7 +9222,7 @@ type RebuildVSchemaGraphRequest struct { func (x *RebuildVSchemaGraphRequest) Reset() { *x = RebuildVSchemaGraphRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[139] + mi := &file_vtctldata_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9123,7 +9235,7 @@ func (x *RebuildVSchemaGraphRequest) String() string { func (*RebuildVSchemaGraphRequest) ProtoMessage() {} func (x *RebuildVSchemaGraphRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[139] + mi := &file_vtctldata_proto_msgTypes[141] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9136,7 +9248,7 @@ func (x *RebuildVSchemaGraphRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RebuildVSchemaGraphRequest.ProtoReflect.Descriptor instead. func (*RebuildVSchemaGraphRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{139} + return file_vtctldata_proto_rawDescGZIP(), []int{141} } func (x *RebuildVSchemaGraphRequest) GetCells() []string { @@ -9155,7 +9267,7 @@ type RebuildVSchemaGraphResponse struct { func (x *RebuildVSchemaGraphResponse) Reset() { *x = RebuildVSchemaGraphResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[140] + mi := &file_vtctldata_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9168,7 +9280,7 @@ func (x *RebuildVSchemaGraphResponse) String() string { func (*RebuildVSchemaGraphResponse) ProtoMessage() {} func (x *RebuildVSchemaGraphResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[140] + mi := &file_vtctldata_proto_msgTypes[142] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9181,7 +9293,7 @@ func (x *RebuildVSchemaGraphResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RebuildVSchemaGraphResponse.ProtoReflect.Descriptor instead. func (*RebuildVSchemaGraphResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{140} + return file_vtctldata_proto_rawDescGZIP(), []int{142} } type RefreshStateRequest struct { @@ -9195,7 +9307,7 @@ type RefreshStateRequest struct { func (x *RefreshStateRequest) Reset() { *x = RefreshStateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[141] + mi := &file_vtctldata_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9208,7 +9320,7 @@ func (x *RefreshStateRequest) String() string { func (*RefreshStateRequest) ProtoMessage() {} func (x *RefreshStateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[141] + mi := &file_vtctldata_proto_msgTypes[143] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9221,7 +9333,7 @@ func (x *RefreshStateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RefreshStateRequest.ProtoReflect.Descriptor instead. func (*RefreshStateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{141} + return file_vtctldata_proto_rawDescGZIP(), []int{143} } func (x *RefreshStateRequest) GetTabletAlias() *topodata.TabletAlias { @@ -9240,7 +9352,7 @@ type RefreshStateResponse struct { func (x *RefreshStateResponse) Reset() { *x = RefreshStateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[142] + mi := &file_vtctldata_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9253,7 +9365,7 @@ func (x *RefreshStateResponse) String() string { func (*RefreshStateResponse) ProtoMessage() {} func (x *RefreshStateResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[142] + mi := &file_vtctldata_proto_msgTypes[144] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9266,7 +9378,7 @@ func (x *RefreshStateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RefreshStateResponse.ProtoReflect.Descriptor instead. func (*RefreshStateResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{142} + return file_vtctldata_proto_rawDescGZIP(), []int{144} } type RefreshStateByShardRequest struct { @@ -9282,7 +9394,7 @@ type RefreshStateByShardRequest struct { func (x *RefreshStateByShardRequest) Reset() { *x = RefreshStateByShardRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[143] + mi := &file_vtctldata_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9295,7 +9407,7 @@ func (x *RefreshStateByShardRequest) String() string { func (*RefreshStateByShardRequest) ProtoMessage() {} func (x *RefreshStateByShardRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[143] + mi := &file_vtctldata_proto_msgTypes[145] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9308,7 +9420,7 @@ func (x *RefreshStateByShardRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RefreshStateByShardRequest.ProtoReflect.Descriptor instead. func (*RefreshStateByShardRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{143} + return file_vtctldata_proto_rawDescGZIP(), []int{145} } func (x *RefreshStateByShardRequest) GetKeyspace() string { @@ -9345,7 +9457,7 @@ type RefreshStateByShardResponse struct { func (x *RefreshStateByShardResponse) Reset() { *x = RefreshStateByShardResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[144] + mi := &file_vtctldata_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9358,7 +9470,7 @@ func (x *RefreshStateByShardResponse) String() string { func (*RefreshStateByShardResponse) ProtoMessage() {} func (x *RefreshStateByShardResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[144] + mi := &file_vtctldata_proto_msgTypes[146] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9371,7 +9483,7 @@ func (x *RefreshStateByShardResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RefreshStateByShardResponse.ProtoReflect.Descriptor instead. func (*RefreshStateByShardResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{144} + return file_vtctldata_proto_rawDescGZIP(), []int{146} } func (x *RefreshStateByShardResponse) GetIsPartialRefresh() bool { @@ -9399,7 +9511,7 @@ type ReloadSchemaRequest struct { func (x *ReloadSchemaRequest) Reset() { *x = ReloadSchemaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[145] + mi := &file_vtctldata_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9412,7 +9524,7 @@ func (x *ReloadSchemaRequest) String() string { func (*ReloadSchemaRequest) ProtoMessage() {} func (x *ReloadSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[145] + mi := &file_vtctldata_proto_msgTypes[147] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9425,7 +9537,7 @@ func (x *ReloadSchemaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReloadSchemaRequest.ProtoReflect.Descriptor instead. func (*ReloadSchemaRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{145} + return file_vtctldata_proto_rawDescGZIP(), []int{147} } func (x *ReloadSchemaRequest) GetTabletAlias() *topodata.TabletAlias { @@ -9444,7 +9556,7 @@ type ReloadSchemaResponse struct { func (x *ReloadSchemaResponse) Reset() { *x = ReloadSchemaResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[146] + mi := &file_vtctldata_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9457,7 +9569,7 @@ func (x *ReloadSchemaResponse) String() string { func (*ReloadSchemaResponse) ProtoMessage() {} func (x *ReloadSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[146] + mi := &file_vtctldata_proto_msgTypes[148] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9470,7 +9582,7 @@ func (x *ReloadSchemaResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReloadSchemaResponse.ProtoReflect.Descriptor instead. func (*ReloadSchemaResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{146} + return file_vtctldata_proto_rawDescGZIP(), []int{148} } type ReloadSchemaKeyspaceRequest struct { @@ -9490,7 +9602,7 @@ type ReloadSchemaKeyspaceRequest struct { func (x *ReloadSchemaKeyspaceRequest) Reset() { *x = ReloadSchemaKeyspaceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[147] + mi := &file_vtctldata_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9503,7 +9615,7 @@ func (x *ReloadSchemaKeyspaceRequest) String() string { func (*ReloadSchemaKeyspaceRequest) ProtoMessage() {} func (x *ReloadSchemaKeyspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[147] + mi := &file_vtctldata_proto_msgTypes[149] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9516,7 +9628,7 @@ func (x *ReloadSchemaKeyspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReloadSchemaKeyspaceRequest.ProtoReflect.Descriptor instead. func (*ReloadSchemaKeyspaceRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{147} + return file_vtctldata_proto_rawDescGZIP(), []int{149} } func (x *ReloadSchemaKeyspaceRequest) GetKeyspace() string { @@ -9558,7 +9670,7 @@ type ReloadSchemaKeyspaceResponse struct { func (x *ReloadSchemaKeyspaceResponse) Reset() { *x = ReloadSchemaKeyspaceResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[148] + mi := &file_vtctldata_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9571,7 +9683,7 @@ func (x *ReloadSchemaKeyspaceResponse) String() string { func (*ReloadSchemaKeyspaceResponse) ProtoMessage() {} func (x *ReloadSchemaKeyspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[148] + mi := &file_vtctldata_proto_msgTypes[150] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9584,7 +9696,7 @@ func (x *ReloadSchemaKeyspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReloadSchemaKeyspaceResponse.ProtoReflect.Descriptor instead. func (*ReloadSchemaKeyspaceResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{148} + return file_vtctldata_proto_rawDescGZIP(), []int{150} } func (x *ReloadSchemaKeyspaceResponse) GetEvents() []*logutil.Event { @@ -9610,7 +9722,7 @@ type ReloadSchemaShardRequest struct { func (x *ReloadSchemaShardRequest) Reset() { *x = ReloadSchemaShardRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[149] + mi := &file_vtctldata_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9623,7 +9735,7 @@ func (x *ReloadSchemaShardRequest) String() string { func (*ReloadSchemaShardRequest) ProtoMessage() {} func (x *ReloadSchemaShardRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[149] + mi := &file_vtctldata_proto_msgTypes[151] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9636,7 +9748,7 @@ func (x *ReloadSchemaShardRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReloadSchemaShardRequest.ProtoReflect.Descriptor instead. func (*ReloadSchemaShardRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{149} + return file_vtctldata_proto_rawDescGZIP(), []int{151} } func (x *ReloadSchemaShardRequest) GetKeyspace() string { @@ -9685,7 +9797,7 @@ type ReloadSchemaShardResponse struct { func (x *ReloadSchemaShardResponse) Reset() { *x = ReloadSchemaShardResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[150] + mi := &file_vtctldata_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9698,7 +9810,7 @@ func (x *ReloadSchemaShardResponse) String() string { func (*ReloadSchemaShardResponse) ProtoMessage() {} func (x *ReloadSchemaShardResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[150] + mi := &file_vtctldata_proto_msgTypes[152] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9711,7 +9823,7 @@ func (x *ReloadSchemaShardResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReloadSchemaShardResponse.ProtoReflect.Descriptor instead. func (*ReloadSchemaShardResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{150} + return file_vtctldata_proto_rawDescGZIP(), []int{152} } func (x *ReloadSchemaShardResponse) GetEvents() []*logutil.Event { @@ -9734,7 +9846,7 @@ type RemoveBackupRequest struct { func (x *RemoveBackupRequest) Reset() { *x = RemoveBackupRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[151] + mi := &file_vtctldata_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9747,7 +9859,7 @@ func (x *RemoveBackupRequest) String() string { func (*RemoveBackupRequest) ProtoMessage() {} func (x *RemoveBackupRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[151] + mi := &file_vtctldata_proto_msgTypes[153] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9760,7 +9872,7 @@ func (x *RemoveBackupRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveBackupRequest.ProtoReflect.Descriptor instead. func (*RemoveBackupRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{151} + return file_vtctldata_proto_rawDescGZIP(), []int{153} } func (x *RemoveBackupRequest) GetKeyspace() string { @@ -9793,7 +9905,7 @@ type RemoveBackupResponse struct { func (x *RemoveBackupResponse) Reset() { *x = RemoveBackupResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[152] + mi := &file_vtctldata_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9806,7 +9918,7 @@ func (x *RemoveBackupResponse) String() string { func (*RemoveBackupResponse) ProtoMessage() {} func (x *RemoveBackupResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[152] + mi := &file_vtctldata_proto_msgTypes[154] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9819,7 +9931,7 @@ func (x *RemoveBackupResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveBackupResponse.ProtoReflect.Descriptor instead. func (*RemoveBackupResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{152} + return file_vtctldata_proto_rawDescGZIP(), []int{154} } type RemoveKeyspaceCellRequest struct { @@ -9841,7 +9953,7 @@ type RemoveKeyspaceCellRequest struct { func (x *RemoveKeyspaceCellRequest) Reset() { *x = RemoveKeyspaceCellRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[153] + mi := &file_vtctldata_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9854,7 +9966,7 @@ func (x *RemoveKeyspaceCellRequest) String() string { func (*RemoveKeyspaceCellRequest) ProtoMessage() {} func (x *RemoveKeyspaceCellRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[153] + mi := &file_vtctldata_proto_msgTypes[155] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9867,7 +9979,7 @@ func (x *RemoveKeyspaceCellRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveKeyspaceCellRequest.ProtoReflect.Descriptor instead. func (*RemoveKeyspaceCellRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{153} + return file_vtctldata_proto_rawDescGZIP(), []int{155} } func (x *RemoveKeyspaceCellRequest) GetKeyspace() string { @@ -9907,7 +10019,7 @@ type RemoveKeyspaceCellResponse struct { func (x *RemoveKeyspaceCellResponse) Reset() { *x = RemoveKeyspaceCellResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[154] + mi := &file_vtctldata_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9920,7 +10032,7 @@ func (x *RemoveKeyspaceCellResponse) String() string { func (*RemoveKeyspaceCellResponse) ProtoMessage() {} func (x *RemoveKeyspaceCellResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[154] + mi := &file_vtctldata_proto_msgTypes[156] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9933,7 +10045,7 @@ func (x *RemoveKeyspaceCellResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveKeyspaceCellResponse.ProtoReflect.Descriptor instead. func (*RemoveKeyspaceCellResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{154} + return file_vtctldata_proto_rawDescGZIP(), []int{156} } type RemoveShardCellRequest struct { @@ -9956,7 +10068,7 @@ type RemoveShardCellRequest struct { func (x *RemoveShardCellRequest) Reset() { *x = RemoveShardCellRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[155] + mi := &file_vtctldata_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9969,7 +10081,7 @@ func (x *RemoveShardCellRequest) String() string { func (*RemoveShardCellRequest) ProtoMessage() {} func (x *RemoveShardCellRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[155] + mi := &file_vtctldata_proto_msgTypes[157] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9982,7 +10094,7 @@ func (x *RemoveShardCellRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveShardCellRequest.ProtoReflect.Descriptor instead. func (*RemoveShardCellRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{155} + return file_vtctldata_proto_rawDescGZIP(), []int{157} } func (x *RemoveShardCellRequest) GetKeyspace() string { @@ -10029,7 +10141,7 @@ type RemoveShardCellResponse struct { func (x *RemoveShardCellResponse) Reset() { *x = RemoveShardCellResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[156] + mi := &file_vtctldata_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10042,7 +10154,7 @@ func (x *RemoveShardCellResponse) String() string { func (*RemoveShardCellResponse) ProtoMessage() {} func (x *RemoveShardCellResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[156] + mi := &file_vtctldata_proto_msgTypes[158] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10055,7 +10167,7 @@ func (x *RemoveShardCellResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveShardCellResponse.ProtoReflect.Descriptor instead. func (*RemoveShardCellResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{156} + return file_vtctldata_proto_rawDescGZIP(), []int{158} } type ReparentTabletRequest struct { @@ -10071,7 +10183,7 @@ type ReparentTabletRequest struct { func (x *ReparentTabletRequest) Reset() { *x = ReparentTabletRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[157] + mi := &file_vtctldata_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10084,7 +10196,7 @@ func (x *ReparentTabletRequest) String() string { func (*ReparentTabletRequest) ProtoMessage() {} func (x *ReparentTabletRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[157] + mi := &file_vtctldata_proto_msgTypes[159] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10097,7 +10209,7 @@ func (x *ReparentTabletRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReparentTabletRequest.ProtoReflect.Descriptor instead. func (*ReparentTabletRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{157} + return file_vtctldata_proto_rawDescGZIP(), []int{159} } func (x *ReparentTabletRequest) GetTablet() *topodata.TabletAlias { @@ -10123,7 +10235,7 @@ type ReparentTabletResponse struct { func (x *ReparentTabletResponse) Reset() { *x = ReparentTabletResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[158] + mi := &file_vtctldata_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10136,7 +10248,7 @@ func (x *ReparentTabletResponse) String() string { func (*ReparentTabletResponse) ProtoMessage() {} func (x *ReparentTabletResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[158] + mi := &file_vtctldata_proto_msgTypes[160] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10149,7 +10261,7 @@ func (x *ReparentTabletResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReparentTabletResponse.ProtoReflect.Descriptor instead. func (*ReparentTabletResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{158} + return file_vtctldata_proto_rawDescGZIP(), []int{160} } func (x *ReparentTabletResponse) GetKeyspace() string { @@ -10201,7 +10313,7 @@ type ReshardCreateRequest struct { func (x *ReshardCreateRequest) Reset() { *x = ReshardCreateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[159] + mi := &file_vtctldata_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10214,7 +10326,7 @@ func (x *ReshardCreateRequest) String() string { func (*ReshardCreateRequest) ProtoMessage() {} func (x *ReshardCreateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[159] + mi := &file_vtctldata_proto_msgTypes[161] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10227,7 +10339,7 @@ func (x *ReshardCreateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReshardCreateRequest.ProtoReflect.Descriptor instead. func (*ReshardCreateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{159} + return file_vtctldata_proto_rawDescGZIP(), []int{161} } func (x *ReshardCreateRequest) GetWorkflow() string { @@ -10337,7 +10449,7 @@ type RestoreFromBackupRequest struct { func (x *RestoreFromBackupRequest) Reset() { *x = RestoreFromBackupRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[160] + mi := &file_vtctldata_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10350,7 +10462,7 @@ func (x *RestoreFromBackupRequest) String() string { func (*RestoreFromBackupRequest) ProtoMessage() {} func (x *RestoreFromBackupRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[160] + mi := &file_vtctldata_proto_msgTypes[162] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10363,7 +10475,7 @@ func (x *RestoreFromBackupRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RestoreFromBackupRequest.ProtoReflect.Descriptor instead. func (*RestoreFromBackupRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{160} + return file_vtctldata_proto_rawDescGZIP(), []int{162} } func (x *RestoreFromBackupRequest) GetTabletAlias() *topodata.TabletAlias { @@ -10416,7 +10528,7 @@ type RestoreFromBackupResponse struct { func (x *RestoreFromBackupResponse) Reset() { *x = RestoreFromBackupResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[161] + mi := &file_vtctldata_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10429,7 +10541,7 @@ func (x *RestoreFromBackupResponse) String() string { func (*RestoreFromBackupResponse) ProtoMessage() {} func (x *RestoreFromBackupResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[161] + mi := &file_vtctldata_proto_msgTypes[163] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10442,7 +10554,7 @@ func (x *RestoreFromBackupResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RestoreFromBackupResponse.ProtoReflect.Descriptor instead. func (*RestoreFromBackupResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{161} + return file_vtctldata_proto_rawDescGZIP(), []int{163} } func (x *RestoreFromBackupResponse) GetTabletAlias() *topodata.TabletAlias { @@ -10485,7 +10597,7 @@ type RetrySchemaMigrationRequest struct { func (x *RetrySchemaMigrationRequest) Reset() { *x = RetrySchemaMigrationRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[162] + mi := &file_vtctldata_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10498,7 +10610,7 @@ func (x *RetrySchemaMigrationRequest) String() string { func (*RetrySchemaMigrationRequest) ProtoMessage() {} func (x *RetrySchemaMigrationRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[162] + mi := &file_vtctldata_proto_msgTypes[164] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10511,7 +10623,7 @@ func (x *RetrySchemaMigrationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RetrySchemaMigrationRequest.ProtoReflect.Descriptor instead. func (*RetrySchemaMigrationRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{162} + return file_vtctldata_proto_rawDescGZIP(), []int{164} } func (x *RetrySchemaMigrationRequest) GetKeyspace() string { @@ -10539,7 +10651,7 @@ type RetrySchemaMigrationResponse struct { func (x *RetrySchemaMigrationResponse) Reset() { *x = RetrySchemaMigrationResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[163] + mi := &file_vtctldata_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10552,7 +10664,7 @@ func (x *RetrySchemaMigrationResponse) String() string { func (*RetrySchemaMigrationResponse) ProtoMessage() {} func (x *RetrySchemaMigrationResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[163] + mi := &file_vtctldata_proto_msgTypes[165] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10565,7 +10677,7 @@ func (x *RetrySchemaMigrationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RetrySchemaMigrationResponse.ProtoReflect.Descriptor instead. func (*RetrySchemaMigrationResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{163} + return file_vtctldata_proto_rawDescGZIP(), []int{165} } func (x *RetrySchemaMigrationResponse) GetRowsAffectedByShard() map[string]uint64 { @@ -10586,7 +10698,7 @@ type RunHealthCheckRequest struct { func (x *RunHealthCheckRequest) Reset() { *x = RunHealthCheckRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[164] + mi := &file_vtctldata_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10599,7 +10711,7 @@ func (x *RunHealthCheckRequest) String() string { func (*RunHealthCheckRequest) ProtoMessage() {} func (x *RunHealthCheckRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[164] + mi := &file_vtctldata_proto_msgTypes[166] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10612,7 +10724,7 @@ func (x *RunHealthCheckRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RunHealthCheckRequest.ProtoReflect.Descriptor instead. func (*RunHealthCheckRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{164} + return file_vtctldata_proto_rawDescGZIP(), []int{166} } func (x *RunHealthCheckRequest) GetTabletAlias() *topodata.TabletAlias { @@ -10631,7 +10743,7 @@ type RunHealthCheckResponse struct { func (x *RunHealthCheckResponse) Reset() { *x = RunHealthCheckResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[165] + mi := &file_vtctldata_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10644,7 +10756,7 @@ func (x *RunHealthCheckResponse) String() string { func (*RunHealthCheckResponse) ProtoMessage() {} func (x *RunHealthCheckResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[165] + mi := &file_vtctldata_proto_msgTypes[167] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10657,7 +10769,7 @@ func (x *RunHealthCheckResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RunHealthCheckResponse.ProtoReflect.Descriptor instead. func (*RunHealthCheckResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{165} + return file_vtctldata_proto_rawDescGZIP(), []int{167} } type SetKeyspaceDurabilityPolicyRequest struct { @@ -10672,7 +10784,7 @@ type SetKeyspaceDurabilityPolicyRequest struct { func (x *SetKeyspaceDurabilityPolicyRequest) Reset() { *x = SetKeyspaceDurabilityPolicyRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[166] + mi := &file_vtctldata_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10685,7 +10797,7 @@ func (x *SetKeyspaceDurabilityPolicyRequest) String() string { func (*SetKeyspaceDurabilityPolicyRequest) ProtoMessage() {} func (x *SetKeyspaceDurabilityPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[166] + mi := &file_vtctldata_proto_msgTypes[168] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10698,7 +10810,7 @@ func (x *SetKeyspaceDurabilityPolicyRequest) ProtoReflect() protoreflect.Message // Deprecated: Use SetKeyspaceDurabilityPolicyRequest.ProtoReflect.Descriptor instead. func (*SetKeyspaceDurabilityPolicyRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{166} + return file_vtctldata_proto_rawDescGZIP(), []int{168} } func (x *SetKeyspaceDurabilityPolicyRequest) GetKeyspace() string { @@ -10727,7 +10839,7 @@ type SetKeyspaceDurabilityPolicyResponse struct { func (x *SetKeyspaceDurabilityPolicyResponse) Reset() { *x = SetKeyspaceDurabilityPolicyResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[167] + mi := &file_vtctldata_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10740,7 +10852,7 @@ func (x *SetKeyspaceDurabilityPolicyResponse) String() string { func (*SetKeyspaceDurabilityPolicyResponse) ProtoMessage() {} func (x *SetKeyspaceDurabilityPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[167] + mi := &file_vtctldata_proto_msgTypes[169] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10753,7 +10865,7 @@ func (x *SetKeyspaceDurabilityPolicyResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use SetKeyspaceDurabilityPolicyResponse.ProtoReflect.Descriptor instead. func (*SetKeyspaceDurabilityPolicyResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{167} + return file_vtctldata_proto_rawDescGZIP(), []int{169} } func (x *SetKeyspaceDurabilityPolicyResponse) GetKeyspace() *topodata.Keyspace { @@ -10775,7 +10887,7 @@ type SetKeyspaceShardingInfoRequest struct { func (x *SetKeyspaceShardingInfoRequest) Reset() { *x = SetKeyspaceShardingInfoRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[168] + mi := &file_vtctldata_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10788,7 +10900,7 @@ func (x *SetKeyspaceShardingInfoRequest) String() string { func (*SetKeyspaceShardingInfoRequest) ProtoMessage() {} func (x *SetKeyspaceShardingInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[168] + mi := &file_vtctldata_proto_msgTypes[170] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10801,7 +10913,7 @@ func (x *SetKeyspaceShardingInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetKeyspaceShardingInfoRequest.ProtoReflect.Descriptor instead. func (*SetKeyspaceShardingInfoRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{168} + return file_vtctldata_proto_rawDescGZIP(), []int{170} } func (x *SetKeyspaceShardingInfoRequest) GetKeyspace() string { @@ -10830,7 +10942,7 @@ type SetKeyspaceShardingInfoResponse struct { func (x *SetKeyspaceShardingInfoResponse) Reset() { *x = SetKeyspaceShardingInfoResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[169] + mi := &file_vtctldata_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10843,7 +10955,7 @@ func (x *SetKeyspaceShardingInfoResponse) String() string { func (*SetKeyspaceShardingInfoResponse) ProtoMessage() {} func (x *SetKeyspaceShardingInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[169] + mi := &file_vtctldata_proto_msgTypes[171] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10856,7 +10968,7 @@ func (x *SetKeyspaceShardingInfoResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SetKeyspaceShardingInfoResponse.ProtoReflect.Descriptor instead. func (*SetKeyspaceShardingInfoResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{169} + return file_vtctldata_proto_rawDescGZIP(), []int{171} } func (x *SetKeyspaceShardingInfoResponse) GetKeyspace() *topodata.Keyspace { @@ -10879,7 +10991,7 @@ type SetShardIsPrimaryServingRequest struct { func (x *SetShardIsPrimaryServingRequest) Reset() { *x = SetShardIsPrimaryServingRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[170] + mi := &file_vtctldata_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10892,7 +11004,7 @@ func (x *SetShardIsPrimaryServingRequest) String() string { func (*SetShardIsPrimaryServingRequest) ProtoMessage() {} func (x *SetShardIsPrimaryServingRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[170] + mi := &file_vtctldata_proto_msgTypes[172] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10905,7 +11017,7 @@ func (x *SetShardIsPrimaryServingRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetShardIsPrimaryServingRequest.ProtoReflect.Descriptor instead. func (*SetShardIsPrimaryServingRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{170} + return file_vtctldata_proto_rawDescGZIP(), []int{172} } func (x *SetShardIsPrimaryServingRequest) GetKeyspace() string { @@ -10941,7 +11053,7 @@ type SetShardIsPrimaryServingResponse struct { func (x *SetShardIsPrimaryServingResponse) Reset() { *x = SetShardIsPrimaryServingResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[171] + mi := &file_vtctldata_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10954,7 +11066,7 @@ func (x *SetShardIsPrimaryServingResponse) String() string { func (*SetShardIsPrimaryServingResponse) ProtoMessage() {} func (x *SetShardIsPrimaryServingResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[171] + mi := &file_vtctldata_proto_msgTypes[173] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10967,7 +11079,7 @@ func (x *SetShardIsPrimaryServingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SetShardIsPrimaryServingResponse.ProtoReflect.Descriptor instead. func (*SetShardIsPrimaryServingResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{171} + return file_vtctldata_proto_rawDescGZIP(), []int{173} } func (x *SetShardIsPrimaryServingResponse) GetShard() *topodata.Shard { @@ -11008,7 +11120,7 @@ type SetShardTabletControlRequest struct { func (x *SetShardTabletControlRequest) Reset() { *x = SetShardTabletControlRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[172] + mi := &file_vtctldata_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11021,7 +11133,7 @@ func (x *SetShardTabletControlRequest) String() string { func (*SetShardTabletControlRequest) ProtoMessage() {} func (x *SetShardTabletControlRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[172] + mi := &file_vtctldata_proto_msgTypes[174] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11034,7 +11146,7 @@ func (x *SetShardTabletControlRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetShardTabletControlRequest.ProtoReflect.Descriptor instead. func (*SetShardTabletControlRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{172} + return file_vtctldata_proto_rawDescGZIP(), []int{174} } func (x *SetShardTabletControlRequest) GetKeyspace() string { @@ -11098,7 +11210,7 @@ type SetShardTabletControlResponse struct { func (x *SetShardTabletControlResponse) Reset() { *x = SetShardTabletControlResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[173] + mi := &file_vtctldata_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11111,7 +11223,7 @@ func (x *SetShardTabletControlResponse) String() string { func (*SetShardTabletControlResponse) ProtoMessage() {} func (x *SetShardTabletControlResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[173] + mi := &file_vtctldata_proto_msgTypes[175] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11124,7 +11236,7 @@ func (x *SetShardTabletControlResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SetShardTabletControlResponse.ProtoReflect.Descriptor instead. func (*SetShardTabletControlResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{173} + return file_vtctldata_proto_rawDescGZIP(), []int{175} } func (x *SetShardTabletControlResponse) GetShard() *topodata.Shard { @@ -11146,7 +11258,7 @@ type SetWritableRequest struct { func (x *SetWritableRequest) Reset() { *x = SetWritableRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[174] + mi := &file_vtctldata_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11159,7 +11271,7 @@ func (x *SetWritableRequest) String() string { func (*SetWritableRequest) ProtoMessage() {} func (x *SetWritableRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[174] + mi := &file_vtctldata_proto_msgTypes[176] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11172,7 +11284,7 @@ func (x *SetWritableRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetWritableRequest.ProtoReflect.Descriptor instead. func (*SetWritableRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{174} + return file_vtctldata_proto_rawDescGZIP(), []int{176} } func (x *SetWritableRequest) GetTabletAlias() *topodata.TabletAlias { @@ -11198,7 +11310,7 @@ type SetWritableResponse struct { func (x *SetWritableResponse) Reset() { *x = SetWritableResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[175] + mi := &file_vtctldata_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11211,7 +11323,7 @@ func (x *SetWritableResponse) String() string { func (*SetWritableResponse) ProtoMessage() {} func (x *SetWritableResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[175] + mi := &file_vtctldata_proto_msgTypes[177] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11224,7 +11336,7 @@ func (x *SetWritableResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SetWritableResponse.ProtoReflect.Descriptor instead. func (*SetWritableResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{175} + return file_vtctldata_proto_rawDescGZIP(), []int{177} } type ShardReplicationAddRequest struct { @@ -11240,7 +11352,7 @@ type ShardReplicationAddRequest struct { func (x *ShardReplicationAddRequest) Reset() { *x = ShardReplicationAddRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[176] + mi := &file_vtctldata_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11253,7 +11365,7 @@ func (x *ShardReplicationAddRequest) String() string { func (*ShardReplicationAddRequest) ProtoMessage() {} func (x *ShardReplicationAddRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[176] + mi := &file_vtctldata_proto_msgTypes[178] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11266,7 +11378,7 @@ func (x *ShardReplicationAddRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ShardReplicationAddRequest.ProtoReflect.Descriptor instead. func (*ShardReplicationAddRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{176} + return file_vtctldata_proto_rawDescGZIP(), []int{178} } func (x *ShardReplicationAddRequest) GetKeyspace() string { @@ -11299,7 +11411,7 @@ type ShardReplicationAddResponse struct { func (x *ShardReplicationAddResponse) Reset() { *x = ShardReplicationAddResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[177] + mi := &file_vtctldata_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11312,7 +11424,7 @@ func (x *ShardReplicationAddResponse) String() string { func (*ShardReplicationAddResponse) ProtoMessage() {} func (x *ShardReplicationAddResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[177] + mi := &file_vtctldata_proto_msgTypes[179] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11325,7 +11437,7 @@ func (x *ShardReplicationAddResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ShardReplicationAddResponse.ProtoReflect.Descriptor instead. func (*ShardReplicationAddResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{177} + return file_vtctldata_proto_rawDescGZIP(), []int{179} } type ShardReplicationFixRequest struct { @@ -11341,7 +11453,7 @@ type ShardReplicationFixRequest struct { func (x *ShardReplicationFixRequest) Reset() { *x = ShardReplicationFixRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[178] + mi := &file_vtctldata_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11354,7 +11466,7 @@ func (x *ShardReplicationFixRequest) String() string { func (*ShardReplicationFixRequest) ProtoMessage() {} func (x *ShardReplicationFixRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[178] + mi := &file_vtctldata_proto_msgTypes[180] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11367,7 +11479,7 @@ func (x *ShardReplicationFixRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ShardReplicationFixRequest.ProtoReflect.Descriptor instead. func (*ShardReplicationFixRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{178} + return file_vtctldata_proto_rawDescGZIP(), []int{180} } func (x *ShardReplicationFixRequest) GetKeyspace() string { @@ -11405,7 +11517,7 @@ type ShardReplicationFixResponse struct { func (x *ShardReplicationFixResponse) Reset() { *x = ShardReplicationFixResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[179] + mi := &file_vtctldata_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11418,7 +11530,7 @@ func (x *ShardReplicationFixResponse) String() string { func (*ShardReplicationFixResponse) ProtoMessage() {} func (x *ShardReplicationFixResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[179] + mi := &file_vtctldata_proto_msgTypes[181] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11431,7 +11543,7 @@ func (x *ShardReplicationFixResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ShardReplicationFixResponse.ProtoReflect.Descriptor instead. func (*ShardReplicationFixResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{179} + return file_vtctldata_proto_rawDescGZIP(), []int{181} } func (x *ShardReplicationFixResponse) GetError() *topodata.ShardReplicationError { @@ -11453,7 +11565,7 @@ type ShardReplicationPositionsRequest struct { func (x *ShardReplicationPositionsRequest) Reset() { *x = ShardReplicationPositionsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[180] + mi := &file_vtctldata_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11466,7 +11578,7 @@ func (x *ShardReplicationPositionsRequest) String() string { func (*ShardReplicationPositionsRequest) ProtoMessage() {} func (x *ShardReplicationPositionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[180] + mi := &file_vtctldata_proto_msgTypes[182] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11479,7 +11591,7 @@ func (x *ShardReplicationPositionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ShardReplicationPositionsRequest.ProtoReflect.Descriptor instead. func (*ShardReplicationPositionsRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{180} + return file_vtctldata_proto_rawDescGZIP(), []int{182} } func (x *ShardReplicationPositionsRequest) GetKeyspace() string { @@ -11512,7 +11624,7 @@ type ShardReplicationPositionsResponse struct { func (x *ShardReplicationPositionsResponse) Reset() { *x = ShardReplicationPositionsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[181] + mi := &file_vtctldata_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11525,7 +11637,7 @@ func (x *ShardReplicationPositionsResponse) String() string { func (*ShardReplicationPositionsResponse) ProtoMessage() {} func (x *ShardReplicationPositionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[181] + mi := &file_vtctldata_proto_msgTypes[183] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11538,7 +11650,7 @@ func (x *ShardReplicationPositionsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use ShardReplicationPositionsResponse.ProtoReflect.Descriptor instead. func (*ShardReplicationPositionsResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{181} + return file_vtctldata_proto_rawDescGZIP(), []int{183} } func (x *ShardReplicationPositionsResponse) GetReplicationStatuses() map[string]*replicationdata.Status { @@ -11568,7 +11680,7 @@ type ShardReplicationRemoveRequest struct { func (x *ShardReplicationRemoveRequest) Reset() { *x = ShardReplicationRemoveRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[182] + mi := &file_vtctldata_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11581,7 +11693,7 @@ func (x *ShardReplicationRemoveRequest) String() string { func (*ShardReplicationRemoveRequest) ProtoMessage() {} func (x *ShardReplicationRemoveRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[182] + mi := &file_vtctldata_proto_msgTypes[184] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11594,7 +11706,7 @@ func (x *ShardReplicationRemoveRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ShardReplicationRemoveRequest.ProtoReflect.Descriptor instead. func (*ShardReplicationRemoveRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{182} + return file_vtctldata_proto_rawDescGZIP(), []int{184} } func (x *ShardReplicationRemoveRequest) GetKeyspace() string { @@ -11627,7 +11739,7 @@ type ShardReplicationRemoveResponse struct { func (x *ShardReplicationRemoveResponse) Reset() { *x = ShardReplicationRemoveResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[183] + mi := &file_vtctldata_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11640,7 +11752,7 @@ func (x *ShardReplicationRemoveResponse) String() string { func (*ShardReplicationRemoveResponse) ProtoMessage() {} func (x *ShardReplicationRemoveResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[183] + mi := &file_vtctldata_proto_msgTypes[185] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11653,7 +11765,7 @@ func (x *ShardReplicationRemoveResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ShardReplicationRemoveResponse.ProtoReflect.Descriptor instead. func (*ShardReplicationRemoveResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{183} + return file_vtctldata_proto_rawDescGZIP(), []int{185} } type SleepTabletRequest struct { @@ -11668,7 +11780,7 @@ type SleepTabletRequest struct { func (x *SleepTabletRequest) Reset() { *x = SleepTabletRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[184] + mi := &file_vtctldata_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11681,7 +11793,7 @@ func (x *SleepTabletRequest) String() string { func (*SleepTabletRequest) ProtoMessage() {} func (x *SleepTabletRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[184] + mi := &file_vtctldata_proto_msgTypes[186] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11694,7 +11806,7 @@ func (x *SleepTabletRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SleepTabletRequest.ProtoReflect.Descriptor instead. func (*SleepTabletRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{184} + return file_vtctldata_proto_rawDescGZIP(), []int{186} } func (x *SleepTabletRequest) GetTabletAlias() *topodata.TabletAlias { @@ -11720,7 +11832,7 @@ type SleepTabletResponse struct { func (x *SleepTabletResponse) Reset() { *x = SleepTabletResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[185] + mi := &file_vtctldata_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11733,7 +11845,7 @@ func (x *SleepTabletResponse) String() string { func (*SleepTabletResponse) ProtoMessage() {} func (x *SleepTabletResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[185] + mi := &file_vtctldata_proto_msgTypes[187] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11746,7 +11858,7 @@ func (x *SleepTabletResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SleepTabletResponse.ProtoReflect.Descriptor instead. func (*SleepTabletResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{185} + return file_vtctldata_proto_rawDescGZIP(), []int{187} } type SourceShardAddRequest struct { @@ -11770,7 +11882,7 @@ type SourceShardAddRequest struct { func (x *SourceShardAddRequest) Reset() { *x = SourceShardAddRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[186] + mi := &file_vtctldata_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11783,7 +11895,7 @@ func (x *SourceShardAddRequest) String() string { func (*SourceShardAddRequest) ProtoMessage() {} func (x *SourceShardAddRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[186] + mi := &file_vtctldata_proto_msgTypes[188] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11796,7 +11908,7 @@ func (x *SourceShardAddRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SourceShardAddRequest.ProtoReflect.Descriptor instead. func (*SourceShardAddRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{186} + return file_vtctldata_proto_rawDescGZIP(), []int{188} } func (x *SourceShardAddRequest) GetKeyspace() string { @@ -11860,7 +11972,7 @@ type SourceShardAddResponse struct { func (x *SourceShardAddResponse) Reset() { *x = SourceShardAddResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[187] + mi := &file_vtctldata_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11873,7 +11985,7 @@ func (x *SourceShardAddResponse) String() string { func (*SourceShardAddResponse) ProtoMessage() {} func (x *SourceShardAddResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[187] + mi := &file_vtctldata_proto_msgTypes[189] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11886,7 +11998,7 @@ func (x *SourceShardAddResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SourceShardAddResponse.ProtoReflect.Descriptor instead. func (*SourceShardAddResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{187} + return file_vtctldata_proto_rawDescGZIP(), []int{189} } func (x *SourceShardAddResponse) GetShard() *topodata.Shard { @@ -11909,7 +12021,7 @@ type SourceShardDeleteRequest struct { func (x *SourceShardDeleteRequest) Reset() { *x = SourceShardDeleteRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[188] + mi := &file_vtctldata_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11922,7 +12034,7 @@ func (x *SourceShardDeleteRequest) String() string { func (*SourceShardDeleteRequest) ProtoMessage() {} func (x *SourceShardDeleteRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[188] + mi := &file_vtctldata_proto_msgTypes[190] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11935,7 +12047,7 @@ func (x *SourceShardDeleteRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SourceShardDeleteRequest.ProtoReflect.Descriptor instead. func (*SourceShardDeleteRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{188} + return file_vtctldata_proto_rawDescGZIP(), []int{190} } func (x *SourceShardDeleteRequest) GetKeyspace() string { @@ -11971,7 +12083,7 @@ type SourceShardDeleteResponse struct { func (x *SourceShardDeleteResponse) Reset() { *x = SourceShardDeleteResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[189] + mi := &file_vtctldata_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11984,7 +12096,7 @@ func (x *SourceShardDeleteResponse) String() string { func (*SourceShardDeleteResponse) ProtoMessage() {} func (x *SourceShardDeleteResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[189] + mi := &file_vtctldata_proto_msgTypes[191] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11997,7 +12109,7 @@ func (x *SourceShardDeleteResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SourceShardDeleteResponse.ProtoReflect.Descriptor instead. func (*SourceShardDeleteResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{189} + return file_vtctldata_proto_rawDescGZIP(), []int{191} } func (x *SourceShardDeleteResponse) GetShard() *topodata.Shard { @@ -12018,7 +12130,7 @@ type StartReplicationRequest struct { func (x *StartReplicationRequest) Reset() { *x = StartReplicationRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[190] + mi := &file_vtctldata_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12031,7 +12143,7 @@ func (x *StartReplicationRequest) String() string { func (*StartReplicationRequest) ProtoMessage() {} func (x *StartReplicationRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[190] + mi := &file_vtctldata_proto_msgTypes[192] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12044,7 +12156,7 @@ func (x *StartReplicationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartReplicationRequest.ProtoReflect.Descriptor instead. func (*StartReplicationRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{190} + return file_vtctldata_proto_rawDescGZIP(), []int{192} } func (x *StartReplicationRequest) GetTabletAlias() *topodata.TabletAlias { @@ -12063,7 +12175,7 @@ type StartReplicationResponse struct { func (x *StartReplicationResponse) Reset() { *x = StartReplicationResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[191] + mi := &file_vtctldata_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12076,7 +12188,7 @@ func (x *StartReplicationResponse) String() string { func (*StartReplicationResponse) ProtoMessage() {} func (x *StartReplicationResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[191] + mi := &file_vtctldata_proto_msgTypes[193] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12089,7 +12201,7 @@ func (x *StartReplicationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StartReplicationResponse.ProtoReflect.Descriptor instead. func (*StartReplicationResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{191} + return file_vtctldata_proto_rawDescGZIP(), []int{193} } type StopReplicationRequest struct { @@ -12103,7 +12215,7 @@ type StopReplicationRequest struct { func (x *StopReplicationRequest) Reset() { *x = StopReplicationRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[192] + mi := &file_vtctldata_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12116,7 +12228,7 @@ func (x *StopReplicationRequest) String() string { func (*StopReplicationRequest) ProtoMessage() {} func (x *StopReplicationRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[192] + mi := &file_vtctldata_proto_msgTypes[194] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12129,7 +12241,7 @@ func (x *StopReplicationRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopReplicationRequest.ProtoReflect.Descriptor instead. func (*StopReplicationRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{192} + return file_vtctldata_proto_rawDescGZIP(), []int{194} } func (x *StopReplicationRequest) GetTabletAlias() *topodata.TabletAlias { @@ -12148,7 +12260,7 @@ type StopReplicationResponse struct { func (x *StopReplicationResponse) Reset() { *x = StopReplicationResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[193] + mi := &file_vtctldata_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12161,7 +12273,7 @@ func (x *StopReplicationResponse) String() string { func (*StopReplicationResponse) ProtoMessage() {} func (x *StopReplicationResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[193] + mi := &file_vtctldata_proto_msgTypes[195] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12174,7 +12286,7 @@ func (x *StopReplicationResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StopReplicationResponse.ProtoReflect.Descriptor instead. func (*StopReplicationResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{193} + return file_vtctldata_proto_rawDescGZIP(), []int{195} } type TabletExternallyReparentedRequest struct { @@ -12190,7 +12302,7 @@ type TabletExternallyReparentedRequest struct { func (x *TabletExternallyReparentedRequest) Reset() { *x = TabletExternallyReparentedRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[194] + mi := &file_vtctldata_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12203,7 +12315,7 @@ func (x *TabletExternallyReparentedRequest) String() string { func (*TabletExternallyReparentedRequest) ProtoMessage() {} func (x *TabletExternallyReparentedRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[194] + mi := &file_vtctldata_proto_msgTypes[196] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12216,7 +12328,7 @@ func (x *TabletExternallyReparentedRequest) ProtoReflect() protoreflect.Message // Deprecated: Use TabletExternallyReparentedRequest.ProtoReflect.Descriptor instead. func (*TabletExternallyReparentedRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{194} + return file_vtctldata_proto_rawDescGZIP(), []int{196} } func (x *TabletExternallyReparentedRequest) GetTablet() *topodata.TabletAlias { @@ -12240,7 +12352,7 @@ type TabletExternallyReparentedResponse struct { func (x *TabletExternallyReparentedResponse) Reset() { *x = TabletExternallyReparentedResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[195] + mi := &file_vtctldata_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12253,7 +12365,7 @@ func (x *TabletExternallyReparentedResponse) String() string { func (*TabletExternallyReparentedResponse) ProtoMessage() {} func (x *TabletExternallyReparentedResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[195] + mi := &file_vtctldata_proto_msgTypes[197] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12266,7 +12378,7 @@ func (x *TabletExternallyReparentedResponse) ProtoReflect() protoreflect.Message // Deprecated: Use TabletExternallyReparentedResponse.ProtoReflect.Descriptor instead. func (*TabletExternallyReparentedResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{195} + return file_vtctldata_proto_rawDescGZIP(), []int{197} } func (x *TabletExternallyReparentedResponse) GetKeyspace() string { @@ -12309,7 +12421,7 @@ type UpdateCellInfoRequest struct { func (x *UpdateCellInfoRequest) Reset() { *x = UpdateCellInfoRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[196] + mi := &file_vtctldata_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12322,7 +12434,7 @@ func (x *UpdateCellInfoRequest) String() string { func (*UpdateCellInfoRequest) ProtoMessage() {} func (x *UpdateCellInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[196] + mi := &file_vtctldata_proto_msgTypes[198] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12335,7 +12447,7 @@ func (x *UpdateCellInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateCellInfoRequest.ProtoReflect.Descriptor instead. func (*UpdateCellInfoRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{196} + return file_vtctldata_proto_rawDescGZIP(), []int{198} } func (x *UpdateCellInfoRequest) GetName() string { @@ -12364,7 +12476,7 @@ type UpdateCellInfoResponse struct { func (x *UpdateCellInfoResponse) Reset() { *x = UpdateCellInfoResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[197] + mi := &file_vtctldata_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12377,7 +12489,7 @@ func (x *UpdateCellInfoResponse) String() string { func (*UpdateCellInfoResponse) ProtoMessage() {} func (x *UpdateCellInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[197] + mi := &file_vtctldata_proto_msgTypes[199] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12390,7 +12502,7 @@ func (x *UpdateCellInfoResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateCellInfoResponse.ProtoReflect.Descriptor instead. func (*UpdateCellInfoResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{197} + return file_vtctldata_proto_rawDescGZIP(), []int{199} } func (x *UpdateCellInfoResponse) GetName() string { @@ -12419,7 +12531,7 @@ type UpdateCellsAliasRequest struct { func (x *UpdateCellsAliasRequest) Reset() { *x = UpdateCellsAliasRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[198] + mi := &file_vtctldata_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12432,7 +12544,7 @@ func (x *UpdateCellsAliasRequest) String() string { func (*UpdateCellsAliasRequest) ProtoMessage() {} func (x *UpdateCellsAliasRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[198] + mi := &file_vtctldata_proto_msgTypes[200] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12445,7 +12557,7 @@ func (x *UpdateCellsAliasRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateCellsAliasRequest.ProtoReflect.Descriptor instead. func (*UpdateCellsAliasRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{198} + return file_vtctldata_proto_rawDescGZIP(), []int{200} } func (x *UpdateCellsAliasRequest) GetName() string { @@ -12474,7 +12586,7 @@ type UpdateCellsAliasResponse struct { func (x *UpdateCellsAliasResponse) Reset() { *x = UpdateCellsAliasResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[199] + mi := &file_vtctldata_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12487,7 +12599,7 @@ func (x *UpdateCellsAliasResponse) String() string { func (*UpdateCellsAliasResponse) ProtoMessage() {} func (x *UpdateCellsAliasResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[199] + mi := &file_vtctldata_proto_msgTypes[201] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12500,7 +12612,7 @@ func (x *UpdateCellsAliasResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateCellsAliasResponse.ProtoReflect.Descriptor instead. func (*UpdateCellsAliasResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{199} + return file_vtctldata_proto_rawDescGZIP(), []int{201} } func (x *UpdateCellsAliasResponse) GetName() string { @@ -12528,7 +12640,7 @@ type ValidateRequest struct { func (x *ValidateRequest) Reset() { *x = ValidateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[200] + mi := &file_vtctldata_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12541,7 +12653,7 @@ func (x *ValidateRequest) String() string { func (*ValidateRequest) ProtoMessage() {} func (x *ValidateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[200] + mi := &file_vtctldata_proto_msgTypes[202] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12554,7 +12666,7 @@ func (x *ValidateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateRequest.ProtoReflect.Descriptor instead. func (*ValidateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{200} + return file_vtctldata_proto_rawDescGZIP(), []int{202} } func (x *ValidateRequest) GetPingTablets() bool { @@ -12576,7 +12688,7 @@ type ValidateResponse struct { func (x *ValidateResponse) Reset() { *x = ValidateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[201] + mi := &file_vtctldata_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12589,7 +12701,7 @@ func (x *ValidateResponse) String() string { func (*ValidateResponse) ProtoMessage() {} func (x *ValidateResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[201] + mi := &file_vtctldata_proto_msgTypes[203] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12602,7 +12714,7 @@ func (x *ValidateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateResponse.ProtoReflect.Descriptor instead. func (*ValidateResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{201} + return file_vtctldata_proto_rawDescGZIP(), []int{203} } func (x *ValidateResponse) GetResults() []string { @@ -12631,7 +12743,7 @@ type ValidateKeyspaceRequest struct { func (x *ValidateKeyspaceRequest) Reset() { *x = ValidateKeyspaceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[202] + mi := &file_vtctldata_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12644,7 +12756,7 @@ func (x *ValidateKeyspaceRequest) String() string { func (*ValidateKeyspaceRequest) ProtoMessage() {} func (x *ValidateKeyspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[202] + mi := &file_vtctldata_proto_msgTypes[204] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12657,7 +12769,7 @@ func (x *ValidateKeyspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateKeyspaceRequest.ProtoReflect.Descriptor instead. func (*ValidateKeyspaceRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{202} + return file_vtctldata_proto_rawDescGZIP(), []int{204} } func (x *ValidateKeyspaceRequest) GetKeyspace() string { @@ -12686,7 +12798,7 @@ type ValidateKeyspaceResponse struct { func (x *ValidateKeyspaceResponse) Reset() { *x = ValidateKeyspaceResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[203] + mi := &file_vtctldata_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12699,7 +12811,7 @@ func (x *ValidateKeyspaceResponse) String() string { func (*ValidateKeyspaceResponse) ProtoMessage() {} func (x *ValidateKeyspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[203] + mi := &file_vtctldata_proto_msgTypes[205] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12712,7 +12824,7 @@ func (x *ValidateKeyspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateKeyspaceResponse.ProtoReflect.Descriptor instead. func (*ValidateKeyspaceResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{203} + return file_vtctldata_proto_rawDescGZIP(), []int{205} } func (x *ValidateKeyspaceResponse) GetResults() []string { @@ -12744,7 +12856,7 @@ type ValidateSchemaKeyspaceRequest struct { func (x *ValidateSchemaKeyspaceRequest) Reset() { *x = ValidateSchemaKeyspaceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[204] + mi := &file_vtctldata_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12757,7 +12869,7 @@ func (x *ValidateSchemaKeyspaceRequest) String() string { func (*ValidateSchemaKeyspaceRequest) ProtoMessage() {} func (x *ValidateSchemaKeyspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[204] + mi := &file_vtctldata_proto_msgTypes[206] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12770,7 +12882,7 @@ func (x *ValidateSchemaKeyspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateSchemaKeyspaceRequest.ProtoReflect.Descriptor instead. func (*ValidateSchemaKeyspaceRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{204} + return file_vtctldata_proto_rawDescGZIP(), []int{206} } func (x *ValidateSchemaKeyspaceRequest) GetKeyspace() string { @@ -12820,7 +12932,7 @@ type ValidateSchemaKeyspaceResponse struct { func (x *ValidateSchemaKeyspaceResponse) Reset() { *x = ValidateSchemaKeyspaceResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[205] + mi := &file_vtctldata_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12833,7 +12945,7 @@ func (x *ValidateSchemaKeyspaceResponse) String() string { func (*ValidateSchemaKeyspaceResponse) ProtoMessage() {} func (x *ValidateSchemaKeyspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[205] + mi := &file_vtctldata_proto_msgTypes[207] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12846,7 +12958,7 @@ func (x *ValidateSchemaKeyspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateSchemaKeyspaceResponse.ProtoReflect.Descriptor instead. func (*ValidateSchemaKeyspaceResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{205} + return file_vtctldata_proto_rawDescGZIP(), []int{207} } func (x *ValidateSchemaKeyspaceResponse) GetResults() []string { @@ -12876,7 +12988,7 @@ type ValidateShardRequest struct { func (x *ValidateShardRequest) Reset() { *x = ValidateShardRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[206] + mi := &file_vtctldata_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12889,7 +13001,7 @@ func (x *ValidateShardRequest) String() string { func (*ValidateShardRequest) ProtoMessage() {} func (x *ValidateShardRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[206] + mi := &file_vtctldata_proto_msgTypes[208] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12902,7 +13014,7 @@ func (x *ValidateShardRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateShardRequest.ProtoReflect.Descriptor instead. func (*ValidateShardRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{206} + return file_vtctldata_proto_rawDescGZIP(), []int{208} } func (x *ValidateShardRequest) GetKeyspace() string { @@ -12937,7 +13049,7 @@ type ValidateShardResponse struct { func (x *ValidateShardResponse) Reset() { *x = ValidateShardResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[207] + mi := &file_vtctldata_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12950,7 +13062,7 @@ func (x *ValidateShardResponse) String() string { func (*ValidateShardResponse) ProtoMessage() {} func (x *ValidateShardResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[207] + mi := &file_vtctldata_proto_msgTypes[209] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12963,7 +13075,7 @@ func (x *ValidateShardResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateShardResponse.ProtoReflect.Descriptor instead. func (*ValidateShardResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{207} + return file_vtctldata_proto_rawDescGZIP(), []int{209} } func (x *ValidateShardResponse) GetResults() []string { @@ -12984,7 +13096,7 @@ type ValidateVersionKeyspaceRequest struct { func (x *ValidateVersionKeyspaceRequest) Reset() { *x = ValidateVersionKeyspaceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[208] + mi := &file_vtctldata_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12997,7 +13109,7 @@ func (x *ValidateVersionKeyspaceRequest) String() string { func (*ValidateVersionKeyspaceRequest) ProtoMessage() {} func (x *ValidateVersionKeyspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[208] + mi := &file_vtctldata_proto_msgTypes[210] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13010,7 +13122,7 @@ func (x *ValidateVersionKeyspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateVersionKeyspaceRequest.ProtoReflect.Descriptor instead. func (*ValidateVersionKeyspaceRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{208} + return file_vtctldata_proto_rawDescGZIP(), []int{210} } func (x *ValidateVersionKeyspaceRequest) GetKeyspace() string { @@ -13032,7 +13144,7 @@ type ValidateVersionKeyspaceResponse struct { func (x *ValidateVersionKeyspaceResponse) Reset() { *x = ValidateVersionKeyspaceResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[209] + mi := &file_vtctldata_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13045,7 +13157,7 @@ func (x *ValidateVersionKeyspaceResponse) String() string { func (*ValidateVersionKeyspaceResponse) ProtoMessage() {} func (x *ValidateVersionKeyspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[209] + mi := &file_vtctldata_proto_msgTypes[211] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13058,7 +13170,7 @@ func (x *ValidateVersionKeyspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateVersionKeyspaceResponse.ProtoReflect.Descriptor instead. func (*ValidateVersionKeyspaceResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{209} + return file_vtctldata_proto_rawDescGZIP(), []int{211} } func (x *ValidateVersionKeyspaceResponse) GetResults() []string { @@ -13087,7 +13199,7 @@ type ValidateVersionShardRequest struct { func (x *ValidateVersionShardRequest) Reset() { *x = ValidateVersionShardRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[210] + mi := &file_vtctldata_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13100,7 +13212,7 @@ func (x *ValidateVersionShardRequest) String() string { func (*ValidateVersionShardRequest) ProtoMessage() {} func (x *ValidateVersionShardRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[210] + mi := &file_vtctldata_proto_msgTypes[212] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13113,7 +13225,7 @@ func (x *ValidateVersionShardRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateVersionShardRequest.ProtoReflect.Descriptor instead. func (*ValidateVersionShardRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{210} + return file_vtctldata_proto_rawDescGZIP(), []int{212} } func (x *ValidateVersionShardRequest) GetKeyspace() string { @@ -13141,7 +13253,7 @@ type ValidateVersionShardResponse struct { func (x *ValidateVersionShardResponse) Reset() { *x = ValidateVersionShardResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[211] + mi := &file_vtctldata_proto_msgTypes[213] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13154,7 +13266,7 @@ func (x *ValidateVersionShardResponse) String() string { func (*ValidateVersionShardResponse) ProtoMessage() {} func (x *ValidateVersionShardResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[211] + mi := &file_vtctldata_proto_msgTypes[213] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13167,7 +13279,7 @@ func (x *ValidateVersionShardResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateVersionShardResponse.ProtoReflect.Descriptor instead. func (*ValidateVersionShardResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{211} + return file_vtctldata_proto_rawDescGZIP(), []int{213} } func (x *ValidateVersionShardResponse) GetResults() []string { @@ -13191,7 +13303,7 @@ type ValidateVSchemaRequest struct { func (x *ValidateVSchemaRequest) Reset() { *x = ValidateVSchemaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[212] + mi := &file_vtctldata_proto_msgTypes[214] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13204,7 +13316,7 @@ func (x *ValidateVSchemaRequest) String() string { func (*ValidateVSchemaRequest) ProtoMessage() {} func (x *ValidateVSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[212] + mi := &file_vtctldata_proto_msgTypes[214] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13217,7 +13329,7 @@ func (x *ValidateVSchemaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateVSchemaRequest.ProtoReflect.Descriptor instead. func (*ValidateVSchemaRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{212} + return file_vtctldata_proto_rawDescGZIP(), []int{214} } func (x *ValidateVSchemaRequest) GetKeyspace() string { @@ -13260,7 +13372,7 @@ type ValidateVSchemaResponse struct { func (x *ValidateVSchemaResponse) Reset() { *x = ValidateVSchemaResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[213] + mi := &file_vtctldata_proto_msgTypes[215] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13273,7 +13385,7 @@ func (x *ValidateVSchemaResponse) String() string { func (*ValidateVSchemaResponse) ProtoMessage() {} func (x *ValidateVSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[213] + mi := &file_vtctldata_proto_msgTypes[215] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13286,7 +13398,7 @@ func (x *ValidateVSchemaResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ValidateVSchemaResponse.ProtoReflect.Descriptor instead. func (*ValidateVSchemaResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{213} + return file_vtctldata_proto_rawDescGZIP(), []int{215} } func (x *ValidateVSchemaResponse) GetResults() []string { @@ -13333,7 +13445,7 @@ type VDiffCreateRequest struct { func (x *VDiffCreateRequest) Reset() { *x = VDiffCreateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[214] + mi := &file_vtctldata_proto_msgTypes[216] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13346,7 +13458,7 @@ func (x *VDiffCreateRequest) String() string { func (*VDiffCreateRequest) ProtoMessage() {} func (x *VDiffCreateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[214] + mi := &file_vtctldata_proto_msgTypes[216] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13359,7 +13471,7 @@ func (x *VDiffCreateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffCreateRequest.ProtoReflect.Descriptor instead. func (*VDiffCreateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{214} + return file_vtctldata_proto_rawDescGZIP(), []int{216} } func (x *VDiffCreateRequest) GetWorkflow() string { @@ -13515,7 +13627,7 @@ type VDiffCreateResponse struct { func (x *VDiffCreateResponse) Reset() { *x = VDiffCreateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[215] + mi := &file_vtctldata_proto_msgTypes[217] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13528,7 +13640,7 @@ func (x *VDiffCreateResponse) String() string { func (*VDiffCreateResponse) ProtoMessage() {} func (x *VDiffCreateResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[215] + mi := &file_vtctldata_proto_msgTypes[217] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13541,7 +13653,7 @@ func (x *VDiffCreateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffCreateResponse.ProtoReflect.Descriptor instead. func (*VDiffCreateResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{215} + return file_vtctldata_proto_rawDescGZIP(), []int{217} } func (x *VDiffCreateResponse) GetUUID() string { @@ -13565,7 +13677,7 @@ type VDiffDeleteRequest struct { func (x *VDiffDeleteRequest) Reset() { *x = VDiffDeleteRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[216] + mi := &file_vtctldata_proto_msgTypes[218] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13578,7 +13690,7 @@ func (x *VDiffDeleteRequest) String() string { func (*VDiffDeleteRequest) ProtoMessage() {} func (x *VDiffDeleteRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[216] + mi := &file_vtctldata_proto_msgTypes[218] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13591,7 +13703,7 @@ func (x *VDiffDeleteRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffDeleteRequest.ProtoReflect.Descriptor instead. func (*VDiffDeleteRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{216} + return file_vtctldata_proto_rawDescGZIP(), []int{218} } func (x *VDiffDeleteRequest) GetWorkflow() string { @@ -13624,7 +13736,7 @@ type VDiffDeleteResponse struct { func (x *VDiffDeleteResponse) Reset() { *x = VDiffDeleteResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[217] + mi := &file_vtctldata_proto_msgTypes[219] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13637,7 +13749,7 @@ func (x *VDiffDeleteResponse) String() string { func (*VDiffDeleteResponse) ProtoMessage() {} func (x *VDiffDeleteResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[217] + mi := &file_vtctldata_proto_msgTypes[219] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13650,7 +13762,7 @@ func (x *VDiffDeleteResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffDeleteResponse.ProtoReflect.Descriptor instead. func (*VDiffDeleteResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{217} + return file_vtctldata_proto_rawDescGZIP(), []int{219} } type VDiffResumeRequest struct { @@ -13666,7 +13778,7 @@ type VDiffResumeRequest struct { func (x *VDiffResumeRequest) Reset() { *x = VDiffResumeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[218] + mi := &file_vtctldata_proto_msgTypes[220] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13679,7 +13791,7 @@ func (x *VDiffResumeRequest) String() string { func (*VDiffResumeRequest) ProtoMessage() {} func (x *VDiffResumeRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[218] + mi := &file_vtctldata_proto_msgTypes[220] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13692,7 +13804,7 @@ func (x *VDiffResumeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffResumeRequest.ProtoReflect.Descriptor instead. func (*VDiffResumeRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{218} + return file_vtctldata_proto_rawDescGZIP(), []int{220} } func (x *VDiffResumeRequest) GetWorkflow() string { @@ -13725,7 +13837,7 @@ type VDiffResumeResponse struct { func (x *VDiffResumeResponse) Reset() { *x = VDiffResumeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[219] + mi := &file_vtctldata_proto_msgTypes[221] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13738,7 +13850,7 @@ func (x *VDiffResumeResponse) String() string { func (*VDiffResumeResponse) ProtoMessage() {} func (x *VDiffResumeResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[219] + mi := &file_vtctldata_proto_msgTypes[221] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13751,7 +13863,7 @@ func (x *VDiffResumeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffResumeResponse.ProtoReflect.Descriptor instead. func (*VDiffResumeResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{219} + return file_vtctldata_proto_rawDescGZIP(), []int{221} } type VDiffShowRequest struct { @@ -13768,7 +13880,7 @@ type VDiffShowRequest struct { func (x *VDiffShowRequest) Reset() { *x = VDiffShowRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[220] + mi := &file_vtctldata_proto_msgTypes[222] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13781,7 +13893,7 @@ func (x *VDiffShowRequest) String() string { func (*VDiffShowRequest) ProtoMessage() {} func (x *VDiffShowRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[220] + mi := &file_vtctldata_proto_msgTypes[222] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13794,7 +13906,7 @@ func (x *VDiffShowRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffShowRequest.ProtoReflect.Descriptor instead. func (*VDiffShowRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{220} + return file_vtctldata_proto_rawDescGZIP(), []int{222} } func (x *VDiffShowRequest) GetWorkflow() string { @@ -13830,7 +13942,7 @@ type VDiffShowResponse struct { func (x *VDiffShowResponse) Reset() { *x = VDiffShowResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[221] + mi := &file_vtctldata_proto_msgTypes[223] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13843,7 +13955,7 @@ func (x *VDiffShowResponse) String() string { func (*VDiffShowResponse) ProtoMessage() {} func (x *VDiffShowResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[221] + mi := &file_vtctldata_proto_msgTypes[223] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13856,7 +13968,7 @@ func (x *VDiffShowResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffShowResponse.ProtoReflect.Descriptor instead. func (*VDiffShowResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{221} + return file_vtctldata_proto_rawDescGZIP(), []int{223} } func (x *VDiffShowResponse) GetTabletResponses() map[string]*tabletmanagerdata.VDiffResponse { @@ -13879,7 +13991,7 @@ type VDiffStopRequest struct { func (x *VDiffStopRequest) Reset() { *x = VDiffStopRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[222] + mi := &file_vtctldata_proto_msgTypes[224] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13892,7 +14004,7 @@ func (x *VDiffStopRequest) String() string { func (*VDiffStopRequest) ProtoMessage() {} func (x *VDiffStopRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[222] + mi := &file_vtctldata_proto_msgTypes[224] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13905,7 +14017,7 @@ func (x *VDiffStopRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffStopRequest.ProtoReflect.Descriptor instead. func (*VDiffStopRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{222} + return file_vtctldata_proto_rawDescGZIP(), []int{224} } func (x *VDiffStopRequest) GetWorkflow() string { @@ -13938,7 +14050,7 @@ type VDiffStopResponse struct { func (x *VDiffStopResponse) Reset() { *x = VDiffStopResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[223] + mi := &file_vtctldata_proto_msgTypes[225] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13951,7 +14063,7 @@ func (x *VDiffStopResponse) String() string { func (*VDiffStopResponse) ProtoMessage() {} func (x *VDiffStopResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[223] + mi := &file_vtctldata_proto_msgTypes[225] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13964,7 +14076,7 @@ func (x *VDiffStopResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VDiffStopResponse.ProtoReflect.Descriptor instead. func (*VDiffStopResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{223} + return file_vtctldata_proto_rawDescGZIP(), []int{225} } type WorkflowDeleteRequest struct { @@ -13982,7 +14094,7 @@ type WorkflowDeleteRequest struct { func (x *WorkflowDeleteRequest) Reset() { *x = WorkflowDeleteRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[224] + mi := &file_vtctldata_proto_msgTypes[226] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13995,7 +14107,7 @@ func (x *WorkflowDeleteRequest) String() string { func (*WorkflowDeleteRequest) ProtoMessage() {} func (x *WorkflowDeleteRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[224] + mi := &file_vtctldata_proto_msgTypes[226] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14008,7 +14120,7 @@ func (x *WorkflowDeleteRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowDeleteRequest.ProtoReflect.Descriptor instead. func (*WorkflowDeleteRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{224} + return file_vtctldata_proto_rawDescGZIP(), []int{226} } func (x *WorkflowDeleteRequest) GetKeyspace() string { @@ -14058,7 +14170,7 @@ type WorkflowDeleteResponse struct { func (x *WorkflowDeleteResponse) Reset() { *x = WorkflowDeleteResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[225] + mi := &file_vtctldata_proto_msgTypes[227] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14071,7 +14183,7 @@ func (x *WorkflowDeleteResponse) String() string { func (*WorkflowDeleteResponse) ProtoMessage() {} func (x *WorkflowDeleteResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[225] + mi := &file_vtctldata_proto_msgTypes[227] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14084,7 +14196,7 @@ func (x *WorkflowDeleteResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowDeleteResponse.ProtoReflect.Descriptor instead. func (*WorkflowDeleteResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{225} + return file_vtctldata_proto_rawDescGZIP(), []int{227} } func (x *WorkflowDeleteResponse) GetSummary() string { @@ -14114,7 +14226,7 @@ type WorkflowStatusRequest struct { func (x *WorkflowStatusRequest) Reset() { *x = WorkflowStatusRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[226] + mi := &file_vtctldata_proto_msgTypes[228] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14127,7 +14239,7 @@ func (x *WorkflowStatusRequest) String() string { func (*WorkflowStatusRequest) ProtoMessage() {} func (x *WorkflowStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[226] + mi := &file_vtctldata_proto_msgTypes[228] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14140,7 +14252,7 @@ func (x *WorkflowStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowStatusRequest.ProtoReflect.Descriptor instead. func (*WorkflowStatusRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{226} + return file_vtctldata_proto_rawDescGZIP(), []int{228} } func (x *WorkflowStatusRequest) GetKeyspace() string { @@ -14178,7 +14290,7 @@ type WorkflowStatusResponse struct { func (x *WorkflowStatusResponse) Reset() { *x = WorkflowStatusResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[227] + mi := &file_vtctldata_proto_msgTypes[229] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14191,7 +14303,7 @@ func (x *WorkflowStatusResponse) String() string { func (*WorkflowStatusResponse) ProtoMessage() {} func (x *WorkflowStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[227] + mi := &file_vtctldata_proto_msgTypes[229] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14204,7 +14316,7 @@ func (x *WorkflowStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowStatusResponse.ProtoReflect.Descriptor instead. func (*WorkflowStatusResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{227} + return file_vtctldata_proto_rawDescGZIP(), []int{229} } func (x *WorkflowStatusResponse) GetTableCopyState() map[string]*WorkflowStatusResponse_TableCopyState { @@ -14249,7 +14361,7 @@ type WorkflowSwitchTrafficRequest struct { func (x *WorkflowSwitchTrafficRequest) Reset() { *x = WorkflowSwitchTrafficRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[228] + mi := &file_vtctldata_proto_msgTypes[230] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14262,7 +14374,7 @@ func (x *WorkflowSwitchTrafficRequest) String() string { func (*WorkflowSwitchTrafficRequest) ProtoMessage() {} func (x *WorkflowSwitchTrafficRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[228] + mi := &file_vtctldata_proto_msgTypes[230] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14275,7 +14387,7 @@ func (x *WorkflowSwitchTrafficRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowSwitchTrafficRequest.ProtoReflect.Descriptor instead. func (*WorkflowSwitchTrafficRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{228} + return file_vtctldata_proto_rawDescGZIP(), []int{230} } func (x *WorkflowSwitchTrafficRequest) GetKeyspace() string { @@ -14369,7 +14481,7 @@ type WorkflowSwitchTrafficResponse struct { func (x *WorkflowSwitchTrafficResponse) Reset() { *x = WorkflowSwitchTrafficResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[229] + mi := &file_vtctldata_proto_msgTypes[231] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14382,7 +14494,7 @@ func (x *WorkflowSwitchTrafficResponse) String() string { func (*WorkflowSwitchTrafficResponse) ProtoMessage() {} func (x *WorkflowSwitchTrafficResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[229] + mi := &file_vtctldata_proto_msgTypes[231] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14395,7 +14507,7 @@ func (x *WorkflowSwitchTrafficResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowSwitchTrafficResponse.ProtoReflect.Descriptor instead. func (*WorkflowSwitchTrafficResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{229} + return file_vtctldata_proto_rawDescGZIP(), []int{231} } func (x *WorkflowSwitchTrafficResponse) GetSummary() string { @@ -14440,7 +14552,7 @@ type WorkflowUpdateRequest struct { func (x *WorkflowUpdateRequest) Reset() { *x = WorkflowUpdateRequest{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[230] + mi := &file_vtctldata_proto_msgTypes[232] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14453,7 +14565,7 @@ func (x *WorkflowUpdateRequest) String() string { func (*WorkflowUpdateRequest) ProtoMessage() {} func (x *WorkflowUpdateRequest) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[230] + mi := &file_vtctldata_proto_msgTypes[232] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14466,7 +14578,7 @@ func (x *WorkflowUpdateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowUpdateRequest.ProtoReflect.Descriptor instead. func (*WorkflowUpdateRequest) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{230} + return file_vtctldata_proto_rawDescGZIP(), []int{232} } func (x *WorkflowUpdateRequest) GetKeyspace() string { @@ -14495,7 +14607,7 @@ type WorkflowUpdateResponse struct { func (x *WorkflowUpdateResponse) Reset() { *x = WorkflowUpdateResponse{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[231] + mi := &file_vtctldata_proto_msgTypes[233] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14508,7 +14620,7 @@ func (x *WorkflowUpdateResponse) String() string { func (*WorkflowUpdateResponse) ProtoMessage() {} func (x *WorkflowUpdateResponse) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[231] + mi := &file_vtctldata_proto_msgTypes[233] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14521,7 +14633,7 @@ func (x *WorkflowUpdateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkflowUpdateResponse.ProtoReflect.Descriptor instead. func (*WorkflowUpdateResponse) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{231} + return file_vtctldata_proto_rawDescGZIP(), []int{233} } func (x *WorkflowUpdateResponse) GetSummary() string { @@ -14550,7 +14662,7 @@ type Workflow_ReplicationLocation struct { func (x *Workflow_ReplicationLocation) Reset() { *x = Workflow_ReplicationLocation{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[233] + mi := &file_vtctldata_proto_msgTypes[235] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14563,7 +14675,7 @@ func (x *Workflow_ReplicationLocation) String() string { func (*Workflow_ReplicationLocation) ProtoMessage() {} func (x *Workflow_ReplicationLocation) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[233] + mi := &file_vtctldata_proto_msgTypes[235] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14606,7 +14718,7 @@ type Workflow_ShardStream struct { func (x *Workflow_ShardStream) Reset() { *x = Workflow_ShardStream{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[234] + mi := &file_vtctldata_proto_msgTypes[236] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14619,7 +14731,7 @@ func (x *Workflow_ShardStream) String() string { func (*Workflow_ShardStream) ProtoMessage() {} func (x *Workflow_ShardStream) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[234] + mi := &file_vtctldata_proto_msgTypes[236] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14694,7 +14806,7 @@ type Workflow_Stream struct { func (x *Workflow_Stream) Reset() { *x = Workflow_Stream{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[235] + mi := &file_vtctldata_proto_msgTypes[237] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14707,7 +14819,7 @@ func (x *Workflow_Stream) String() string { func (*Workflow_Stream) ProtoMessage() {} func (x *Workflow_Stream) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[235] + mi := &file_vtctldata_proto_msgTypes[237] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14876,7 +14988,7 @@ type Workflow_Stream_CopyState struct { func (x *Workflow_Stream_CopyState) Reset() { *x = Workflow_Stream_CopyState{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[236] + mi := &file_vtctldata_proto_msgTypes[238] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14889,7 +15001,7 @@ func (x *Workflow_Stream_CopyState) String() string { func (*Workflow_Stream_CopyState) ProtoMessage() {} func (x *Workflow_Stream_CopyState) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[236] + mi := &file_vtctldata_proto_msgTypes[238] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14944,7 +15056,7 @@ type Workflow_Stream_Log struct { func (x *Workflow_Stream_Log) Reset() { *x = Workflow_Stream_Log{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[237] + mi := &file_vtctldata_proto_msgTypes[239] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14957,7 +15069,7 @@ func (x *Workflow_Stream_Log) String() string { func (*Workflow_Stream_Log) ProtoMessage() {} func (x *Workflow_Stream_Log) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[237] + mi := &file_vtctldata_proto_msgTypes[239] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15041,7 +15153,7 @@ type Workflow_Stream_ThrottlerStatus struct { func (x *Workflow_Stream_ThrottlerStatus) Reset() { *x = Workflow_Stream_ThrottlerStatus{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[238] + mi := &file_vtctldata_proto_msgTypes[240] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15054,7 +15166,7 @@ func (x *Workflow_Stream_ThrottlerStatus) String() string { func (*Workflow_Stream_ThrottlerStatus) ProtoMessage() {} func (x *Workflow_Stream_ThrottlerStatus) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[238] + mi := &file_vtctldata_proto_msgTypes[240] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15095,7 +15207,7 @@ type ApplyVSchemaResponse_ParamList struct { func (x *ApplyVSchemaResponse_ParamList) Reset() { *x = ApplyVSchemaResponse_ParamList{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[241] + mi := &file_vtctldata_proto_msgTypes[243] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15108,7 +15220,7 @@ func (x *ApplyVSchemaResponse_ParamList) String() string { func (*ApplyVSchemaResponse_ParamList) ProtoMessage() {} func (x *ApplyVSchemaResponse_ParamList) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[241] + mi := &file_vtctldata_proto_msgTypes[243] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15142,7 +15254,7 @@ type GetSrvKeyspaceNamesResponse_NameList struct { func (x *GetSrvKeyspaceNamesResponse_NameList) Reset() { *x = GetSrvKeyspaceNamesResponse_NameList{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[249] + mi := &file_vtctldata_proto_msgTypes[252] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15155,7 +15267,7 @@ func (x *GetSrvKeyspaceNamesResponse_NameList) String() string { func (*GetSrvKeyspaceNamesResponse_NameList) ProtoMessage() {} func (x *GetSrvKeyspaceNamesResponse_NameList) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[249] + mi := &file_vtctldata_proto_msgTypes[252] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15168,7 +15280,7 @@ func (x *GetSrvKeyspaceNamesResponse_NameList) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSrvKeyspaceNamesResponse_NameList.ProtoReflect.Descriptor instead. func (*GetSrvKeyspaceNamesResponse_NameList) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{86, 1} + return file_vtctldata_proto_rawDescGZIP(), []int{88, 1} } func (x *GetSrvKeyspaceNamesResponse_NameList) GetNames() []string { @@ -15191,7 +15303,7 @@ type MoveTablesCreateResponse_TabletInfo struct { func (x *MoveTablesCreateResponse_TabletInfo) Reset() { *x = MoveTablesCreateResponse_TabletInfo{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[253] + mi := &file_vtctldata_proto_msgTypes[256] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15204,7 +15316,7 @@ func (x *MoveTablesCreateResponse_TabletInfo) String() string { func (*MoveTablesCreateResponse_TabletInfo) ProtoMessage() {} func (x *MoveTablesCreateResponse_TabletInfo) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[253] + mi := &file_vtctldata_proto_msgTypes[256] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15217,7 +15329,7 @@ func (x *MoveTablesCreateResponse_TabletInfo) ProtoReflect() protoreflect.Messag // Deprecated: Use MoveTablesCreateResponse_TabletInfo.ProtoReflect.Descriptor instead. func (*MoveTablesCreateResponse_TabletInfo) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{130, 0} + return file_vtctldata_proto_rawDescGZIP(), []int{132, 0} } func (x *MoveTablesCreateResponse_TabletInfo) GetTablet() *topodata.TabletAlias { @@ -15247,7 +15359,7 @@ type WorkflowDeleteResponse_TabletInfo struct { func (x *WorkflowDeleteResponse_TabletInfo) Reset() { *x = WorkflowDeleteResponse_TabletInfo{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[263] + mi := &file_vtctldata_proto_msgTypes[266] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15260,7 +15372,7 @@ func (x *WorkflowDeleteResponse_TabletInfo) String() string { func (*WorkflowDeleteResponse_TabletInfo) ProtoMessage() {} func (x *WorkflowDeleteResponse_TabletInfo) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[263] + mi := &file_vtctldata_proto_msgTypes[266] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15273,7 +15385,7 @@ func (x *WorkflowDeleteResponse_TabletInfo) ProtoReflect() protoreflect.Message // Deprecated: Use WorkflowDeleteResponse_TabletInfo.ProtoReflect.Descriptor instead. func (*WorkflowDeleteResponse_TabletInfo) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{225, 0} + return file_vtctldata_proto_rawDescGZIP(), []int{227, 0} } func (x *WorkflowDeleteResponse_TabletInfo) GetTablet() *topodata.TabletAlias { @@ -15306,7 +15418,7 @@ type WorkflowStatusResponse_TableCopyState struct { func (x *WorkflowStatusResponse_TableCopyState) Reset() { *x = WorkflowStatusResponse_TableCopyState{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[264] + mi := &file_vtctldata_proto_msgTypes[267] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15319,7 +15431,7 @@ func (x *WorkflowStatusResponse_TableCopyState) String() string { func (*WorkflowStatusResponse_TableCopyState) ProtoMessage() {} func (x *WorkflowStatusResponse_TableCopyState) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[264] + mi := &file_vtctldata_proto_msgTypes[267] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15332,7 +15444,7 @@ func (x *WorkflowStatusResponse_TableCopyState) ProtoReflect() protoreflect.Mess // Deprecated: Use WorkflowStatusResponse_TableCopyState.ProtoReflect.Descriptor instead. func (*WorkflowStatusResponse_TableCopyState) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{227, 0} + return file_vtctldata_proto_rawDescGZIP(), []int{229, 0} } func (x *WorkflowStatusResponse_TableCopyState) GetRowsCopied() int64 { @@ -15393,7 +15505,7 @@ type WorkflowStatusResponse_ShardStreamState struct { func (x *WorkflowStatusResponse_ShardStreamState) Reset() { *x = WorkflowStatusResponse_ShardStreamState{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[265] + mi := &file_vtctldata_proto_msgTypes[268] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15406,7 +15518,7 @@ func (x *WorkflowStatusResponse_ShardStreamState) String() string { func (*WorkflowStatusResponse_ShardStreamState) ProtoMessage() {} func (x *WorkflowStatusResponse_ShardStreamState) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[265] + mi := &file_vtctldata_proto_msgTypes[268] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15419,7 +15531,7 @@ func (x *WorkflowStatusResponse_ShardStreamState) ProtoReflect() protoreflect.Me // Deprecated: Use WorkflowStatusResponse_ShardStreamState.ProtoReflect.Descriptor instead. func (*WorkflowStatusResponse_ShardStreamState) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{227, 1} + return file_vtctldata_proto_rawDescGZIP(), []int{229, 1} } func (x *WorkflowStatusResponse_ShardStreamState) GetId() int32 { @@ -15475,7 +15587,7 @@ type WorkflowStatusResponse_ShardStreams struct { func (x *WorkflowStatusResponse_ShardStreams) Reset() { *x = WorkflowStatusResponse_ShardStreams{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[266] + mi := &file_vtctldata_proto_msgTypes[269] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15488,7 +15600,7 @@ func (x *WorkflowStatusResponse_ShardStreams) String() string { func (*WorkflowStatusResponse_ShardStreams) ProtoMessage() {} func (x *WorkflowStatusResponse_ShardStreams) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[266] + mi := &file_vtctldata_proto_msgTypes[269] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15501,7 +15613,7 @@ func (x *WorkflowStatusResponse_ShardStreams) ProtoReflect() protoreflect.Messag // Deprecated: Use WorkflowStatusResponse_ShardStreams.ProtoReflect.Descriptor instead. func (*WorkflowStatusResponse_ShardStreams) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{227, 2} + return file_vtctldata_proto_rawDescGZIP(), []int{229, 2} } func (x *WorkflowStatusResponse_ShardStreams) GetStreams() []*WorkflowStatusResponse_ShardStreamState { @@ -15525,7 +15637,7 @@ type WorkflowUpdateResponse_TabletInfo struct { func (x *WorkflowUpdateResponse_TabletInfo) Reset() { *x = WorkflowUpdateResponse_TabletInfo{} if protoimpl.UnsafeEnabled { - mi := &file_vtctldata_proto_msgTypes[269] + mi := &file_vtctldata_proto_msgTypes[272] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -15538,7 +15650,7 @@ func (x *WorkflowUpdateResponse_TabletInfo) String() string { func (*WorkflowUpdateResponse_TabletInfo) ProtoMessage() {} func (x *WorkflowUpdateResponse_TabletInfo) ProtoReflect() protoreflect.Message { - mi := &file_vtctldata_proto_msgTypes[269] + mi := &file_vtctldata_proto_msgTypes[272] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -15551,7 +15663,7 @@ func (x *WorkflowUpdateResponse_TabletInfo) ProtoReflect() protoreflect.Message // Deprecated: Use WorkflowUpdateResponse_TabletInfo.ProtoReflect.Descriptor instead. func (*WorkflowUpdateResponse_TabletInfo) Descriptor() ([]byte, []int) { - return file_vtctldata_proto_rawDescGZIP(), []int{231, 0} + return file_vtctldata_proto_rawDescGZIP(), []int{233, 0} } func (x *WorkflowUpdateResponse_TabletInfo) GetTablet() *topodata.TabletAlias { @@ -16523,951 +16635,1069 @@ var file_vtctldata_proto_rawDesc = []byte{ 0x3a, 0x0a, 0x0a, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x0a, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x4c, 0x0a, 0x0f, 0x47, - 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, - 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, - 0x61, 0x72, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x73, 0x68, 0x61, 0x72, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x0a, 0x10, 0x47, 0x65, 0x74, - 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, - 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, - 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x1d, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x22, 0x6a, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x13, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x72, 0x6f, - 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1a, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x11, 0x73, - 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, - 0x22, 0x32, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, - 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, - 0x65, 0x6c, 0x6c, 0x73, 0x22, 0xf3, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x0a, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x64, 0x0a, 0x1a, 0x47, + 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, + 0x73, 0x22, 0x83, 0x02, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x7d, 0x0a, 0x19, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x62, 0x79, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x42, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x68, 0x61, + 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x43, + 0x65, 0x6c, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x16, 0x73, 0x68, 0x61, 0x72, 0x64, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x43, 0x65, 0x6c, 0x6c, + 0x1a, 0x65, 0x0a, 0x1b, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x79, 0x43, 0x65, 0x6c, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x30, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4c, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x61, 0x72, + 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x3a, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x05, 0x73, 0x68, 0x61, + 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, + 0x64, 0x22, 0x1d, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x22, 0x6a, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x4a, 0x0a, 0x13, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, + 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x11, 0x73, 0x68, 0x61, 0x72, 0x64, + 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x22, 0x32, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4e, 0x61, 0x6d, 0x65, - 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x1a, 0x69, 0x0a, - 0x0a, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x45, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x20, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, - 0x4c, 0x69, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x4a, 0x0a, 0x16, 0x47, 0x65, - 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, + 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, + 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, + 0x22, 0xf3, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x47, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x31, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, + 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x1a, 0x69, 0x0a, 0x0a, 0x4e, 0x61, 0x6d, + 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x45, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x20, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, 0x4c, 0x69, 0x73, 0x74, + 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x4a, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, + 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, + 0x6c, 0x73, 0x22, 0xcc, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x59, + 0x0a, 0x0d, 0x73, 0x72, 0x76, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x73, 0x72, 0x76, + 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x1a, 0x56, 0x0a, 0x11, 0x53, 0x72, 0x76, + 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x72, 0x76, 0x4b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x22, 0xf8, 0x02, 0x0a, 0x1c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, + 0x74, 0x74, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, + 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, + 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x21, + 0x0a, 0x0c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x5f, 0x73, 0x65, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x63, 0x75, 0x73, + 0x74, 0x6f, 0x6d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x74, 0x12, 0x2d, 0x0a, 0x13, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x61, 0x73, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x73, 0x65, + 0x6c, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x41, + 0x73, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x53, 0x65, 0x6c, 0x66, 0x12, 0x2f, 0x0a, 0x14, 0x63, 0x68, + 0x65, 0x63, 0x6b, 0x5f, 0x61, 0x73, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x73, 0x68, 0x61, + 0x72, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x41, + 0x73, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x3f, 0x0a, 0x0d, 0x74, + 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x5f, 0x61, 0x70, 0x70, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x68, + 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x41, 0x70, 0x70, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x0c, + 0x74, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x41, 0x70, 0x70, 0x22, 0x1f, 0x0a, 0x1d, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0x0a, + 0x14, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x22, 0x4e, 0x0a, 0x15, 0x47, 0x65, 0x74, + 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x35, 0x0a, 0x0c, 0x73, 0x72, 0x76, 0x5f, 0x76, 0x5f, 0x73, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x2e, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x0a, 0x73, + 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x2d, 0x0a, 0x15, 0x47, 0x65, 0x74, + 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0xc5, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, + 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x0d, 0x73, 0x72, 0x76, 0x5f, 0x76, 0x5f, 0x73, 0x63, 0x68, + 0x65, 0x6d, 0x61, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x76, 0x74, 0x63, + 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x72, + 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, + 0x73, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x1a, 0x53, 0x0a, 0x10, 0x53, + 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x13, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x53, 0x72, 0x76, 0x56, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x4c, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, + 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, + 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, + 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x3d, + 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x22, 0xe8, 0x01, + 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x72, 0x69, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x73, 0x74, 0x72, + 0x69, 0x63, 0x74, 0x12, 0x3c, 0x0a, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, + 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, + 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, + 0x61, 0x73, 0x52, 0x0d, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, + 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x40, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, + 0x0a, 0x07, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x52, 0x07, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0x2c, 0x0a, 0x16, 0x47, 0x65, + 0x74, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x46, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x54, + 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x6f, + 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, + 0x22, 0x66, 0x0a, 0x0c, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x43, 0x65, 0x6c, 0x6c, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1a, 0x0a, 0x08, + 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, + 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x22, 0x2f, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x56, + 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x4d, 0x0a, 0x11, 0x47, 0x65, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, + 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x2e, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, + 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x42, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x56, + 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c, + 0x0a, 0x08, 0x76, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x11, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x52, 0x07, 0x76, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0xc6, 0x01, 0x0a, + 0x13, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0xcc, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x53, 0x72, - 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x59, 0x0a, 0x0d, 0x73, 0x72, 0x76, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x72, - 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x0c, 0x73, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x1a, 0x56, 0x0a, - 0x11, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, - 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xf8, 0x02, 0x0a, 0x1c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, + 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4f, 0x6e, 0x6c, + 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6e, 0x61, 0x6d, 0x65, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x1a, + 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0b, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, 0x49, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, + 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x13, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, + 0x22, 0xfb, 0x01, 0x0a, 0x17, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, + 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, + 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x52, + 0x0a, 0x1a, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x5f, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x17, 0x70, 0x72, 0x69, 0x6d, 0x61, + 0x72, 0x79, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, + 0x61, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x44, 0x0a, 0x15, 0x77, 0x61, 0x69, 0x74, + 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, + 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x77, 0x61, 0x69, 0x74, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x42, + 0x0a, 0x18, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, + 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, + 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x73, 0x22, 0x4e, 0x0a, 0x1c, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, + 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, + 0x69, 0x64, 0x22, 0xdf, 0x01, 0x0a, 0x1d, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, + 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x76, 0x0a, 0x16, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x61, 0x66, 0x66, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, + 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, 0x53, 0x68, 0x61, + 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x72, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x46, 0x0a, 0x18, + 0x52, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x22, 0xff, 0x02, 0x0a, 0x19, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1a, + 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, + 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, + 0x12, 0x29, 0x0a, 0x06, 0x76, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x11, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x52, 0x06, 0x76, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x42, 0x0a, 0x1e, 0x63, + 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, + 0x70, 0x79, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x1a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x41, 0x66, 0x74, + 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, + 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, + 0x06, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, + 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x1c, 0x0a, 0x1a, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, + 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x77, 0x0a, 0x1e, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, + 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x69, - 0x73, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x64, 0x69, 0x73, - 0x61, 0x62, 0x6c, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, - 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, - 0x6c, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x73, 0x65, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x0e, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x74, 0x12, - 0x2d, 0x0a, 0x13, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x61, 0x73, 0x5f, 0x63, 0x68, 0x65, 0x63, - 0x6b, 0x5f, 0x73, 0x65, 0x6c, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, 0x68, - 0x65, 0x63, 0x6b, 0x41, 0x73, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x53, 0x65, 0x6c, 0x66, 0x12, 0x2f, - 0x0a, 0x14, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x61, 0x73, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, - 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x63, 0x68, - 0x65, 0x63, 0x6b, 0x41, 0x73, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, - 0x3f, 0x0a, 0x0d, 0x74, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x5f, 0x61, 0x70, 0x70, - 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x41, 0x70, 0x70, 0x52, 0x75, - 0x6c, 0x65, 0x52, 0x0c, 0x74, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x41, 0x70, 0x70, - 0x22, 0x1f, 0x0a, 0x1d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, - 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x2a, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, - 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x22, 0x4e, 0x0a, - 0x15, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x0c, 0x73, 0x72, 0x76, 0x5f, 0x76, 0x5f, - 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, - 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x52, 0x0a, 0x73, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x2d, 0x0a, - 0x15, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0xc5, 0x01, 0x0a, - 0x16, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x0d, 0x73, 0x72, 0x76, 0x5f, 0x76, - 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, - 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x2e, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x52, 0x0b, 0x73, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x1a, - 0x53, 0x0a, 0x10, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x53, - 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4c, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, - 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, - 0x61, 0x73, 0x22, 0x3d, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x22, 0xe8, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, - 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, - 0x16, 0x0a, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x12, 0x3c, 0x0a, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0d, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, - 0x69, 0x61, 0x73, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, - 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x40, 0x0a, 0x12, - 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x07, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x07, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0x2c, - 0x0a, 0x16, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, - 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x46, 0x0a, 0x17, - 0x47, 0x65, 0x74, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, 0x68, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x04, - 0x63, 0x65, 0x6c, 0x6c, 0x22, 0x66, 0x0a, 0x0c, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, - 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x12, 0x0a, 0x04, - 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, - 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x22, 0x2f, 0x0a, 0x11, - 0x47, 0x65, 0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, + 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x4c, 0x0a, + 0x1f, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x29, 0x0a, 0x10, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x64, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x56, 0x0a, 0x18, 0x4d, + 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x08, 0x73, 0x65, 0x74, 0x74, 0x69, + 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x08, 0x73, 0x65, 0x74, 0x74, 0x69, + 0x6e, 0x67, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0xdd, 0x05, 0x0a, 0x14, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x27, + 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x6f, 0x75, 0x6e, 0x74, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, + 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x6c, 0x6c, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x6c, 0x6c, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x12, 0x28, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x6f, 0x6e, + 0x5f, 0x64, 0x64, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, 0x6e, 0x44, 0x64, + 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, + 0x63, 0x6f, 0x70, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x70, + 0x41, 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x12, 0x2a, 0x0a, 0x11, 0x64, 0x72, 0x6f, + 0x70, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x0e, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x64, 0x72, 0x6f, 0x70, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, + 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x65, 0x72, 0x5f, 0x73, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x0f, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, + 0x6f, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x5f, 0x72, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0e, 0x6e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x22, 0xe6, 0x01, 0x0a, 0x16, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x70, + 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x08, 0x6b, 0x65, 0x65, 0x70, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2c, 0x0a, + 0x12, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x6b, 0x65, 0x65, 0x70, 0x52, + 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, + 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x22, 0x5b, 0x0a, 0x17, 0x4d, 0x69, 0x67, + 0x72, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x26, + 0x0a, 0x0f, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x85, 0x01, 0x0a, 0x14, 0x4d, 0x6f, 0x75, 0x6e, 0x74, + 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x1b, 0x0a, 0x09, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, + 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0a, 0x74, 0x6f, 0x70, 0x6f, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x1b, 0x0a, + 0x09, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x17, + 0x0a, 0x15, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x0a, 0x16, 0x4d, 0x6f, 0x75, 0x6e, 0x74, + 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x55, 0x6e, + 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x26, 0x0a, 0x10, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x82, 0x01, 0x0a, 0x11, 0x4d, 0x6f, 0x75, + 0x6e, 0x74, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, + 0x0a, 0x09, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, + 0x6f, 0x70, 0x6f, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x74, 0x6f, 0x70, 0x6f, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, + 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x12, 0x0a, + 0x10, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x22, 0x29, 0x0a, 0x11, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0xbb, 0x06, 0x0a, + 0x17, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x27, 0x0a, + 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, + 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x68, + 0x61, 0x72, 0x64, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x6c, 0x6c, 0x5f, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x6c, + 0x6c, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x0d, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x25, + 0x0a, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x0c, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x5a, + 0x6f, 0x6e, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x6f, 0x6e, 0x5f, 0x64, 0x64, 0x6c, 0x18, 0x0d, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, 0x6e, 0x44, 0x64, 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74, + 0x6f, 0x70, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, 0x0e, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x41, 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f, + 0x70, 0x79, 0x12, 0x2a, 0x0a, 0x11, 0x64, 0x72, 0x6f, 0x70, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, + 0x67, 0x6e, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x64, + 0x72, 0x6f, 0x70, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x30, + 0x0a, 0x14, 0x64, 0x65, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, + 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, + 0x66, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, + 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x11, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, 0x6f, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, + 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x6e, 0x6f, 0x52, 0x6f, 0x75, + 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x74, 0x6f, + 0x6d, 0x69, 0x63, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, + 0x61, 0x74, 0x6f, 0x6d, 0x69, 0x63, 0x43, 0x6f, 0x70, 0x79, 0x22, 0xd5, 0x01, 0x0a, 0x18, 0x4d, + 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, + 0x79, 0x12, 0x48, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, + 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x55, 0x0a, 0x0a, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, + 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x64, 0x22, 0x81, 0x02, 0x0a, 0x19, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6b, 0x65, 0x65, 0x70, 0x44, 0x61, + 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x12, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, + 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, + 0x6b, 0x65, 0x65, 0x70, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, 0x5e, 0x0a, 0x1a, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x26, + 0x0a, 0x0f, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x4d, 0x0a, 0x11, 0x50, 0x69, 0x6e, 0x67, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x14, 0x0a, 0x12, 0x50, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd7, 0x02, 0x0a, 0x1b, + 0x50, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, + 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x36, 0x0a, + 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x50, 0x72, + 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x0d, 0x61, 0x76, 0x6f, 0x69, 0x64, 0x5f, 0x70, + 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, + 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, + 0x69, 0x61, 0x73, 0x52, 0x0c, 0x61, 0x76, 0x6f, 0x69, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, + 0x79, 0x12, 0x44, 0x0a, 0x15, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x13, 0x77, 0x61, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x4c, 0x0a, 0x19, 0x74, 0x6f, 0x6c, 0x65, 0x72, + 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x6c, 0x61, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, + 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x17, 0x74, 0x6f, + 0x6c, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x4c, 0x61, 0x67, 0x22, 0xba, 0x01, 0x0a, 0x1c, 0x50, 0x6c, 0x61, 0x6e, 0x6e, 0x65, + 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x40, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x6d, + 0x6f, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x6d, 0x6f, + 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x26, 0x0a, 0x06, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, + 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x73, 0x22, 0x74, 0x0a, 0x1b, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x4d, 0x0a, - 0x11, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, + 0x6c, 0x6c, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x6c, 0x6c, 0x6f, + 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x22, 0x1e, 0x0a, 0x1c, 0x52, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x32, 0x0a, 0x1a, 0x52, 0x65, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x1d, 0x0a, 0x1b, + 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, + 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, 0x0a, 0x13, 0x52, + 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, - 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x2e, 0x0a, 0x12, - 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x42, 0x0a, 0x12, - 0x47, 0x65, 0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x08, 0x76, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x4b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x07, 0x76, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x22, 0xc6, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6f, - 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x76, - 0x65, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x6f, 0x6e, - 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6e, 0x61, 0x6d, 0x65, 0x4f, 0x6e, - 0x6c, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x21, - 0x0a, 0x0c, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4c, 0x6f, 0x67, - 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, 0x49, 0x0a, 0x14, 0x47, 0x65, 0x74, - 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x31, 0x0a, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x73, 0x22, 0xfb, 0x01, 0x0a, 0x17, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x12, 0x52, 0x0a, 0x1a, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x17, 0x70, - 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x44, 0x0a, 0x15, - 0x77, 0x61, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x74, 0x69, - 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, - 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x77, - 0x61, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x54, 0x69, 0x6d, 0x65, 0x6f, - 0x75, 0x74, 0x22, 0x42, 0x0a, 0x18, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, - 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, - 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, - 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, - 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x4e, 0x0a, 0x1c, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, 0xdf, 0x01, 0x0a, 0x1d, 0x4c, 0x61, 0x75, 0x6e, 0x63, - 0x68, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x76, 0x0a, 0x16, 0x72, 0x6f, 0x77, 0x73, - 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x2e, 0x52, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, - 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x72, 0x6f, 0x77, - 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x1a, 0x46, 0x0a, 0x18, 0x52, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, - 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, - 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, - 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xff, 0x02, 0x0a, 0x19, 0x4c, 0x6f, 0x6f, - 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x14, - 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, - 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x29, 0x0a, 0x06, 0x76, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x4b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x06, 0x76, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, - 0x42, 0x0a, 0x1e, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x5f, 0x61, 0x66, 0x74, 0x65, - 0x72, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x77, 0x6e, 0x65, - 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x1a, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, - 0x65, 0x41, 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x57, 0x69, 0x74, 0x68, 0x4f, 0x77, - 0x6e, 0x65, 0x72, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, - 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, - 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, - 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x22, 0x1c, 0x0a, 0x1a, 0x4c, 0x6f, - 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x77, 0x0a, 0x1e, 0x4c, 0x6f, 0x6f, 0x6b, - 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x69, 0x7a, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0d, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x22, 0x4c, 0x0a, 0x1f, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, - 0x78, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, - 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, - 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, - 0x56, 0x0a, 0x18, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x72, - 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x08, 0x73, - 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, - 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x08, 0x73, - 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x4d, 0x61, 0x74, 0x65, 0x72, - 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xdd, 0x05, 0x0a, 0x14, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, - 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x09, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, - 0x6c, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, - 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x18, 0x06, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, - 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, - 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, - 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x6c, 0x6c, 0x5f, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x6c, 0x6c, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, - 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, - 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x25, 0x0a, - 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, - 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, 0x61, - 0x62, 0x6c, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, - 0x69, 0x6d, 0x65, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x15, - 0x0a, 0x06, 0x6f, 0x6e, 0x5f, 0x64, 0x64, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x6f, 0x6e, 0x44, 0x64, 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x61, 0x66, - 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, - 0x73, 0x74, 0x6f, 0x70, 0x41, 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x12, 0x2a, 0x0a, - 0x11, 0x64, 0x72, 0x6f, 0x70, 0x5f, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6b, 0x65, - 0x79, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x64, 0x72, 0x6f, 0x70, 0x46, 0x6f, - 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, 0x66, - 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, - 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, 0x65, - 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, - 0x75, 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x09, 0x61, 0x75, 0x74, 0x6f, 0x53, 0x74, 0x61, 0x72, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, - 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x11, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x6e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, - 0x75, 0x6c, 0x65, 0x73, 0x22, 0xe6, 0x01, 0x0a, 0x16, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, - 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x64, 0x61, 0x74, - 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6b, 0x65, 0x65, 0x70, 0x44, 0x61, 0x74, - 0x61, 0x12, 0x2c, 0x0a, 0x12, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, - 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x6b, - 0x65, 0x65, 0x70, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, - 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x54, 0x61, - 0x62, 0x6c, 0x65, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x22, 0x5b, 0x0a, - 0x17, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, - 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, - 0x72, 0x79, 0x12, 0x26, 0x0a, 0x0f, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x72, 0x65, - 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x72, 0x79, - 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x85, 0x01, 0x0a, 0x14, 0x4d, - 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x6f, 0x70, 0x6f, 0x53, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x12, - 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x22, 0x17, 0x0a, 0x15, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, - 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x0a, 0x16, 0x4d, - 0x6f, 0x75, 0x6e, 0x74, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x6f, 0x75, - 0x6e, 0x74, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0x0a, 0x10, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, - 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x82, 0x01, 0x0a, - 0x11, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x74, 0x6f, 0x70, 0x6f, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x6f, 0x70, 0x6f, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x6f, 0x70, 0x6f, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x12, 0x0a, - 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, - 0x65, 0x22, 0x12, 0x0a, 0x10, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x29, 0x0a, 0x11, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, - 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x22, 0xbb, 0x06, 0x0a, 0x17, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, - 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, - 0x6c, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, - 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x18, 0x05, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, - 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, - 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, - 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x12, 0x1d, 0x0a, 0x0a, - 0x61, 0x6c, 0x6c, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x09, 0x61, 0x6c, 0x6c, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x09, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0d, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c, - 0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x65, 0x78, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x0a, - 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x7a, 0x6f, 0x6e, - 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x54, - 0x69, 0x6d, 0x65, 0x5a, 0x6f, 0x6e, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x6f, 0x6e, 0x5f, 0x64, 0x64, - 0x6c, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, 0x6e, 0x44, 0x64, 0x6c, 0x12, 0x26, - 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x70, - 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x41, 0x66, 0x74, - 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x12, 0x2a, 0x0a, 0x11, 0x64, 0x72, 0x6f, 0x70, 0x5f, 0x66, - 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0f, 0x64, 0x72, 0x6f, 0x70, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4b, 0x65, - 0x79, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, - 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, - 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, 0x6f, 0x53, 0x74, - 0x61, 0x72, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x6f, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, - 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x6e, - 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x1f, 0x0a, - 0x0b, 0x61, 0x74, 0x6f, 0x6d, 0x69, 0x63, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, 0x13, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x0a, 0x61, 0x74, 0x6f, 0x6d, 0x69, 0x63, 0x43, 0x6f, 0x70, 0x79, 0x22, 0xd5, - 0x01, 0x0a, 0x18, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, - 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, - 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x48, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, - 0x55, 0x0a, 0x0a, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, - 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x16, 0x0a, 0x14, + 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x64, 0x0a, 0x1a, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x83, 0x01, 0x0a, 0x1b, 0x52, + 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x79, 0x53, 0x68, 0x61, + 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x69, 0x73, + 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x12, 0x36, 0x0a, 0x17, 0x70, 0x61, 0x72, 0x74, + 0x69, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x5f, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x70, 0x61, 0x72, 0x74, 0x69, + 0x61, 0x6c, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x22, 0x4f, 0x0a, 0x13, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, - 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, - 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x63, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x22, 0x81, 0x02, 0x0a, 0x19, 0x4d, 0x6f, 0x76, 0x65, 0x54, - 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, - 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x65, - 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6b, 0x65, - 0x65, 0x70, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x12, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x72, - 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x10, 0x6b, 0x65, 0x65, 0x70, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, - 0x75, 0x6c, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x6e, - 0x61, 0x6d, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, - 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, - 0x75, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x08, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, 0x5e, 0x0a, 0x1a, 0x4d, 0x6f, - 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, - 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, - 0x72, 0x79, 0x12, 0x26, 0x0a, 0x0f, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x72, 0x65, - 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x72, 0x79, - 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x4d, 0x0a, 0x11, 0x50, 0x69, - 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x14, 0x0a, 0x12, 0x50, 0x69, 0x6e, - 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0xd7, 0x02, 0x0a, 0x1b, 0x50, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, - 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, - 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, - 0x64, 0x12, 0x36, 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x6e, - 0x65, 0x77, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x0d, 0x61, 0x76, 0x6f, - 0x69, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0c, 0x61, 0x76, 0x6f, 0x69, 0x64, 0x50, 0x72, - 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x44, 0x0a, 0x15, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x72, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x77, 0x61, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x73, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x4c, 0x0a, 0x19, 0x74, - 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, - 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x17, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x61, 0x67, 0x22, 0xba, 0x01, 0x0a, 0x1c, 0x50, 0x6c, - 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, + 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, + 0x73, 0x22, 0x16, 0x0a, 0x14, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa9, 0x01, 0x0a, 0x1b, 0x52, 0x65, + 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x61, + 0x69, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x69, 0x6d, + 0x61, 0x72, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x63, 0x79, 0x22, 0x46, 0x0a, 0x1c, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xbc, 0x01, + 0x0a, 0x18, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x40, 0x0a, 0x10, - 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0f, 0x70, - 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x26, - 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, - 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, - 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x74, 0x0a, 0x1b, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, - 0x64, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, - 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, - 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x22, 0x1e, 0x0a, 0x1c, - 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, - 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x32, 0x0a, 0x1a, - 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, - 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, - 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, - 0x22, 0x1d, 0x0a, 0x1b, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x4f, 0x0a, 0x13, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, - 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, - 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, - 0x22, 0x16, 0x0a, 0x14, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x64, 0x0a, 0x1a, 0x52, 0x65, 0x66, 0x72, - 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x83, - 0x01, 0x0a, 0x1b, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, - 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c, - 0x0a, 0x12, 0x69, 0x73, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x66, - 0x72, 0x65, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x73, 0x50, 0x61, - 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x12, 0x36, 0x0a, 0x17, - 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x5f, - 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x70, - 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x22, 0x4f, 0x0a, 0x13, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x16, 0x0a, 0x14, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa9, 0x01, - 0x0a, 0x1b, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x61, 0x69, - 0x74, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, - 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, - 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, - 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, - 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x63, 0x6f, - 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x22, 0x46, 0x0a, 0x1c, 0x52, 0x65, 0x6c, - 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x65, 0x76, 0x65, - 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x23, 0x0a, 0x0d, + 0x77, 0x61, 0x69, 0x74, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x70, 0x72, 0x69, + 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x64, 0x65, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, + 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x22, 0x43, 0x0a, 0x19, + 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x65, 0x76, 0x65, + 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, - 0x73, 0x22, 0xbc, 0x01, 0x0a, 0x18, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, - 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, - 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, - 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x77, 0x61, 0x69, 0x74, 0x50, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, - 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, - 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x20, - 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, - 0x22, 0x43, 0x0a, 0x19, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, - 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, - 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, - 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x5b, 0x0a, 0x13, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x42, - 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, - 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, - 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x12, - 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x22, 0x16, 0x0a, 0x14, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, - 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7f, 0x0a, 0x19, 0x52, 0x65, - 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x1c, 0x0a, - 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x22, 0x1c, 0x0a, 0x1a, 0x52, - 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, - 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9b, 0x01, 0x0a, 0x16, 0x52, 0x65, - 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x61, 0x72, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, - 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, - 0x65, 0x6c, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x73, 0x22, 0x5b, 0x0a, 0x13, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, + 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x16, + 0x0a, 0x14, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7f, 0x0a, 0x19, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, + 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, + 0x65, 0x6c, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, - 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, - 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x22, 0x19, 0x0a, 0x17, 0x52, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x46, 0x0a, 0x15, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, - 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, - 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x22, 0x7b, 0x0a, 0x16, 0x52, 0x65, - 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x2f, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, - 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x07, - 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x8f, 0x04, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x68, - 0x61, 0x72, 0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x1a, 0x0a, 0x08, - 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x12, 0x23, 0x0a, - 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x04, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, - 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, - 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, - 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, - 0x28, 0x0a, 0x10, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x63, - 0x6f, 0x70, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x73, 0x6b, 0x69, 0x70, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x43, 0x6f, 0x70, 0x79, 0x12, 0x15, 0x0a, 0x06, 0x6f, 0x6e, 0x5f, - 0x64, 0x64, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, 0x6e, 0x44, 0x64, 0x6c, - 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x63, - 0x6f, 0x70, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x41, - 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x70, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x65, - 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, - 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, 0x65, 0x63, - 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, - 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, - 0x61, 0x75, 0x74, 0x6f, 0x53, 0x74, 0x61, 0x72, 0x74, 0x22, 0x82, 0x02, 0x0a, 0x18, 0x52, 0x65, - 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, - 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, - 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, - 0x12, 0x2d, 0x0a, 0x0b, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, - 0x69, 0x6d, 0x65, 0x52, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x12, - 0x24, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x70, 0x6f, - 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, - 0x54, 0x6f, 0x50, 0x6f, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x12, 0x3e, - 0x0a, 0x14, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, - 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x12, 0x72, 0x65, 0x73, 0x74, - 0x6f, 0x72, 0x65, 0x54, 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0xad, - 0x01, 0x0a, 0x19, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, - 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x0c, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x24, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, - 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, - 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x4d, - 0x0a, 0x1b, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, - 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, 0xdd, 0x01, - 0x0a, 0x1c, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x75, - 0x0a, 0x16, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, - 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x40, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, - 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, - 0x52, 0x13, 0x72, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, - 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x46, 0x0a, 0x18, 0x52, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, - 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, - 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x51, 0x0a, - 0x15, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, - 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, - 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, - 0x22, 0x18, 0x0a, 0x16, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, - 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6d, 0x0a, 0x22, 0x53, 0x65, - 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, - 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, + 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x22, 0x1c, 0x0a, 0x1a, 0x52, 0x65, 0x6d, 0x6f, 0x76, + 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9b, 0x01, 0x0a, 0x16, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x2b, 0x0a, 0x11, - 0x64, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, - 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, - 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x22, 0x55, 0x0a, 0x23, 0x53, 0x65, 0x74, - 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, - 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x2e, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x22, 0x5e, 0x0a, 0x1e, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, + 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x73, 0x68, 0x61, 0x72, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, + 0x65, 0x6c, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x12, + 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, + 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, + 0x76, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, + 0x69, 0x76, 0x65, 0x22, 0x19, 0x0a, 0x17, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, 0x61, + 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, + 0x0a, 0x15, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x22, 0x7b, 0x0a, 0x16, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, + 0x72, 0x64, 0x12, 0x2f, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x07, 0x70, 0x72, 0x69, 0x6d, + 0x61, 0x72, 0x79, 0x22, 0x8f, 0x04, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x68, 0x61, 0x72, 0x64, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x12, 0x14, + 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, + 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, + 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, + 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, + 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x73, + 0x6b, 0x69, 0x70, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x73, 0x6b, 0x69, 0x70, 0x53, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x43, 0x6f, 0x70, 0x79, 0x12, 0x15, 0x0a, 0x06, 0x6f, 0x6e, 0x5f, 0x64, 0x64, 0x6c, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, 0x6e, 0x44, 0x64, 0x6c, 0x12, 0x26, 0x0a, 0x0f, + 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x41, 0x66, 0x74, 0x65, 0x72, + 0x43, 0x6f, 0x70, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x64, 0x65, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x12, 0x64, 0x65, 0x66, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, + 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, 0x6f, + 0x53, 0x74, 0x61, 0x72, 0x74, 0x22, 0x82, 0x02, 0x0a, 0x18, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, + 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, + 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, + 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x2d, 0x0a, 0x0b, + 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, + 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, + 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x70, 0x6f, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x54, 0x6f, 0x50, 0x6f, + 0x73, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x12, 0x3e, 0x0a, 0x14, 0x72, 0x65, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x12, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x54, + 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0xad, 0x01, 0x0a, 0x19, 0x52, + 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, + 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, + 0x61, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x12, 0x24, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x4d, 0x0a, 0x1b, 0x52, 0x65, + 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, 0xdd, 0x01, 0x0a, 0x1c, 0x52, 0x65, + 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x75, 0x0a, 0x16, 0x72, 0x6f, + 0x77, 0x73, 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x5f, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x40, 0x2e, 0x76, 0x74, 0x63, + 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x72, 0x6f, + 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x1a, 0x46, 0x0a, 0x18, 0x52, 0x6f, 0x77, 0x73, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, + 0x64, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x51, 0x0a, 0x15, 0x52, 0x75, 0x6e, + 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, + 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, + 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x18, 0x0a, 0x16, + 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6d, 0x0a, 0x22, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, + 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x75, 0x72, 0x61, + 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, + 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x22, 0x55, 0x0a, 0x23, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, 0x6f, + 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x08, + 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, + 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x5e, 0x0a, 0x1e, + 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, + 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, + 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x51, 0x0a, 0x1f, + 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x2e, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, + 0x72, 0x0a, 0x1f, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, + 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, - 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, - 0x6f, 0x72, 0x63, 0x65, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, - 0x22, 0x51, 0x0a, 0x1f, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x22, 0x72, 0x0a, 0x1f, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, + 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, + 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x6e, 0x67, 0x22, 0x49, 0x0a, 0x20, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x73, - 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, - 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x22, 0x49, 0x0a, 0x20, 0x53, 0x65, 0x74, 0x53, 0x68, - 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, - 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, - 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, - 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x22, 0x8e, 0x02, 0x0a, 0x1c, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x8e, + 0x02, 0x0a, 0x1c, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, + 0x64, 0x12, 0x35, 0x0a, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, + 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x23, + 0x0a, 0x0d, 0x64, 0x65, 0x6e, 0x69, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x6e, 0x69, 0x65, 0x64, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x13, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x6d, 0x6f, 0x76, + 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x22, + 0x46, 0x0a, 0x1d, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x6a, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x57, 0x72, + 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, + 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x72, 0x69, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x77, 0x72, 0x69, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x22, 0x15, 0x0a, 0x13, 0x53, 0x65, 0x74, 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x88, 0x01, 0x0a, 0x1a, 0x53, + 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, + 0x64, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x38, 0x0a, 0x0c, 0x74, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x1d, 0x0a, 0x1b, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x62, 0x0a, 0x1a, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x22, 0x54, 0x0a, 0x1b, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x54, + 0x0a, 0x20, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x22, 0xaa, 0x03, 0x0a, 0x21, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x78, 0x0a, 0x14, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x45, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x6d, + 0x61, 0x70, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x4d, 0x61, 0x70, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x4d, 0x61, 0x70, + 0x1a, 0x5f, 0x0a, 0x18, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2d, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x1a, 0x4e, 0x0a, 0x0e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x4d, 0x61, 0x70, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x22, 0x8b, 0x01, 0x0a, 0x1d, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x35, 0x0a, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, - 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, - 0x6c, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x6e, 0x69, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x6e, 0x69, 0x65, - 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x64, 0x69, 0x73, 0x61, 0x62, - 0x6c, 0x65, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, - 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x72, 0x65, 0x6d, - 0x6f, 0x76, 0x65, 0x22, 0x46, 0x0a, 0x1d, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x6a, 0x0a, 0x12, 0x53, - 0x65, 0x74, 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, - 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x77, - 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x77, - 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x15, 0x0a, 0x13, 0x53, 0x65, 0x74, 0x57, 0x72, - 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x88, - 0x01, 0x0a, 0x1a, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, - 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x1d, 0x0a, 0x1b, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x62, 0x0a, 0x1a, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x22, 0x54, 0x0a, 0x1b, - 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x46, 0x69, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x65, - 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x6f, 0x70, - 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, - 0x6f, 0x72, 0x22, 0x54, 0x0a, 0x20, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, + 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, + 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, + 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, + 0x20, 0x0a, 0x1e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x7c, 0x0a, 0x12, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, + 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, + 0x73, 0x12, 0x2c, 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0x15, 0x0a, 0x13, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xf0, 0x01, 0x0a, 0x15, 0x53, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, + 0x72, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x03, 0x75, 0x69, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, + 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x12, 0x2f, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, + 0x65, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x52, 0x61, 0x6e, 0x67, + 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x22, 0x3f, 0x0a, 0x16, 0x53, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x5e, 0x0a, 0x18, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0xaa, 0x03, 0x0a, 0x21, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x78, - 0x0a, 0x14, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x45, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x12, 0x5a, 0x0a, 0x0a, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x5f, 0x6d, 0x61, 0x70, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x4d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x4d, 0x61, 0x70, 0x1a, 0x5f, 0x0a, 0x18, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, - 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, - 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x17, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4e, 0x0a, 0x0e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x4d, - 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x8b, 0x01, 0x0a, 0x1d, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x75, 0x69, 0x64, 0x22, 0x42, 0x0a, 0x19, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x53, + 0x0a, 0x17, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, - 0x69, 0x61, 0x73, 0x22, 0x20, 0x0a, 0x1e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x7c, 0x0a, 0x12, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x2c, 0x0a, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, - 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x64, 0x75, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x22, 0x15, 0x0a, 0x13, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xf0, 0x01, 0x0a, 0x15, 0x53, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x52, 0x65, 0x71, + 0x69, 0x61, 0x73, 0x22, 0x1a, 0x0a, 0x18, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x52, 0x0a, 0x16, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, + 0x69, 0x61, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x52, + 0x0a, 0x21, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x22, 0xc6, 0x01, 0x0a, 0x22, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, + 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x36, 0x0a, 0x0b, 0x6e, + 0x65, 0x77, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x50, 0x72, 0x69, 0x6d, + 0x61, 0x72, 0x79, 0x12, 0x36, 0x0a, 0x0b, 0x6f, 0x6c, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, + 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, + 0x0a, 0x6f, 0x6c, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x5c, 0x0a, 0x15, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x63, 0x65, 0x6c, 0x6c, + 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, + 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x08, 0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x5d, 0x0a, 0x16, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x63, 0x65, 0x6c, 0x6c, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70, + 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, + 0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x64, 0x0a, 0x17, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x0b, 0x63, 0x65, 0x6c, 0x6c, 0x73, + 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, + 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, + 0x61, 0x73, 0x52, 0x0a, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x65, + 0x0a, 0x18, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, + 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x35, + 0x0a, 0x0b, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, + 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x63, 0x65, 0x6c, 0x6c, 0x73, + 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x34, 0x0a, 0x0f, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x69, 0x6e, 0x67, + 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, + 0x70, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0xfb, 0x01, 0x0a, 0x10, + 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x62, 0x0a, 0x13, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x72, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x1a, 0x69, + 0x0a, 0x16, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x39, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x58, 0x0a, 0x17, 0x56, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x03, 0x75, 0x69, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x68, 0x61, 0x72, - 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x12, 0x2f, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x72, 0x61, 0x6e, 0x67, - 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, - 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x22, 0x3f, 0x0a, - 0x16, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x5e, - 0x0a, 0x18, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x10, 0x0a, 0x03, - 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x75, 0x69, 0x64, 0x22, 0x42, - 0x0a, 0x19, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, - 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, - 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x22, 0x53, 0x0a, 0x17, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, - 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x1a, 0x0a, 0x18, 0x53, 0x74, 0x61, 0x72, 0x74, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x52, 0x0a, 0x16, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, - 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x53, 0x74, 0x6f, 0x70, 0x52, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x52, 0x0a, 0x21, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x22, 0xc6, 0x01, 0x0a, 0x22, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, - 0x65, 0x6e, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, - 0x36, 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x6e, 0x65, 0x77, - 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x36, 0x0a, 0x0b, 0x6f, 0x6c, 0x64, 0x5f, 0x70, - 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, - 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, - 0x69, 0x61, 0x73, 0x52, 0x0a, 0x6f, 0x6c, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x22, - 0x5c, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, - 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2f, 0x0a, 0x09, - 0x63, 0x65, 0x6c, 0x6c, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x12, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x5d, 0x0a, - 0x16, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x63, - 0x65, 0x6c, 0x6c, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, - 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, - 0x66, 0x6f, 0x52, 0x08, 0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x64, 0x0a, 0x17, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x0b, 0x63, - 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, - 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, - 0x61, 0x73, 0x22, 0x65, 0x0a, 0x18, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, - 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, - 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x0b, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x61, 0x6c, 0x69, 0x61, - 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x63, - 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x34, 0x0a, 0x0f, 0x56, 0x61, 0x6c, - 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, - 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x0b, 0x70, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, - 0xfb, 0x01, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x62, - 0x0a, 0x13, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x6b, 0x65, 0x79, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x76, 0x74, + 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x73, 0x22, 0xfc, 0x01, 0x0a, 0x18, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x61, 0x0a, 0x10, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x63, 0x0a, + 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0xd8, 0x01, 0x0a, 0x1d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, + 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x5f, 0x76, 0x69, 0x65, 0x77, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, + 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x56, 0x69, 0x65, 0x77, 0x73, 0x12, 0x26, 0x0a, 0x0f, + 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x6e, 0x6f, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x6b, 0x69, 0x70, 0x4e, 0x6f, 0x50, 0x72, 0x69, + 0x6d, 0x61, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, + 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x56, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x88, 0x02, + 0x0a, 0x1e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x67, 0x0a, 0x10, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x1a, 0x63, 0x0a, 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, + 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, - 0x42, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x11, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x1a, 0x69, 0x0a, 0x16, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, - 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x39, - 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, - 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x58, 0x0a, - 0x17, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x69, 0x6e, 0x67, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0xfc, 0x01, 0x0a, 0x18, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x6b, 0x0a, 0x14, 0x56, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, + 0x72, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x69, 0x6e, 0x67, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0x31, 0x0a, 0x15, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, + 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x3c, 0x0a, 0x1e, 0x56, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x8a, 0x02, 0x0a, 0x1f, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x73, 0x12, 0x68, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, + 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3e, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x63, + 0x0a, 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x4f, 0x0a, 0x1b, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x22, 0x38, 0x0a, 0x1c, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x61, - 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x98, + 0x01, 0x0a, 0x16, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x12, 0x25, 0x0a, + 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, + 0x76, 0x69, 0x65, 0x77, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x69, 0x6e, 0x63, + 0x6c, 0x75, 0x64, 0x65, 0x56, 0x69, 0x65, 0x77, 0x73, 0x22, 0xfa, 0x01, 0x0a, 0x17, 0x56, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, + 0x60, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, + 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x63, 0x0a, 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, @@ -17476,376 +17706,281 @@ var file_vtctldata_proto_rawDesc = []byte{ 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd8, 0x01, 0x0a, 0x1d, 0x56, 0x61, 0x6c, 0x69, 0x64, - 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, - 0x63, 0x6c, 0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x76, 0x69, 0x65, 0x77, 0x73, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x0c, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x56, 0x69, 0x65, 0x77, 0x73, - 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x6e, 0x6f, 0x5f, 0x70, 0x72, 0x69, 0x6d, - 0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x6b, 0x69, 0x70, 0x4e, - 0x6f, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, - 0x75, 0x64, 0x65, 0x5f, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x56, 0x73, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x22, 0x88, 0x02, 0x0a, 0x1e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x67, - 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, - 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x63, 0x0a, 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, - 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, - 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, - 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x6b, 0x0a, 0x14, - 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x69, - 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0x31, 0x0a, 0x15, 0x56, 0x61, 0x6c, - 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x3c, 0x0a, 0x1e, - 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, - 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x8a, 0x02, 0x0a, 0x1f, 0x56, - 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, - 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x68, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, - 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, - 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, - 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x1a, 0x63, 0x0a, 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x76, 0x74, 0x63, - 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4f, 0x0a, 0x1b, 0x56, 0x61, 0x6c, 0x69, 0x64, - 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x38, 0x0a, 0x1c, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, - 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, - 0x74, 0x73, 0x22, 0x98, 0x01, 0x0a, 0x16, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, - 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c, 0x75, - 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x63, 0x6c, - 0x75, 0x64, 0x65, 0x5f, 0x76, 0x69, 0x65, 0x77, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x0c, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x56, 0x69, 0x65, 0x77, 0x73, 0x22, 0xfa, 0x01, - 0x0a, 0x17, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, - 0x6c, 0x74, 0x73, 0x12, 0x60, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, - 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, - 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, - 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x63, 0x0a, 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, - 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, - 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, - 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, - 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x88, 0x07, 0x0a, 0x12, 0x56, - 0x44, 0x69, 0x66, 0x66, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, - 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x21, 0x0a, - 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x05, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x73, - 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x18, 0x06, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, - 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, - 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, - 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, - 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, - 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x55, 0x0a, 0x1e, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, - 0x64, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x61, - 0x69, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, - 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x1b, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x61, 0x69, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, - 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0a, 0x64, 0x65, 0x62, 0x75, 0x67, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1a, 0x0a, - 0x09, 0x6f, 0x6e, 0x6c, 0x79, 0x5f, 0x70, 0x5f, 0x6b, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x07, 0x6f, 0x6e, 0x6c, 0x79, 0x50, 0x4b, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x75, 0x70, 0x64, - 0x61, 0x74, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, - 0x0d, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x19, 0x6d, 0x61, 0x78, 0x5f, 0x65, - 0x78, 0x74, 0x72, 0x61, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x6f, 0x6d, - 0x70, 0x61, 0x72, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x6d, 0x61, 0x78, 0x45, - 0x78, 0x74, 0x72, 0x61, 0x52, 0x6f, 0x77, 0x73, 0x54, 0x6f, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, - 0x65, 0x12, 0x12, 0x0a, 0x04, 0x77, 0x61, 0x69, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x04, 0x77, 0x61, 0x69, 0x74, 0x12, 0x42, 0x0a, 0x14, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x75, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x10, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x12, 0x77, 0x61, 0x69, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, - 0x6f, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, - 0x75, 0x74, 0x6f, 0x52, 0x65, 0x74, 0x72, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x62, - 0x6f, 0x73, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, - 0x73, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, - 0x5f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x13, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x13, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x53, 0x61, 0x6d, - 0x70, 0x6c, 0x65, 0x52, 0x6f, 0x77, 0x73, 0x12, 0x3c, 0x0a, 0x11, 0x6d, 0x61, 0x78, 0x5f, 0x64, - 0x69, 0x66, 0x66, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x14, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x6d, 0x61, 0x78, 0x44, 0x69, 0x66, 0x66, 0x44, 0x75, 0x72, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x29, 0x0a, 0x13, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x72, - 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x55, 0x55, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x55, 0x55, 0x49, 0x44, - 0x22, 0x6b, 0x0a, 0x12, 0x56, 0x44, 0x69, 0x66, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x88, 0x07, 0x0a, 0x12, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, + 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x6c, 0x0a, 0x1b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, + 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, + 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x19, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x08, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6c, + 0x69, 0x6d, 0x69, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x12, 0x55, 0x0a, 0x1e, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x5f, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x74, + 0x69, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, + 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x1b, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x65, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x57, 0x61, 0x69, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x65, 0x62, 0x75, + 0x67, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x64, + 0x65, 0x62, 0x75, 0x67, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1a, 0x0a, 0x09, 0x6f, 0x6e, 0x6c, + 0x79, 0x5f, 0x70, 0x5f, 0x6b, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x6f, 0x6e, + 0x6c, 0x79, 0x50, 0x4b, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x10, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x74, + 0x61, 0x74, 0x73, 0x12, 0x38, 0x0a, 0x19, 0x6d, 0x61, 0x78, 0x5f, 0x65, 0x78, 0x74, 0x72, 0x61, + 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, + 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x6d, 0x61, 0x78, 0x45, 0x78, 0x74, 0x72, 0x61, + 0x52, 0x6f, 0x77, 0x73, 0x54, 0x6f, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x12, 0x12, 0x0a, + 0x04, 0x77, 0x61, 0x69, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x77, 0x61, 0x69, + 0x74, 0x12, 0x42, 0x0a, 0x14, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x12, 0x77, 0x61, 0x69, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x74, + 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x72, 0x65, + 0x74, 0x72, 0x79, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x75, 0x74, 0x6f, 0x52, + 0x65, 0x74, 0x72, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x18, + 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x12, 0x33, + 0x0a, 0x16, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x73, 0x61, 0x6d, + 0x70, 0x6c, 0x65, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x13, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, + 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, + 0x6f, 0x77, 0x73, 0x12, 0x3c, 0x0a, 0x11, 0x6d, 0x61, 0x78, 0x5f, 0x64, 0x69, 0x66, 0x66, 0x5f, + 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, + 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x0f, 0x6d, 0x61, 0x78, 0x44, 0x69, 0x66, 0x66, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x29, 0x0a, 0x13, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x55, 0x55, 0x49, 0x44, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x55, 0x55, 0x49, 0x44, 0x22, 0x6b, 0x0a, 0x12, + 0x56, 0x44, 0x69, 0x66, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, + 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x72, 0x67, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x61, 0x72, 0x67, 0x22, 0x15, 0x0a, 0x13, 0x56, 0x44, 0x69, + 0x66, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x6d, 0x0a, 0x12, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, - 0x72, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x61, 0x72, 0x67, 0x22, 0x15, 0x0a, - 0x13, 0x56, 0x44, 0x69, 0x66, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6d, 0x0a, 0x12, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, - 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, + 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, + 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, + 0x15, 0x0a, 0x13, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x69, 0x0a, 0x10, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, + 0x68, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, - 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, - 0x75, 0x69, 0x64, 0x22, 0x15, 0x0a, 0x13, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x75, - 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x69, 0x0a, 0x10, 0x56, 0x44, - 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, - 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, - 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x72, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x03, 0x61, 0x72, 0x67, 0x22, 0xd7, 0x01, 0x0a, 0x11, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, - 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x10, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x1a, 0x64, 0x0a, 0x14, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, - 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, - 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, - 0x6b, 0x0a, 0x10, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, - 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, - 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, 0x13, 0x0a, 0x11, - 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0xb2, 0x01, 0x0a, 0x15, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6b, 0x65, 0x65, 0x70, 0x44, 0x61, 0x74, 0x61, - 0x12, 0x2c, 0x0a, 0x12, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, - 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x6b, 0x65, - 0x65, 0x70, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x16, - 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, - 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, 0xd1, 0x01, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x46, 0x0a, 0x07, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x1a, 0x55, 0x0a, 0x0a, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, 0x66, - 0x6f, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x67, 0x0a, 0x15, 0x57, 0x6f, - 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, - 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x16, 0x0a, 0x06, 0x73, - 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x73, 0x22, 0xe6, 0x07, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5f, - 0x0a, 0x10, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x73, 0x74, 0x61, - 0x74, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, - 0x58, 0x0a, 0x0d, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, - 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, - 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x72, 0x61, - 0x66, 0x66, 0x69, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0c, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x53, 0x74, 0x61, 0x74, 0x65, 0x1a, 0xe8, - 0x01, 0x0a, 0x0e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x72, 0x6f, 0x77, 0x73, 0x43, 0x6f, 0x70, 0x69, - 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x6f, 0x77, 0x73, 0x54, 0x6f, 0x74, 0x61, - 0x6c, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, - 0x74, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0e, 0x72, 0x6f, 0x77, 0x73, - 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x79, - 0x74, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x0b, 0x62, 0x79, 0x74, 0x65, 0x73, 0x43, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x12, 0x1f, 0x0a, - 0x0b, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x0a, 0x62, 0x79, 0x74, 0x65, 0x73, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x12, 0x29, - 0x0a, 0x10, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, - 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x50, - 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x1a, 0xbc, 0x01, 0x0a, 0x10, 0x53, 0x68, - 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0e, - 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2d, - 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, - 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x21, 0x0a, - 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x1a, 0x5c, 0x0a, 0x0c, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x12, 0x4c, 0x0a, 0x07, 0x73, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x07, 0x73, - 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x1a, 0x73, 0x0a, 0x13, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x43, - 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x10, 0x0a, 0x03, 0x61, 0x72, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x61, 0x72, + 0x67, 0x22, 0xd7, 0x01, 0x0a, 0x11, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x10, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x31, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, + 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x1a, 0x64, 0x0a, 0x14, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, - 0x46, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, - 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x6f, 0x0a, 0x11, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, - 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, - 0x65, 0x79, 0x12, 0x44, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x2e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, - 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, - 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xef, 0x03, 0x0a, - 0x1c, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x54, - 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, - 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, - 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, - 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, - 0x79, 0x70, 0x65, 0x73, 0x12, 0x4f, 0x0a, 0x1b, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x67, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, - 0x77, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, - 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x18, 0x6d, 0x61, 0x78, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x61, 0x67, 0x41, 0x6c, - 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x12, 0x3c, 0x0a, 0x1a, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, - 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x65, 0x6e, 0x61, 0x62, 0x6c, - 0x65, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x12, 0x2a, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x17, 0x0a, - 0x07, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, - 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x12, 0x3e, 0x0a, 0x1b, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, - 0x6c, 0x69, 0x7a, 0x65, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x71, 0x75, - 0x65, 0x6e, 0x63, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x69, 0x6e, 0x69, - 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x53, 0x65, 0x71, - 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, - 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, 0xa7, - 0x01, 0x0a, 0x1d, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, - 0x68, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, - 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, - 0x12, 0x26, 0x0a, 0x0f, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x75, - 0x6c, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x72, 0x79, 0x52, 0x75, - 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x90, 0x01, 0x0a, 0x15, 0x57, 0x6f, 0x72, - 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x5b, - 0x0a, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, - 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, - 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0d, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xd1, 0x01, 0x0a, 0x16, - 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, - 0x12, 0x46, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x2c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, - 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x55, 0x0a, 0x0a, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x2a, - 0x4a, 0x0a, 0x15, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x0a, 0x0a, 0x06, 0x43, 0x55, 0x53, 0x54, - 0x4f, 0x4d, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4d, 0x4f, 0x56, 0x45, 0x54, 0x41, 0x42, 0x4c, - 0x45, 0x53, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x4c, 0x4f, - 0x4f, 0x4b, 0x55, 0x50, 0x49, 0x4e, 0x44, 0x45, 0x58, 0x10, 0x02, 0x2a, 0x38, 0x0a, 0x0d, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x08, 0x0a, 0x04, - 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x53, 0x43, 0x45, 0x4e, 0x44, - 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x44, 0x45, 0x53, 0x43, 0x45, 0x4e, 0x44, - 0x49, 0x4e, 0x47, 0x10, 0x02, 0x42, 0x28, 0x5a, 0x26, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2e, - 0x69, 0x6f, 0x2f, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x74, 0x2f, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x62, - 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x6b, 0x0a, 0x10, 0x56, + 0x44, 0x69, 0x66, 0x66, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x74, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x75, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x75, 0x75, 0x69, 0x64, 0x22, 0x13, 0x0a, 0x11, 0x56, 0x44, 0x69, 0x66, + 0x66, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb2, 0x01, + 0x0a, 0x15, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, + 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x08, 0x6b, 0x65, 0x65, 0x70, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x12, + 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x6b, 0x65, 0x65, 0x70, 0x52, 0x6f, + 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, + 0x61, 0x72, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, + 0x64, 0x73, 0x22, 0xd1, 0x01, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, + 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x46, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, + 0x55, 0x0a, 0x0a, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2d, 0x0a, + 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, + 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x18, 0x0a, 0x07, + 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x64, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x67, 0x0a, 0x15, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, + 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, + 0xe6, 0x07, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5f, 0x0a, 0x10, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x70, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x58, 0x0a, 0x0d, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, + 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x73, 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, + 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x74, 0x72, + 0x61, 0x66, 0x66, 0x69, 0x63, 0x53, 0x74, 0x61, 0x74, 0x65, 0x1a, 0xe8, 0x01, 0x0a, 0x0e, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, + 0x0b, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0a, 0x72, 0x6f, 0x77, 0x73, 0x43, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x12, 0x1d, + 0x0a, 0x0a, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x09, 0x72, 0x6f, 0x77, 0x73, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x12, 0x27, 0x0a, + 0x0f, 0x72, 0x6f, 0x77, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0e, 0x72, 0x6f, 0x77, 0x73, 0x50, 0x65, 0x72, 0x63, + 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, + 0x63, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x43, 0x6f, 0x70, 0x69, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x12, 0x29, 0x0a, 0x10, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x02, 0x52, 0x0f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x50, 0x65, 0x72, 0x63, 0x65, + 0x6e, 0x74, 0x61, 0x67, 0x65, 0x1a, 0xbc, 0x01, 0x0a, 0x10, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, + 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, + 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x1a, 0x0a, 0x08, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x12, 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x69, 0x6e, 0x66, 0x6f, 0x1a, 0x5c, 0x0a, 0x0c, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x73, 0x12, 0x4c, 0x0a, 0x07, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x07, 0x73, 0x74, 0x72, 0x65, 0x61, + 0x6d, 0x73, 0x1a, 0x73, 0x0a, 0x13, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x46, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x76, 0x74, 0x63, + 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x6f, 0x0a, 0x11, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x44, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xef, 0x03, 0x0a, 0x1c, 0x57, 0x6f, 0x72, + 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x54, 0x72, 0x61, 0x66, 0x66, + 0x69, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, + 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x14, 0x2e, + 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x12, 0x4f, 0x0a, 0x1b, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x61, 0x67, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x18, 0x6d, 0x61, 0x78, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x61, 0x67, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, + 0x64, 0x12, 0x3c, 0x0a, 0x1a, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x65, + 0x72, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x76, + 0x65, 0x72, 0x73, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x1c, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, + 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, + 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, + 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52, + 0x75, 0x6e, 0x12, 0x3e, 0x0a, 0x1b, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, + 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x19, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, + 0x69, 0x7a, 0x65, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, + 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x0b, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x22, 0xa7, 0x01, 0x0a, 0x1d, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x54, 0x72, 0x61, + 0x66, 0x66, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, + 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, + 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x26, 0x0a, 0x0f, + 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x73, 0x22, 0x90, 0x01, 0x0a, 0x15, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, + 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x5b, 0x0a, 0x0e, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61, 0x67, + 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, + 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0d, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xd1, 0x01, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x46, 0x0a, 0x07, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x55, 0x0a, 0x0a, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x2a, 0x4a, 0x0a, 0x15, 0x4d, + 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x12, 0x0a, 0x0a, 0x06, 0x43, 0x55, 0x53, 0x54, 0x4f, 0x4d, 0x10, 0x00, + 0x12, 0x0e, 0x0a, 0x0a, 0x4d, 0x4f, 0x56, 0x45, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x53, 0x10, 0x01, + 0x12, 0x15, 0x0a, 0x11, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, + 0x49, 0x4e, 0x44, 0x45, 0x58, 0x10, 0x02, 0x2a, 0x38, 0x0a, 0x0d, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x4f, 0x4e, 0x45, + 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x53, 0x43, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, + 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x44, 0x45, 0x53, 0x43, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, + 0x02, 0x42, 0x28, 0x5a, 0x26, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2e, 0x69, 0x6f, 0x2f, 0x76, + 0x69, 0x74, 0x65, 0x73, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2f, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, } var ( @@ -17861,7 +17996,7 @@ func file_vtctldata_proto_rawDescGZIP() []byte { } var file_vtctldata_proto_enumTypes = make([]protoimpl.EnumInfo, 4) -var file_vtctldata_proto_msgTypes = make([]protoimpl.MessageInfo, 270) +var file_vtctldata_proto_msgTypes = make([]protoimpl.MessageInfo, 273) var file_vtctldata_proto_goTypes = []interface{}{ (MaterializationIntent)(0), // 0: vtctldata.MaterializationIntent (QueryOrdering)(0), // 1: vtctldata.QueryOrdering @@ -17948,446 +18083,452 @@ var file_vtctldata_proto_goTypes = []interface{}{ (*GetSchemaResponse)(nil), // 82: vtctldata.GetSchemaResponse (*GetSchemaMigrationsRequest)(nil), // 83: vtctldata.GetSchemaMigrationsRequest (*GetSchemaMigrationsResponse)(nil), // 84: vtctldata.GetSchemaMigrationsResponse - (*GetShardRequest)(nil), // 85: vtctldata.GetShardRequest - (*GetShardResponse)(nil), // 86: vtctldata.GetShardResponse - (*GetShardRoutingRulesRequest)(nil), // 87: vtctldata.GetShardRoutingRulesRequest - (*GetShardRoutingRulesResponse)(nil), // 88: vtctldata.GetShardRoutingRulesResponse - (*GetSrvKeyspaceNamesRequest)(nil), // 89: vtctldata.GetSrvKeyspaceNamesRequest - (*GetSrvKeyspaceNamesResponse)(nil), // 90: vtctldata.GetSrvKeyspaceNamesResponse - (*GetSrvKeyspacesRequest)(nil), // 91: vtctldata.GetSrvKeyspacesRequest - (*GetSrvKeyspacesResponse)(nil), // 92: vtctldata.GetSrvKeyspacesResponse - (*UpdateThrottlerConfigRequest)(nil), // 93: vtctldata.UpdateThrottlerConfigRequest - (*UpdateThrottlerConfigResponse)(nil), // 94: vtctldata.UpdateThrottlerConfigResponse - (*GetSrvVSchemaRequest)(nil), // 95: vtctldata.GetSrvVSchemaRequest - (*GetSrvVSchemaResponse)(nil), // 96: vtctldata.GetSrvVSchemaResponse - (*GetSrvVSchemasRequest)(nil), // 97: vtctldata.GetSrvVSchemasRequest - (*GetSrvVSchemasResponse)(nil), // 98: vtctldata.GetSrvVSchemasResponse - (*GetTabletRequest)(nil), // 99: vtctldata.GetTabletRequest - (*GetTabletResponse)(nil), // 100: vtctldata.GetTabletResponse - (*GetTabletsRequest)(nil), // 101: vtctldata.GetTabletsRequest - (*GetTabletsResponse)(nil), // 102: vtctldata.GetTabletsResponse - (*GetTopologyPathRequest)(nil), // 103: vtctldata.GetTopologyPathRequest - (*GetTopologyPathResponse)(nil), // 104: vtctldata.GetTopologyPathResponse - (*TopologyCell)(nil), // 105: vtctldata.TopologyCell - (*GetVSchemaRequest)(nil), // 106: vtctldata.GetVSchemaRequest - (*GetVersionRequest)(nil), // 107: vtctldata.GetVersionRequest - (*GetVersionResponse)(nil), // 108: vtctldata.GetVersionResponse - (*GetVSchemaResponse)(nil), // 109: vtctldata.GetVSchemaResponse - (*GetWorkflowsRequest)(nil), // 110: vtctldata.GetWorkflowsRequest - (*GetWorkflowsResponse)(nil), // 111: vtctldata.GetWorkflowsResponse - (*InitShardPrimaryRequest)(nil), // 112: vtctldata.InitShardPrimaryRequest - (*InitShardPrimaryResponse)(nil), // 113: vtctldata.InitShardPrimaryResponse - (*LaunchSchemaMigrationRequest)(nil), // 114: vtctldata.LaunchSchemaMigrationRequest - (*LaunchSchemaMigrationResponse)(nil), // 115: vtctldata.LaunchSchemaMigrationResponse - (*LookupVindexCreateRequest)(nil), // 116: vtctldata.LookupVindexCreateRequest - (*LookupVindexCreateResponse)(nil), // 117: vtctldata.LookupVindexCreateResponse - (*LookupVindexExternalizeRequest)(nil), // 118: vtctldata.LookupVindexExternalizeRequest - (*LookupVindexExternalizeResponse)(nil), // 119: vtctldata.LookupVindexExternalizeResponse - (*MaterializeCreateRequest)(nil), // 120: vtctldata.MaterializeCreateRequest - (*MaterializeCreateResponse)(nil), // 121: vtctldata.MaterializeCreateResponse - (*MigrateCreateRequest)(nil), // 122: vtctldata.MigrateCreateRequest - (*MigrateCompleteRequest)(nil), // 123: vtctldata.MigrateCompleteRequest - (*MigrateCompleteResponse)(nil), // 124: vtctldata.MigrateCompleteResponse - (*MountRegisterRequest)(nil), // 125: vtctldata.MountRegisterRequest - (*MountRegisterResponse)(nil), // 126: vtctldata.MountRegisterResponse - (*MountUnregisterRequest)(nil), // 127: vtctldata.MountUnregisterRequest - (*MountUnregisterResponse)(nil), // 128: vtctldata.MountUnregisterResponse - (*MountShowRequest)(nil), // 129: vtctldata.MountShowRequest - (*MountShowResponse)(nil), // 130: vtctldata.MountShowResponse - (*MountListRequest)(nil), // 131: vtctldata.MountListRequest - (*MountListResponse)(nil), // 132: vtctldata.MountListResponse - (*MoveTablesCreateRequest)(nil), // 133: vtctldata.MoveTablesCreateRequest - (*MoveTablesCreateResponse)(nil), // 134: vtctldata.MoveTablesCreateResponse - (*MoveTablesCompleteRequest)(nil), // 135: vtctldata.MoveTablesCompleteRequest - (*MoveTablesCompleteResponse)(nil), // 136: vtctldata.MoveTablesCompleteResponse - (*PingTabletRequest)(nil), // 137: vtctldata.PingTabletRequest - (*PingTabletResponse)(nil), // 138: vtctldata.PingTabletResponse - (*PlannedReparentShardRequest)(nil), // 139: vtctldata.PlannedReparentShardRequest - (*PlannedReparentShardResponse)(nil), // 140: vtctldata.PlannedReparentShardResponse - (*RebuildKeyspaceGraphRequest)(nil), // 141: vtctldata.RebuildKeyspaceGraphRequest - (*RebuildKeyspaceGraphResponse)(nil), // 142: vtctldata.RebuildKeyspaceGraphResponse - (*RebuildVSchemaGraphRequest)(nil), // 143: vtctldata.RebuildVSchemaGraphRequest - (*RebuildVSchemaGraphResponse)(nil), // 144: vtctldata.RebuildVSchemaGraphResponse - (*RefreshStateRequest)(nil), // 145: vtctldata.RefreshStateRequest - (*RefreshStateResponse)(nil), // 146: vtctldata.RefreshStateResponse - (*RefreshStateByShardRequest)(nil), // 147: vtctldata.RefreshStateByShardRequest - (*RefreshStateByShardResponse)(nil), // 148: vtctldata.RefreshStateByShardResponse - (*ReloadSchemaRequest)(nil), // 149: vtctldata.ReloadSchemaRequest - (*ReloadSchemaResponse)(nil), // 150: vtctldata.ReloadSchemaResponse - (*ReloadSchemaKeyspaceRequest)(nil), // 151: vtctldata.ReloadSchemaKeyspaceRequest - (*ReloadSchemaKeyspaceResponse)(nil), // 152: vtctldata.ReloadSchemaKeyspaceResponse - (*ReloadSchemaShardRequest)(nil), // 153: vtctldata.ReloadSchemaShardRequest - (*ReloadSchemaShardResponse)(nil), // 154: vtctldata.ReloadSchemaShardResponse - (*RemoveBackupRequest)(nil), // 155: vtctldata.RemoveBackupRequest - (*RemoveBackupResponse)(nil), // 156: vtctldata.RemoveBackupResponse - (*RemoveKeyspaceCellRequest)(nil), // 157: vtctldata.RemoveKeyspaceCellRequest - (*RemoveKeyspaceCellResponse)(nil), // 158: vtctldata.RemoveKeyspaceCellResponse - (*RemoveShardCellRequest)(nil), // 159: vtctldata.RemoveShardCellRequest - (*RemoveShardCellResponse)(nil), // 160: vtctldata.RemoveShardCellResponse - (*ReparentTabletRequest)(nil), // 161: vtctldata.ReparentTabletRequest - (*ReparentTabletResponse)(nil), // 162: vtctldata.ReparentTabletResponse - (*ReshardCreateRequest)(nil), // 163: vtctldata.ReshardCreateRequest - (*RestoreFromBackupRequest)(nil), // 164: vtctldata.RestoreFromBackupRequest - (*RestoreFromBackupResponse)(nil), // 165: vtctldata.RestoreFromBackupResponse - (*RetrySchemaMigrationRequest)(nil), // 166: vtctldata.RetrySchemaMigrationRequest - (*RetrySchemaMigrationResponse)(nil), // 167: vtctldata.RetrySchemaMigrationResponse - (*RunHealthCheckRequest)(nil), // 168: vtctldata.RunHealthCheckRequest - (*RunHealthCheckResponse)(nil), // 169: vtctldata.RunHealthCheckResponse - (*SetKeyspaceDurabilityPolicyRequest)(nil), // 170: vtctldata.SetKeyspaceDurabilityPolicyRequest - (*SetKeyspaceDurabilityPolicyResponse)(nil), // 171: vtctldata.SetKeyspaceDurabilityPolicyResponse - (*SetKeyspaceShardingInfoRequest)(nil), // 172: vtctldata.SetKeyspaceShardingInfoRequest - (*SetKeyspaceShardingInfoResponse)(nil), // 173: vtctldata.SetKeyspaceShardingInfoResponse - (*SetShardIsPrimaryServingRequest)(nil), // 174: vtctldata.SetShardIsPrimaryServingRequest - (*SetShardIsPrimaryServingResponse)(nil), // 175: vtctldata.SetShardIsPrimaryServingResponse - (*SetShardTabletControlRequest)(nil), // 176: vtctldata.SetShardTabletControlRequest - (*SetShardTabletControlResponse)(nil), // 177: vtctldata.SetShardTabletControlResponse - (*SetWritableRequest)(nil), // 178: vtctldata.SetWritableRequest - (*SetWritableResponse)(nil), // 179: vtctldata.SetWritableResponse - (*ShardReplicationAddRequest)(nil), // 180: vtctldata.ShardReplicationAddRequest - (*ShardReplicationAddResponse)(nil), // 181: vtctldata.ShardReplicationAddResponse - (*ShardReplicationFixRequest)(nil), // 182: vtctldata.ShardReplicationFixRequest - (*ShardReplicationFixResponse)(nil), // 183: vtctldata.ShardReplicationFixResponse - (*ShardReplicationPositionsRequest)(nil), // 184: vtctldata.ShardReplicationPositionsRequest - (*ShardReplicationPositionsResponse)(nil), // 185: vtctldata.ShardReplicationPositionsResponse - (*ShardReplicationRemoveRequest)(nil), // 186: vtctldata.ShardReplicationRemoveRequest - (*ShardReplicationRemoveResponse)(nil), // 187: vtctldata.ShardReplicationRemoveResponse - (*SleepTabletRequest)(nil), // 188: vtctldata.SleepTabletRequest - (*SleepTabletResponse)(nil), // 189: vtctldata.SleepTabletResponse - (*SourceShardAddRequest)(nil), // 190: vtctldata.SourceShardAddRequest - (*SourceShardAddResponse)(nil), // 191: vtctldata.SourceShardAddResponse - (*SourceShardDeleteRequest)(nil), // 192: vtctldata.SourceShardDeleteRequest - (*SourceShardDeleteResponse)(nil), // 193: vtctldata.SourceShardDeleteResponse - (*StartReplicationRequest)(nil), // 194: vtctldata.StartReplicationRequest - (*StartReplicationResponse)(nil), // 195: vtctldata.StartReplicationResponse - (*StopReplicationRequest)(nil), // 196: vtctldata.StopReplicationRequest - (*StopReplicationResponse)(nil), // 197: vtctldata.StopReplicationResponse - (*TabletExternallyReparentedRequest)(nil), // 198: vtctldata.TabletExternallyReparentedRequest - (*TabletExternallyReparentedResponse)(nil), // 199: vtctldata.TabletExternallyReparentedResponse - (*UpdateCellInfoRequest)(nil), // 200: vtctldata.UpdateCellInfoRequest - (*UpdateCellInfoResponse)(nil), // 201: vtctldata.UpdateCellInfoResponse - (*UpdateCellsAliasRequest)(nil), // 202: vtctldata.UpdateCellsAliasRequest - (*UpdateCellsAliasResponse)(nil), // 203: vtctldata.UpdateCellsAliasResponse - (*ValidateRequest)(nil), // 204: vtctldata.ValidateRequest - (*ValidateResponse)(nil), // 205: vtctldata.ValidateResponse - (*ValidateKeyspaceRequest)(nil), // 206: vtctldata.ValidateKeyspaceRequest - (*ValidateKeyspaceResponse)(nil), // 207: vtctldata.ValidateKeyspaceResponse - (*ValidateSchemaKeyspaceRequest)(nil), // 208: vtctldata.ValidateSchemaKeyspaceRequest - (*ValidateSchemaKeyspaceResponse)(nil), // 209: vtctldata.ValidateSchemaKeyspaceResponse - (*ValidateShardRequest)(nil), // 210: vtctldata.ValidateShardRequest - (*ValidateShardResponse)(nil), // 211: vtctldata.ValidateShardResponse - (*ValidateVersionKeyspaceRequest)(nil), // 212: vtctldata.ValidateVersionKeyspaceRequest - (*ValidateVersionKeyspaceResponse)(nil), // 213: vtctldata.ValidateVersionKeyspaceResponse - (*ValidateVersionShardRequest)(nil), // 214: vtctldata.ValidateVersionShardRequest - (*ValidateVersionShardResponse)(nil), // 215: vtctldata.ValidateVersionShardResponse - (*ValidateVSchemaRequest)(nil), // 216: vtctldata.ValidateVSchemaRequest - (*ValidateVSchemaResponse)(nil), // 217: vtctldata.ValidateVSchemaResponse - (*VDiffCreateRequest)(nil), // 218: vtctldata.VDiffCreateRequest - (*VDiffCreateResponse)(nil), // 219: vtctldata.VDiffCreateResponse - (*VDiffDeleteRequest)(nil), // 220: vtctldata.VDiffDeleteRequest - (*VDiffDeleteResponse)(nil), // 221: vtctldata.VDiffDeleteResponse - (*VDiffResumeRequest)(nil), // 222: vtctldata.VDiffResumeRequest - (*VDiffResumeResponse)(nil), // 223: vtctldata.VDiffResumeResponse - (*VDiffShowRequest)(nil), // 224: vtctldata.VDiffShowRequest - (*VDiffShowResponse)(nil), // 225: vtctldata.VDiffShowResponse - (*VDiffStopRequest)(nil), // 226: vtctldata.VDiffStopRequest - (*VDiffStopResponse)(nil), // 227: vtctldata.VDiffStopResponse - (*WorkflowDeleteRequest)(nil), // 228: vtctldata.WorkflowDeleteRequest - (*WorkflowDeleteResponse)(nil), // 229: vtctldata.WorkflowDeleteResponse - (*WorkflowStatusRequest)(nil), // 230: vtctldata.WorkflowStatusRequest - (*WorkflowStatusResponse)(nil), // 231: vtctldata.WorkflowStatusResponse - (*WorkflowSwitchTrafficRequest)(nil), // 232: vtctldata.WorkflowSwitchTrafficRequest - (*WorkflowSwitchTrafficResponse)(nil), // 233: vtctldata.WorkflowSwitchTrafficResponse - (*WorkflowUpdateRequest)(nil), // 234: vtctldata.WorkflowUpdateRequest - (*WorkflowUpdateResponse)(nil), // 235: vtctldata.WorkflowUpdateResponse - nil, // 236: vtctldata.Workflow.ShardStreamsEntry - (*Workflow_ReplicationLocation)(nil), // 237: vtctldata.Workflow.ReplicationLocation - (*Workflow_ShardStream)(nil), // 238: vtctldata.Workflow.ShardStream - (*Workflow_Stream)(nil), // 239: vtctldata.Workflow.Stream - (*Workflow_Stream_CopyState)(nil), // 240: vtctldata.Workflow.Stream.CopyState - (*Workflow_Stream_Log)(nil), // 241: vtctldata.Workflow.Stream.Log - (*Workflow_Stream_ThrottlerStatus)(nil), // 242: vtctldata.Workflow.Stream.ThrottlerStatus - nil, // 243: vtctldata.ApplySchemaResponse.RowsAffectedByShardEntry - nil, // 244: vtctldata.ApplyVSchemaResponse.UnknownVindexParamsEntry - (*ApplyVSchemaResponse_ParamList)(nil), // 245: vtctldata.ApplyVSchemaResponse.ParamList - nil, // 246: vtctldata.CancelSchemaMigrationResponse.RowsAffectedByShardEntry - nil, // 247: vtctldata.CleanupSchemaMigrationResponse.RowsAffectedByShardEntry - nil, // 248: vtctldata.CompleteSchemaMigrationResponse.RowsAffectedByShardEntry - nil, // 249: vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry - nil, // 250: vtctldata.ForceCutOverSchemaMigrationResponse.RowsAffectedByShardEntry - nil, // 251: vtctldata.GetCellsAliasesResponse.AliasesEntry - nil, // 252: vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry - (*GetSrvKeyspaceNamesResponse_NameList)(nil), // 253: vtctldata.GetSrvKeyspaceNamesResponse.NameList - nil, // 254: vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry - nil, // 255: vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry - nil, // 256: vtctldata.LaunchSchemaMigrationResponse.RowsAffectedByShardEntry - (*MoveTablesCreateResponse_TabletInfo)(nil), // 257: vtctldata.MoveTablesCreateResponse.TabletInfo - nil, // 258: vtctldata.RetrySchemaMigrationResponse.RowsAffectedByShardEntry - nil, // 259: vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry - nil, // 260: vtctldata.ShardReplicationPositionsResponse.TabletMapEntry - nil, // 261: vtctldata.ValidateResponse.ResultsByKeyspaceEntry - nil, // 262: vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry - nil, // 263: vtctldata.ValidateSchemaKeyspaceResponse.ResultsByShardEntry - nil, // 264: vtctldata.ValidateVersionKeyspaceResponse.ResultsByShardEntry - nil, // 265: vtctldata.ValidateVSchemaResponse.ResultsByShardEntry - nil, // 266: vtctldata.VDiffShowResponse.TabletResponsesEntry - (*WorkflowDeleteResponse_TabletInfo)(nil), // 267: vtctldata.WorkflowDeleteResponse.TabletInfo - (*WorkflowStatusResponse_TableCopyState)(nil), // 268: vtctldata.WorkflowStatusResponse.TableCopyState - (*WorkflowStatusResponse_ShardStreamState)(nil), // 269: vtctldata.WorkflowStatusResponse.ShardStreamState - (*WorkflowStatusResponse_ShardStreams)(nil), // 270: vtctldata.WorkflowStatusResponse.ShardStreams - nil, // 271: vtctldata.WorkflowStatusResponse.TableCopyStateEntry - nil, // 272: vtctldata.WorkflowStatusResponse.ShardStreamsEntry - (*WorkflowUpdateResponse_TabletInfo)(nil), // 273: vtctldata.WorkflowUpdateResponse.TabletInfo - (*logutil.Event)(nil), // 274: logutil.Event - (tabletmanagerdata.TabletSelectionPreference)(0), // 275: tabletmanagerdata.TabletSelectionPreference - (*topodata.Keyspace)(nil), // 276: topodata.Keyspace - (*vttime.Time)(nil), // 277: vttime.Time - (*topodata.TabletAlias)(nil), // 278: topodata.TabletAlias - (*vttime.Duration)(nil), // 279: vttime.Duration - (*topodata.Shard)(nil), // 280: topodata.Shard - (*topodata.CellInfo)(nil), // 281: topodata.CellInfo - (*vschema.RoutingRules)(nil), // 282: vschema.RoutingRules - (*vschema.ShardRoutingRules)(nil), // 283: vschema.ShardRoutingRules - (*vtrpc.CallerID)(nil), // 284: vtrpc.CallerID - (*vschema.Keyspace)(nil), // 285: vschema.Keyspace - (topodata.TabletType)(0), // 286: topodata.TabletType - (*topodata.Tablet)(nil), // 287: topodata.Tablet - (topodata.KeyspaceType)(0), // 288: topodata.KeyspaceType - (*query.QueryResult)(nil), // 289: query.QueryResult - (*tabletmanagerdata.ExecuteHookRequest)(nil), // 290: tabletmanagerdata.ExecuteHookRequest - (*tabletmanagerdata.ExecuteHookResponse)(nil), // 291: tabletmanagerdata.ExecuteHookResponse - (*mysqlctl.BackupInfo)(nil), // 292: mysqlctl.BackupInfo - (*replicationdata.FullStatus)(nil), // 293: replicationdata.FullStatus - (*tabletmanagerdata.Permissions)(nil), // 294: tabletmanagerdata.Permissions - (*tabletmanagerdata.SchemaDefinition)(nil), // 295: tabletmanagerdata.SchemaDefinition - (*topodata.ThrottledAppRule)(nil), // 296: topodata.ThrottledAppRule - (*vschema.SrvVSchema)(nil), // 297: vschema.SrvVSchema - (*topodata.ShardReplicationError)(nil), // 298: topodata.ShardReplicationError - (*topodata.KeyRange)(nil), // 299: topodata.KeyRange - (*topodata.CellsAlias)(nil), // 300: topodata.CellsAlias - (*tabletmanagerdata.UpdateVReplicationWorkflowRequest)(nil), // 301: tabletmanagerdata.UpdateVReplicationWorkflowRequest - (*topodata.Shard_TabletControl)(nil), // 302: topodata.Shard.TabletControl - (*binlogdata.BinlogSource)(nil), // 303: binlogdata.BinlogSource - (*topodata.SrvKeyspace)(nil), // 304: topodata.SrvKeyspace - (*replicationdata.Status)(nil), // 305: replicationdata.Status - (*tabletmanagerdata.VDiffResponse)(nil), // 306: tabletmanagerdata.VDiffResponse + (*GetShardReplicationRequest)(nil), // 85: vtctldata.GetShardReplicationRequest + (*GetShardReplicationResponse)(nil), // 86: vtctldata.GetShardReplicationResponse + (*GetShardRequest)(nil), // 87: vtctldata.GetShardRequest + (*GetShardResponse)(nil), // 88: vtctldata.GetShardResponse + (*GetShardRoutingRulesRequest)(nil), // 89: vtctldata.GetShardRoutingRulesRequest + (*GetShardRoutingRulesResponse)(nil), // 90: vtctldata.GetShardRoutingRulesResponse + (*GetSrvKeyspaceNamesRequest)(nil), // 91: vtctldata.GetSrvKeyspaceNamesRequest + (*GetSrvKeyspaceNamesResponse)(nil), // 92: vtctldata.GetSrvKeyspaceNamesResponse + (*GetSrvKeyspacesRequest)(nil), // 93: vtctldata.GetSrvKeyspacesRequest + (*GetSrvKeyspacesResponse)(nil), // 94: vtctldata.GetSrvKeyspacesResponse + (*UpdateThrottlerConfigRequest)(nil), // 95: vtctldata.UpdateThrottlerConfigRequest + (*UpdateThrottlerConfigResponse)(nil), // 96: vtctldata.UpdateThrottlerConfigResponse + (*GetSrvVSchemaRequest)(nil), // 97: vtctldata.GetSrvVSchemaRequest + (*GetSrvVSchemaResponse)(nil), // 98: vtctldata.GetSrvVSchemaResponse + (*GetSrvVSchemasRequest)(nil), // 99: vtctldata.GetSrvVSchemasRequest + (*GetSrvVSchemasResponse)(nil), // 100: vtctldata.GetSrvVSchemasResponse + (*GetTabletRequest)(nil), // 101: vtctldata.GetTabletRequest + (*GetTabletResponse)(nil), // 102: vtctldata.GetTabletResponse + (*GetTabletsRequest)(nil), // 103: vtctldata.GetTabletsRequest + (*GetTabletsResponse)(nil), // 104: vtctldata.GetTabletsResponse + (*GetTopologyPathRequest)(nil), // 105: vtctldata.GetTopologyPathRequest + (*GetTopologyPathResponse)(nil), // 106: vtctldata.GetTopologyPathResponse + (*TopologyCell)(nil), // 107: vtctldata.TopologyCell + (*GetVSchemaRequest)(nil), // 108: vtctldata.GetVSchemaRequest + (*GetVersionRequest)(nil), // 109: vtctldata.GetVersionRequest + (*GetVersionResponse)(nil), // 110: vtctldata.GetVersionResponse + (*GetVSchemaResponse)(nil), // 111: vtctldata.GetVSchemaResponse + (*GetWorkflowsRequest)(nil), // 112: vtctldata.GetWorkflowsRequest + (*GetWorkflowsResponse)(nil), // 113: vtctldata.GetWorkflowsResponse + (*InitShardPrimaryRequest)(nil), // 114: vtctldata.InitShardPrimaryRequest + (*InitShardPrimaryResponse)(nil), // 115: vtctldata.InitShardPrimaryResponse + (*LaunchSchemaMigrationRequest)(nil), // 116: vtctldata.LaunchSchemaMigrationRequest + (*LaunchSchemaMigrationResponse)(nil), // 117: vtctldata.LaunchSchemaMigrationResponse + (*LookupVindexCreateRequest)(nil), // 118: vtctldata.LookupVindexCreateRequest + (*LookupVindexCreateResponse)(nil), // 119: vtctldata.LookupVindexCreateResponse + (*LookupVindexExternalizeRequest)(nil), // 120: vtctldata.LookupVindexExternalizeRequest + (*LookupVindexExternalizeResponse)(nil), // 121: vtctldata.LookupVindexExternalizeResponse + (*MaterializeCreateRequest)(nil), // 122: vtctldata.MaterializeCreateRequest + (*MaterializeCreateResponse)(nil), // 123: vtctldata.MaterializeCreateResponse + (*MigrateCreateRequest)(nil), // 124: vtctldata.MigrateCreateRequest + (*MigrateCompleteRequest)(nil), // 125: vtctldata.MigrateCompleteRequest + (*MigrateCompleteResponse)(nil), // 126: vtctldata.MigrateCompleteResponse + (*MountRegisterRequest)(nil), // 127: vtctldata.MountRegisterRequest + (*MountRegisterResponse)(nil), // 128: vtctldata.MountRegisterResponse + (*MountUnregisterRequest)(nil), // 129: vtctldata.MountUnregisterRequest + (*MountUnregisterResponse)(nil), // 130: vtctldata.MountUnregisterResponse + (*MountShowRequest)(nil), // 131: vtctldata.MountShowRequest + (*MountShowResponse)(nil), // 132: vtctldata.MountShowResponse + (*MountListRequest)(nil), // 133: vtctldata.MountListRequest + (*MountListResponse)(nil), // 134: vtctldata.MountListResponse + (*MoveTablesCreateRequest)(nil), // 135: vtctldata.MoveTablesCreateRequest + (*MoveTablesCreateResponse)(nil), // 136: vtctldata.MoveTablesCreateResponse + (*MoveTablesCompleteRequest)(nil), // 137: vtctldata.MoveTablesCompleteRequest + (*MoveTablesCompleteResponse)(nil), // 138: vtctldata.MoveTablesCompleteResponse + (*PingTabletRequest)(nil), // 139: vtctldata.PingTabletRequest + (*PingTabletResponse)(nil), // 140: vtctldata.PingTabletResponse + (*PlannedReparentShardRequest)(nil), // 141: vtctldata.PlannedReparentShardRequest + (*PlannedReparentShardResponse)(nil), // 142: vtctldata.PlannedReparentShardResponse + (*RebuildKeyspaceGraphRequest)(nil), // 143: vtctldata.RebuildKeyspaceGraphRequest + (*RebuildKeyspaceGraphResponse)(nil), // 144: vtctldata.RebuildKeyspaceGraphResponse + (*RebuildVSchemaGraphRequest)(nil), // 145: vtctldata.RebuildVSchemaGraphRequest + (*RebuildVSchemaGraphResponse)(nil), // 146: vtctldata.RebuildVSchemaGraphResponse + (*RefreshStateRequest)(nil), // 147: vtctldata.RefreshStateRequest + (*RefreshStateResponse)(nil), // 148: vtctldata.RefreshStateResponse + (*RefreshStateByShardRequest)(nil), // 149: vtctldata.RefreshStateByShardRequest + (*RefreshStateByShardResponse)(nil), // 150: vtctldata.RefreshStateByShardResponse + (*ReloadSchemaRequest)(nil), // 151: vtctldata.ReloadSchemaRequest + (*ReloadSchemaResponse)(nil), // 152: vtctldata.ReloadSchemaResponse + (*ReloadSchemaKeyspaceRequest)(nil), // 153: vtctldata.ReloadSchemaKeyspaceRequest + (*ReloadSchemaKeyspaceResponse)(nil), // 154: vtctldata.ReloadSchemaKeyspaceResponse + (*ReloadSchemaShardRequest)(nil), // 155: vtctldata.ReloadSchemaShardRequest + (*ReloadSchemaShardResponse)(nil), // 156: vtctldata.ReloadSchemaShardResponse + (*RemoveBackupRequest)(nil), // 157: vtctldata.RemoveBackupRequest + (*RemoveBackupResponse)(nil), // 158: vtctldata.RemoveBackupResponse + (*RemoveKeyspaceCellRequest)(nil), // 159: vtctldata.RemoveKeyspaceCellRequest + (*RemoveKeyspaceCellResponse)(nil), // 160: vtctldata.RemoveKeyspaceCellResponse + (*RemoveShardCellRequest)(nil), // 161: vtctldata.RemoveShardCellRequest + (*RemoveShardCellResponse)(nil), // 162: vtctldata.RemoveShardCellResponse + (*ReparentTabletRequest)(nil), // 163: vtctldata.ReparentTabletRequest + (*ReparentTabletResponse)(nil), // 164: vtctldata.ReparentTabletResponse + (*ReshardCreateRequest)(nil), // 165: vtctldata.ReshardCreateRequest + (*RestoreFromBackupRequest)(nil), // 166: vtctldata.RestoreFromBackupRequest + (*RestoreFromBackupResponse)(nil), // 167: vtctldata.RestoreFromBackupResponse + (*RetrySchemaMigrationRequest)(nil), // 168: vtctldata.RetrySchemaMigrationRequest + (*RetrySchemaMigrationResponse)(nil), // 169: vtctldata.RetrySchemaMigrationResponse + (*RunHealthCheckRequest)(nil), // 170: vtctldata.RunHealthCheckRequest + (*RunHealthCheckResponse)(nil), // 171: vtctldata.RunHealthCheckResponse + (*SetKeyspaceDurabilityPolicyRequest)(nil), // 172: vtctldata.SetKeyspaceDurabilityPolicyRequest + (*SetKeyspaceDurabilityPolicyResponse)(nil), // 173: vtctldata.SetKeyspaceDurabilityPolicyResponse + (*SetKeyspaceShardingInfoRequest)(nil), // 174: vtctldata.SetKeyspaceShardingInfoRequest + (*SetKeyspaceShardingInfoResponse)(nil), // 175: vtctldata.SetKeyspaceShardingInfoResponse + (*SetShardIsPrimaryServingRequest)(nil), // 176: vtctldata.SetShardIsPrimaryServingRequest + (*SetShardIsPrimaryServingResponse)(nil), // 177: vtctldata.SetShardIsPrimaryServingResponse + (*SetShardTabletControlRequest)(nil), // 178: vtctldata.SetShardTabletControlRequest + (*SetShardTabletControlResponse)(nil), // 179: vtctldata.SetShardTabletControlResponse + (*SetWritableRequest)(nil), // 180: vtctldata.SetWritableRequest + (*SetWritableResponse)(nil), // 181: vtctldata.SetWritableResponse + (*ShardReplicationAddRequest)(nil), // 182: vtctldata.ShardReplicationAddRequest + (*ShardReplicationAddResponse)(nil), // 183: vtctldata.ShardReplicationAddResponse + (*ShardReplicationFixRequest)(nil), // 184: vtctldata.ShardReplicationFixRequest + (*ShardReplicationFixResponse)(nil), // 185: vtctldata.ShardReplicationFixResponse + (*ShardReplicationPositionsRequest)(nil), // 186: vtctldata.ShardReplicationPositionsRequest + (*ShardReplicationPositionsResponse)(nil), // 187: vtctldata.ShardReplicationPositionsResponse + (*ShardReplicationRemoveRequest)(nil), // 188: vtctldata.ShardReplicationRemoveRequest + (*ShardReplicationRemoveResponse)(nil), // 189: vtctldata.ShardReplicationRemoveResponse + (*SleepTabletRequest)(nil), // 190: vtctldata.SleepTabletRequest + (*SleepTabletResponse)(nil), // 191: vtctldata.SleepTabletResponse + (*SourceShardAddRequest)(nil), // 192: vtctldata.SourceShardAddRequest + (*SourceShardAddResponse)(nil), // 193: vtctldata.SourceShardAddResponse + (*SourceShardDeleteRequest)(nil), // 194: vtctldata.SourceShardDeleteRequest + (*SourceShardDeleteResponse)(nil), // 195: vtctldata.SourceShardDeleteResponse + (*StartReplicationRequest)(nil), // 196: vtctldata.StartReplicationRequest + (*StartReplicationResponse)(nil), // 197: vtctldata.StartReplicationResponse + (*StopReplicationRequest)(nil), // 198: vtctldata.StopReplicationRequest + (*StopReplicationResponse)(nil), // 199: vtctldata.StopReplicationResponse + (*TabletExternallyReparentedRequest)(nil), // 200: vtctldata.TabletExternallyReparentedRequest + (*TabletExternallyReparentedResponse)(nil), // 201: vtctldata.TabletExternallyReparentedResponse + (*UpdateCellInfoRequest)(nil), // 202: vtctldata.UpdateCellInfoRequest + (*UpdateCellInfoResponse)(nil), // 203: vtctldata.UpdateCellInfoResponse + (*UpdateCellsAliasRequest)(nil), // 204: vtctldata.UpdateCellsAliasRequest + (*UpdateCellsAliasResponse)(nil), // 205: vtctldata.UpdateCellsAliasResponse + (*ValidateRequest)(nil), // 206: vtctldata.ValidateRequest + (*ValidateResponse)(nil), // 207: vtctldata.ValidateResponse + (*ValidateKeyspaceRequest)(nil), // 208: vtctldata.ValidateKeyspaceRequest + (*ValidateKeyspaceResponse)(nil), // 209: vtctldata.ValidateKeyspaceResponse + (*ValidateSchemaKeyspaceRequest)(nil), // 210: vtctldata.ValidateSchemaKeyspaceRequest + (*ValidateSchemaKeyspaceResponse)(nil), // 211: vtctldata.ValidateSchemaKeyspaceResponse + (*ValidateShardRequest)(nil), // 212: vtctldata.ValidateShardRequest + (*ValidateShardResponse)(nil), // 213: vtctldata.ValidateShardResponse + (*ValidateVersionKeyspaceRequest)(nil), // 214: vtctldata.ValidateVersionKeyspaceRequest + (*ValidateVersionKeyspaceResponse)(nil), // 215: vtctldata.ValidateVersionKeyspaceResponse + (*ValidateVersionShardRequest)(nil), // 216: vtctldata.ValidateVersionShardRequest + (*ValidateVersionShardResponse)(nil), // 217: vtctldata.ValidateVersionShardResponse + (*ValidateVSchemaRequest)(nil), // 218: vtctldata.ValidateVSchemaRequest + (*ValidateVSchemaResponse)(nil), // 219: vtctldata.ValidateVSchemaResponse + (*VDiffCreateRequest)(nil), // 220: vtctldata.VDiffCreateRequest + (*VDiffCreateResponse)(nil), // 221: vtctldata.VDiffCreateResponse + (*VDiffDeleteRequest)(nil), // 222: vtctldata.VDiffDeleteRequest + (*VDiffDeleteResponse)(nil), // 223: vtctldata.VDiffDeleteResponse + (*VDiffResumeRequest)(nil), // 224: vtctldata.VDiffResumeRequest + (*VDiffResumeResponse)(nil), // 225: vtctldata.VDiffResumeResponse + (*VDiffShowRequest)(nil), // 226: vtctldata.VDiffShowRequest + (*VDiffShowResponse)(nil), // 227: vtctldata.VDiffShowResponse + (*VDiffStopRequest)(nil), // 228: vtctldata.VDiffStopRequest + (*VDiffStopResponse)(nil), // 229: vtctldata.VDiffStopResponse + (*WorkflowDeleteRequest)(nil), // 230: vtctldata.WorkflowDeleteRequest + (*WorkflowDeleteResponse)(nil), // 231: vtctldata.WorkflowDeleteResponse + (*WorkflowStatusRequest)(nil), // 232: vtctldata.WorkflowStatusRequest + (*WorkflowStatusResponse)(nil), // 233: vtctldata.WorkflowStatusResponse + (*WorkflowSwitchTrafficRequest)(nil), // 234: vtctldata.WorkflowSwitchTrafficRequest + (*WorkflowSwitchTrafficResponse)(nil), // 235: vtctldata.WorkflowSwitchTrafficResponse + (*WorkflowUpdateRequest)(nil), // 236: vtctldata.WorkflowUpdateRequest + (*WorkflowUpdateResponse)(nil), // 237: vtctldata.WorkflowUpdateResponse + nil, // 238: vtctldata.Workflow.ShardStreamsEntry + (*Workflow_ReplicationLocation)(nil), // 239: vtctldata.Workflow.ReplicationLocation + (*Workflow_ShardStream)(nil), // 240: vtctldata.Workflow.ShardStream + (*Workflow_Stream)(nil), // 241: vtctldata.Workflow.Stream + (*Workflow_Stream_CopyState)(nil), // 242: vtctldata.Workflow.Stream.CopyState + (*Workflow_Stream_Log)(nil), // 243: vtctldata.Workflow.Stream.Log + (*Workflow_Stream_ThrottlerStatus)(nil), // 244: vtctldata.Workflow.Stream.ThrottlerStatus + nil, // 245: vtctldata.ApplySchemaResponse.RowsAffectedByShardEntry + nil, // 246: vtctldata.ApplyVSchemaResponse.UnknownVindexParamsEntry + (*ApplyVSchemaResponse_ParamList)(nil), // 247: vtctldata.ApplyVSchemaResponse.ParamList + nil, // 248: vtctldata.CancelSchemaMigrationResponse.RowsAffectedByShardEntry + nil, // 249: vtctldata.CleanupSchemaMigrationResponse.RowsAffectedByShardEntry + nil, // 250: vtctldata.CompleteSchemaMigrationResponse.RowsAffectedByShardEntry + nil, // 251: vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry + nil, // 252: vtctldata.ForceCutOverSchemaMigrationResponse.RowsAffectedByShardEntry + nil, // 253: vtctldata.GetCellsAliasesResponse.AliasesEntry + nil, // 254: vtctldata.GetShardReplicationResponse.ShardReplicationByCellEntry + nil, // 255: vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry + (*GetSrvKeyspaceNamesResponse_NameList)(nil), // 256: vtctldata.GetSrvKeyspaceNamesResponse.NameList + nil, // 257: vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry + nil, // 258: vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry + nil, // 259: vtctldata.LaunchSchemaMigrationResponse.RowsAffectedByShardEntry + (*MoveTablesCreateResponse_TabletInfo)(nil), // 260: vtctldata.MoveTablesCreateResponse.TabletInfo + nil, // 261: vtctldata.RetrySchemaMigrationResponse.RowsAffectedByShardEntry + nil, // 262: vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry + nil, // 263: vtctldata.ShardReplicationPositionsResponse.TabletMapEntry + nil, // 264: vtctldata.ValidateResponse.ResultsByKeyspaceEntry + nil, // 265: vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry + nil, // 266: vtctldata.ValidateSchemaKeyspaceResponse.ResultsByShardEntry + nil, // 267: vtctldata.ValidateVersionKeyspaceResponse.ResultsByShardEntry + nil, // 268: vtctldata.ValidateVSchemaResponse.ResultsByShardEntry + nil, // 269: vtctldata.VDiffShowResponse.TabletResponsesEntry + (*WorkflowDeleteResponse_TabletInfo)(nil), // 270: vtctldata.WorkflowDeleteResponse.TabletInfo + (*WorkflowStatusResponse_TableCopyState)(nil), // 271: vtctldata.WorkflowStatusResponse.TableCopyState + (*WorkflowStatusResponse_ShardStreamState)(nil), // 272: vtctldata.WorkflowStatusResponse.ShardStreamState + (*WorkflowStatusResponse_ShardStreams)(nil), // 273: vtctldata.WorkflowStatusResponse.ShardStreams + nil, // 274: vtctldata.WorkflowStatusResponse.TableCopyStateEntry + nil, // 275: vtctldata.WorkflowStatusResponse.ShardStreamsEntry + (*WorkflowUpdateResponse_TabletInfo)(nil), // 276: vtctldata.WorkflowUpdateResponse.TabletInfo + (*logutil.Event)(nil), // 277: logutil.Event + (tabletmanagerdata.TabletSelectionPreference)(0), // 278: tabletmanagerdata.TabletSelectionPreference + (*topodata.Keyspace)(nil), // 279: topodata.Keyspace + (*vttime.Time)(nil), // 280: vttime.Time + (*topodata.TabletAlias)(nil), // 281: topodata.TabletAlias + (*vttime.Duration)(nil), // 282: vttime.Duration + (*topodata.Shard)(nil), // 283: topodata.Shard + (*topodata.CellInfo)(nil), // 284: topodata.CellInfo + (*vschema.RoutingRules)(nil), // 285: vschema.RoutingRules + (*vschema.ShardRoutingRules)(nil), // 286: vschema.ShardRoutingRules + (*vtrpc.CallerID)(nil), // 287: vtrpc.CallerID + (*vschema.Keyspace)(nil), // 288: vschema.Keyspace + (topodata.TabletType)(0), // 289: topodata.TabletType + (*topodata.Tablet)(nil), // 290: topodata.Tablet + (topodata.KeyspaceType)(0), // 291: topodata.KeyspaceType + (*query.QueryResult)(nil), // 292: query.QueryResult + (*tabletmanagerdata.ExecuteHookRequest)(nil), // 293: tabletmanagerdata.ExecuteHookRequest + (*tabletmanagerdata.ExecuteHookResponse)(nil), // 294: tabletmanagerdata.ExecuteHookResponse + (*mysqlctl.BackupInfo)(nil), // 295: mysqlctl.BackupInfo + (*replicationdata.FullStatus)(nil), // 296: replicationdata.FullStatus + (*tabletmanagerdata.Permissions)(nil), // 297: tabletmanagerdata.Permissions + (*tabletmanagerdata.SchemaDefinition)(nil), // 298: tabletmanagerdata.SchemaDefinition + (*topodata.ThrottledAppRule)(nil), // 299: topodata.ThrottledAppRule + (*vschema.SrvVSchema)(nil), // 300: vschema.SrvVSchema + (*topodata.ShardReplicationError)(nil), // 301: topodata.ShardReplicationError + (*topodata.KeyRange)(nil), // 302: topodata.KeyRange + (*topodata.CellsAlias)(nil), // 303: topodata.CellsAlias + (*tabletmanagerdata.UpdateVReplicationWorkflowRequest)(nil), // 304: tabletmanagerdata.UpdateVReplicationWorkflowRequest + (*topodata.Shard_TabletControl)(nil), // 305: topodata.Shard.TabletControl + (*binlogdata.BinlogSource)(nil), // 306: binlogdata.BinlogSource + (*topodata.ShardReplication)(nil), // 307: topodata.ShardReplication + (*topodata.SrvKeyspace)(nil), // 308: topodata.SrvKeyspace + (*replicationdata.Status)(nil), // 309: replicationdata.Status + (*tabletmanagerdata.VDiffResponse)(nil), // 310: tabletmanagerdata.VDiffResponse } var file_vtctldata_proto_depIdxs = []int32{ - 274, // 0: vtctldata.ExecuteVtctlCommandResponse.event:type_name -> logutil.Event + 277, // 0: vtctldata.ExecuteVtctlCommandResponse.event:type_name -> logutil.Event 6, // 1: vtctldata.MaterializeSettings.table_settings:type_name -> vtctldata.TableMaterializeSettings 0, // 2: vtctldata.MaterializeSettings.materialization_intent:type_name -> vtctldata.MaterializationIntent - 275, // 3: vtctldata.MaterializeSettings.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference - 276, // 4: vtctldata.Keyspace.keyspace:type_name -> topodata.Keyspace + 278, // 3: vtctldata.MaterializeSettings.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference + 279, // 4: vtctldata.Keyspace.keyspace:type_name -> topodata.Keyspace 2, // 5: vtctldata.SchemaMigration.strategy:type_name -> vtctldata.SchemaMigration.Strategy - 277, // 6: vtctldata.SchemaMigration.added_at:type_name -> vttime.Time - 277, // 7: vtctldata.SchemaMigration.requested_at:type_name -> vttime.Time - 277, // 8: vtctldata.SchemaMigration.ready_at:type_name -> vttime.Time - 277, // 9: vtctldata.SchemaMigration.started_at:type_name -> vttime.Time - 277, // 10: vtctldata.SchemaMigration.liveness_timestamp:type_name -> vttime.Time - 277, // 11: vtctldata.SchemaMigration.completed_at:type_name -> vttime.Time - 277, // 12: vtctldata.SchemaMigration.cleaned_up_at:type_name -> vttime.Time + 280, // 6: vtctldata.SchemaMigration.added_at:type_name -> vttime.Time + 280, // 7: vtctldata.SchemaMigration.requested_at:type_name -> vttime.Time + 280, // 8: vtctldata.SchemaMigration.ready_at:type_name -> vttime.Time + 280, // 9: vtctldata.SchemaMigration.started_at:type_name -> vttime.Time + 280, // 10: vtctldata.SchemaMigration.liveness_timestamp:type_name -> vttime.Time + 280, // 11: vtctldata.SchemaMigration.completed_at:type_name -> vttime.Time + 280, // 12: vtctldata.SchemaMigration.cleaned_up_at:type_name -> vttime.Time 3, // 13: vtctldata.SchemaMigration.status:type_name -> vtctldata.SchemaMigration.Status - 278, // 14: vtctldata.SchemaMigration.tablet:type_name -> topodata.TabletAlias - 279, // 15: vtctldata.SchemaMigration.artifact_retention:type_name -> vttime.Duration - 277, // 16: vtctldata.SchemaMigration.last_throttled_at:type_name -> vttime.Time - 277, // 17: vtctldata.SchemaMigration.cancelled_at:type_name -> vttime.Time - 277, // 18: vtctldata.SchemaMigration.reviewed_at:type_name -> vttime.Time - 277, // 19: vtctldata.SchemaMigration.ready_to_complete_at:type_name -> vttime.Time - 280, // 20: vtctldata.Shard.shard:type_name -> topodata.Shard - 237, // 21: vtctldata.Workflow.source:type_name -> vtctldata.Workflow.ReplicationLocation - 237, // 22: vtctldata.Workflow.target:type_name -> vtctldata.Workflow.ReplicationLocation - 236, // 23: vtctldata.Workflow.shard_streams:type_name -> vtctldata.Workflow.ShardStreamsEntry - 281, // 24: vtctldata.AddCellInfoRequest.cell_info:type_name -> topodata.CellInfo - 282, // 25: vtctldata.ApplyRoutingRulesRequest.routing_rules:type_name -> vschema.RoutingRules - 283, // 26: vtctldata.ApplyShardRoutingRulesRequest.shard_routing_rules:type_name -> vschema.ShardRoutingRules - 279, // 27: vtctldata.ApplySchemaRequest.wait_replicas_timeout:type_name -> vttime.Duration - 284, // 28: vtctldata.ApplySchemaRequest.caller_id:type_name -> vtrpc.CallerID - 243, // 29: vtctldata.ApplySchemaResponse.rows_affected_by_shard:type_name -> vtctldata.ApplySchemaResponse.RowsAffectedByShardEntry - 285, // 30: vtctldata.ApplyVSchemaRequest.v_schema:type_name -> vschema.Keyspace - 285, // 31: vtctldata.ApplyVSchemaResponse.v_schema:type_name -> vschema.Keyspace - 244, // 32: vtctldata.ApplyVSchemaResponse.unknown_vindex_params:type_name -> vtctldata.ApplyVSchemaResponse.UnknownVindexParamsEntry - 278, // 33: vtctldata.BackupRequest.tablet_alias:type_name -> topodata.TabletAlias - 278, // 34: vtctldata.BackupResponse.tablet_alias:type_name -> topodata.TabletAlias - 274, // 35: vtctldata.BackupResponse.event:type_name -> logutil.Event - 246, // 36: vtctldata.CancelSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.CancelSchemaMigrationResponse.RowsAffectedByShardEntry - 278, // 37: vtctldata.ChangeTabletTypeRequest.tablet_alias:type_name -> topodata.TabletAlias - 286, // 38: vtctldata.ChangeTabletTypeRequest.db_type:type_name -> topodata.TabletType - 287, // 39: vtctldata.ChangeTabletTypeResponse.before_tablet:type_name -> topodata.Tablet - 287, // 40: vtctldata.ChangeTabletTypeResponse.after_tablet:type_name -> topodata.Tablet - 247, // 41: vtctldata.CleanupSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.CleanupSchemaMigrationResponse.RowsAffectedByShardEntry - 248, // 42: vtctldata.CompleteSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.CompleteSchemaMigrationResponse.RowsAffectedByShardEntry - 288, // 43: vtctldata.CreateKeyspaceRequest.type:type_name -> topodata.KeyspaceType - 277, // 44: vtctldata.CreateKeyspaceRequest.snapshot_time:type_name -> vttime.Time + 281, // 14: vtctldata.SchemaMigration.tablet:type_name -> topodata.TabletAlias + 282, // 15: vtctldata.SchemaMigration.artifact_retention:type_name -> vttime.Duration + 280, // 16: vtctldata.SchemaMigration.last_throttled_at:type_name -> vttime.Time + 280, // 17: vtctldata.SchemaMigration.cancelled_at:type_name -> vttime.Time + 280, // 18: vtctldata.SchemaMigration.reviewed_at:type_name -> vttime.Time + 280, // 19: vtctldata.SchemaMigration.ready_to_complete_at:type_name -> vttime.Time + 283, // 20: vtctldata.Shard.shard:type_name -> topodata.Shard + 239, // 21: vtctldata.Workflow.source:type_name -> vtctldata.Workflow.ReplicationLocation + 239, // 22: vtctldata.Workflow.target:type_name -> vtctldata.Workflow.ReplicationLocation + 238, // 23: vtctldata.Workflow.shard_streams:type_name -> vtctldata.Workflow.ShardStreamsEntry + 284, // 24: vtctldata.AddCellInfoRequest.cell_info:type_name -> topodata.CellInfo + 285, // 25: vtctldata.ApplyRoutingRulesRequest.routing_rules:type_name -> vschema.RoutingRules + 286, // 26: vtctldata.ApplyShardRoutingRulesRequest.shard_routing_rules:type_name -> vschema.ShardRoutingRules + 282, // 27: vtctldata.ApplySchemaRequest.wait_replicas_timeout:type_name -> vttime.Duration + 287, // 28: vtctldata.ApplySchemaRequest.caller_id:type_name -> vtrpc.CallerID + 245, // 29: vtctldata.ApplySchemaResponse.rows_affected_by_shard:type_name -> vtctldata.ApplySchemaResponse.RowsAffectedByShardEntry + 288, // 30: vtctldata.ApplyVSchemaRequest.v_schema:type_name -> vschema.Keyspace + 288, // 31: vtctldata.ApplyVSchemaResponse.v_schema:type_name -> vschema.Keyspace + 246, // 32: vtctldata.ApplyVSchemaResponse.unknown_vindex_params:type_name -> vtctldata.ApplyVSchemaResponse.UnknownVindexParamsEntry + 281, // 33: vtctldata.BackupRequest.tablet_alias:type_name -> topodata.TabletAlias + 281, // 34: vtctldata.BackupResponse.tablet_alias:type_name -> topodata.TabletAlias + 277, // 35: vtctldata.BackupResponse.event:type_name -> logutil.Event + 248, // 36: vtctldata.CancelSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.CancelSchemaMigrationResponse.RowsAffectedByShardEntry + 281, // 37: vtctldata.ChangeTabletTypeRequest.tablet_alias:type_name -> topodata.TabletAlias + 289, // 38: vtctldata.ChangeTabletTypeRequest.db_type:type_name -> topodata.TabletType + 290, // 39: vtctldata.ChangeTabletTypeResponse.before_tablet:type_name -> topodata.Tablet + 290, // 40: vtctldata.ChangeTabletTypeResponse.after_tablet:type_name -> topodata.Tablet + 249, // 41: vtctldata.CleanupSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.CleanupSchemaMigrationResponse.RowsAffectedByShardEntry + 250, // 42: vtctldata.CompleteSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.CompleteSchemaMigrationResponse.RowsAffectedByShardEntry + 291, // 43: vtctldata.CreateKeyspaceRequest.type:type_name -> topodata.KeyspaceType + 280, // 44: vtctldata.CreateKeyspaceRequest.snapshot_time:type_name -> vttime.Time 8, // 45: vtctldata.CreateKeyspaceResponse.keyspace:type_name -> vtctldata.Keyspace 8, // 46: vtctldata.CreateShardResponse.keyspace:type_name -> vtctldata.Keyspace 10, // 47: vtctldata.CreateShardResponse.shard:type_name -> vtctldata.Shard 10, // 48: vtctldata.DeleteShardsRequest.shards:type_name -> vtctldata.Shard - 278, // 49: vtctldata.DeleteTabletsRequest.tablet_aliases:type_name -> topodata.TabletAlias - 278, // 50: vtctldata.EmergencyReparentShardRequest.new_primary:type_name -> topodata.TabletAlias - 278, // 51: vtctldata.EmergencyReparentShardRequest.ignore_replicas:type_name -> topodata.TabletAlias - 279, // 52: vtctldata.EmergencyReparentShardRequest.wait_replicas_timeout:type_name -> vttime.Duration - 278, // 53: vtctldata.EmergencyReparentShardResponse.promoted_primary:type_name -> topodata.TabletAlias - 274, // 54: vtctldata.EmergencyReparentShardResponse.events:type_name -> logutil.Event - 278, // 55: vtctldata.ExecuteFetchAsAppRequest.tablet_alias:type_name -> topodata.TabletAlias - 289, // 56: vtctldata.ExecuteFetchAsAppResponse.result:type_name -> query.QueryResult - 278, // 57: vtctldata.ExecuteFetchAsDBARequest.tablet_alias:type_name -> topodata.TabletAlias - 289, // 58: vtctldata.ExecuteFetchAsDBAResponse.result:type_name -> query.QueryResult - 278, // 59: vtctldata.ExecuteHookRequest.tablet_alias:type_name -> topodata.TabletAlias - 290, // 60: vtctldata.ExecuteHookRequest.tablet_hook_request:type_name -> tabletmanagerdata.ExecuteHookRequest - 291, // 61: vtctldata.ExecuteHookResponse.hook_result:type_name -> tabletmanagerdata.ExecuteHookResponse - 249, // 62: vtctldata.FindAllShardsInKeyspaceResponse.shards:type_name -> vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry - 250, // 63: vtctldata.ForceCutOverSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.ForceCutOverSchemaMigrationResponse.RowsAffectedByShardEntry - 292, // 64: vtctldata.GetBackupsResponse.backups:type_name -> mysqlctl.BackupInfo - 281, // 65: vtctldata.GetCellInfoResponse.cell_info:type_name -> topodata.CellInfo - 251, // 66: vtctldata.GetCellsAliasesResponse.aliases:type_name -> vtctldata.GetCellsAliasesResponse.AliasesEntry - 278, // 67: vtctldata.GetFullStatusRequest.tablet_alias:type_name -> topodata.TabletAlias - 293, // 68: vtctldata.GetFullStatusResponse.status:type_name -> replicationdata.FullStatus + 281, // 49: vtctldata.DeleteTabletsRequest.tablet_aliases:type_name -> topodata.TabletAlias + 281, // 50: vtctldata.EmergencyReparentShardRequest.new_primary:type_name -> topodata.TabletAlias + 281, // 51: vtctldata.EmergencyReparentShardRequest.ignore_replicas:type_name -> topodata.TabletAlias + 282, // 52: vtctldata.EmergencyReparentShardRequest.wait_replicas_timeout:type_name -> vttime.Duration + 281, // 53: vtctldata.EmergencyReparentShardResponse.promoted_primary:type_name -> topodata.TabletAlias + 277, // 54: vtctldata.EmergencyReparentShardResponse.events:type_name -> logutil.Event + 281, // 55: vtctldata.ExecuteFetchAsAppRequest.tablet_alias:type_name -> topodata.TabletAlias + 292, // 56: vtctldata.ExecuteFetchAsAppResponse.result:type_name -> query.QueryResult + 281, // 57: vtctldata.ExecuteFetchAsDBARequest.tablet_alias:type_name -> topodata.TabletAlias + 292, // 58: vtctldata.ExecuteFetchAsDBAResponse.result:type_name -> query.QueryResult + 281, // 59: vtctldata.ExecuteHookRequest.tablet_alias:type_name -> topodata.TabletAlias + 293, // 60: vtctldata.ExecuteHookRequest.tablet_hook_request:type_name -> tabletmanagerdata.ExecuteHookRequest + 294, // 61: vtctldata.ExecuteHookResponse.hook_result:type_name -> tabletmanagerdata.ExecuteHookResponse + 251, // 62: vtctldata.FindAllShardsInKeyspaceResponse.shards:type_name -> vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry + 252, // 63: vtctldata.ForceCutOverSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.ForceCutOverSchemaMigrationResponse.RowsAffectedByShardEntry + 295, // 64: vtctldata.GetBackupsResponse.backups:type_name -> mysqlctl.BackupInfo + 284, // 65: vtctldata.GetCellInfoResponse.cell_info:type_name -> topodata.CellInfo + 253, // 66: vtctldata.GetCellsAliasesResponse.aliases:type_name -> vtctldata.GetCellsAliasesResponse.AliasesEntry + 281, // 67: vtctldata.GetFullStatusRequest.tablet_alias:type_name -> topodata.TabletAlias + 296, // 68: vtctldata.GetFullStatusResponse.status:type_name -> replicationdata.FullStatus 8, // 69: vtctldata.GetKeyspacesResponse.keyspaces:type_name -> vtctldata.Keyspace 8, // 70: vtctldata.GetKeyspaceResponse.keyspace:type_name -> vtctldata.Keyspace - 278, // 71: vtctldata.GetPermissionsRequest.tablet_alias:type_name -> topodata.TabletAlias - 294, // 72: vtctldata.GetPermissionsResponse.permissions:type_name -> tabletmanagerdata.Permissions - 282, // 73: vtctldata.GetRoutingRulesResponse.routing_rules:type_name -> vschema.RoutingRules - 278, // 74: vtctldata.GetSchemaRequest.tablet_alias:type_name -> topodata.TabletAlias - 295, // 75: vtctldata.GetSchemaResponse.schema:type_name -> tabletmanagerdata.SchemaDefinition + 281, // 71: vtctldata.GetPermissionsRequest.tablet_alias:type_name -> topodata.TabletAlias + 297, // 72: vtctldata.GetPermissionsResponse.permissions:type_name -> tabletmanagerdata.Permissions + 285, // 73: vtctldata.GetRoutingRulesResponse.routing_rules:type_name -> vschema.RoutingRules + 281, // 74: vtctldata.GetSchemaRequest.tablet_alias:type_name -> topodata.TabletAlias + 298, // 75: vtctldata.GetSchemaResponse.schema:type_name -> tabletmanagerdata.SchemaDefinition 3, // 76: vtctldata.GetSchemaMigrationsRequest.status:type_name -> vtctldata.SchemaMigration.Status - 279, // 77: vtctldata.GetSchemaMigrationsRequest.recent:type_name -> vttime.Duration + 282, // 77: vtctldata.GetSchemaMigrationsRequest.recent:type_name -> vttime.Duration 1, // 78: vtctldata.GetSchemaMigrationsRequest.order:type_name -> vtctldata.QueryOrdering 9, // 79: vtctldata.GetSchemaMigrationsResponse.migrations:type_name -> vtctldata.SchemaMigration - 10, // 80: vtctldata.GetShardResponse.shard:type_name -> vtctldata.Shard - 283, // 81: vtctldata.GetShardRoutingRulesResponse.shard_routing_rules:type_name -> vschema.ShardRoutingRules - 252, // 82: vtctldata.GetSrvKeyspaceNamesResponse.names:type_name -> vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry - 254, // 83: vtctldata.GetSrvKeyspacesResponse.srv_keyspaces:type_name -> vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry - 296, // 84: vtctldata.UpdateThrottlerConfigRequest.throttled_app:type_name -> topodata.ThrottledAppRule - 297, // 85: vtctldata.GetSrvVSchemaResponse.srv_v_schema:type_name -> vschema.SrvVSchema - 255, // 86: vtctldata.GetSrvVSchemasResponse.srv_v_schemas:type_name -> vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry - 278, // 87: vtctldata.GetTabletRequest.tablet_alias:type_name -> topodata.TabletAlias - 287, // 88: vtctldata.GetTabletResponse.tablet:type_name -> topodata.Tablet - 278, // 89: vtctldata.GetTabletsRequest.tablet_aliases:type_name -> topodata.TabletAlias - 286, // 90: vtctldata.GetTabletsRequest.tablet_type:type_name -> topodata.TabletType - 287, // 91: vtctldata.GetTabletsResponse.tablets:type_name -> topodata.Tablet - 105, // 92: vtctldata.GetTopologyPathResponse.cell:type_name -> vtctldata.TopologyCell - 278, // 93: vtctldata.GetVersionRequest.tablet_alias:type_name -> topodata.TabletAlias - 285, // 94: vtctldata.GetVSchemaResponse.v_schema:type_name -> vschema.Keyspace - 11, // 95: vtctldata.GetWorkflowsResponse.workflows:type_name -> vtctldata.Workflow - 278, // 96: vtctldata.InitShardPrimaryRequest.primary_elect_tablet_alias:type_name -> topodata.TabletAlias - 279, // 97: vtctldata.InitShardPrimaryRequest.wait_replicas_timeout:type_name -> vttime.Duration - 274, // 98: vtctldata.InitShardPrimaryResponse.events:type_name -> logutil.Event - 256, // 99: vtctldata.LaunchSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.LaunchSchemaMigrationResponse.RowsAffectedByShardEntry - 285, // 100: vtctldata.LookupVindexCreateRequest.vindex:type_name -> vschema.Keyspace - 286, // 101: vtctldata.LookupVindexCreateRequest.tablet_types:type_name -> topodata.TabletType - 275, // 102: vtctldata.LookupVindexCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference - 7, // 103: vtctldata.MaterializeCreateRequest.settings:type_name -> vtctldata.MaterializeSettings - 286, // 104: vtctldata.MigrateCreateRequest.tablet_types:type_name -> topodata.TabletType - 275, // 105: vtctldata.MigrateCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference - 286, // 106: vtctldata.MoveTablesCreateRequest.tablet_types:type_name -> topodata.TabletType - 275, // 107: vtctldata.MoveTablesCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference - 257, // 108: vtctldata.MoveTablesCreateResponse.details:type_name -> vtctldata.MoveTablesCreateResponse.TabletInfo - 278, // 109: vtctldata.PingTabletRequest.tablet_alias:type_name -> topodata.TabletAlias - 278, // 110: vtctldata.PlannedReparentShardRequest.new_primary:type_name -> topodata.TabletAlias - 278, // 111: vtctldata.PlannedReparentShardRequest.avoid_primary:type_name -> topodata.TabletAlias - 279, // 112: vtctldata.PlannedReparentShardRequest.wait_replicas_timeout:type_name -> vttime.Duration - 279, // 113: vtctldata.PlannedReparentShardRequest.tolerable_replication_lag:type_name -> vttime.Duration - 278, // 114: vtctldata.PlannedReparentShardResponse.promoted_primary:type_name -> topodata.TabletAlias - 274, // 115: vtctldata.PlannedReparentShardResponse.events:type_name -> logutil.Event - 278, // 116: vtctldata.RefreshStateRequest.tablet_alias:type_name -> topodata.TabletAlias - 278, // 117: vtctldata.ReloadSchemaRequest.tablet_alias:type_name -> topodata.TabletAlias - 274, // 118: vtctldata.ReloadSchemaKeyspaceResponse.events:type_name -> logutil.Event - 274, // 119: vtctldata.ReloadSchemaShardResponse.events:type_name -> logutil.Event - 278, // 120: vtctldata.ReparentTabletRequest.tablet:type_name -> topodata.TabletAlias - 278, // 121: vtctldata.ReparentTabletResponse.primary:type_name -> topodata.TabletAlias - 286, // 122: vtctldata.ReshardCreateRequest.tablet_types:type_name -> topodata.TabletType - 275, // 123: vtctldata.ReshardCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference - 278, // 124: vtctldata.RestoreFromBackupRequest.tablet_alias:type_name -> topodata.TabletAlias - 277, // 125: vtctldata.RestoreFromBackupRequest.backup_time:type_name -> vttime.Time - 277, // 126: vtctldata.RestoreFromBackupRequest.restore_to_timestamp:type_name -> vttime.Time - 278, // 127: vtctldata.RestoreFromBackupResponse.tablet_alias:type_name -> topodata.TabletAlias - 274, // 128: vtctldata.RestoreFromBackupResponse.event:type_name -> logutil.Event - 258, // 129: vtctldata.RetrySchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.RetrySchemaMigrationResponse.RowsAffectedByShardEntry - 278, // 130: vtctldata.RunHealthCheckRequest.tablet_alias:type_name -> topodata.TabletAlias - 276, // 131: vtctldata.SetKeyspaceDurabilityPolicyResponse.keyspace:type_name -> topodata.Keyspace - 276, // 132: vtctldata.SetKeyspaceShardingInfoResponse.keyspace:type_name -> topodata.Keyspace - 280, // 133: vtctldata.SetShardIsPrimaryServingResponse.shard:type_name -> topodata.Shard - 286, // 134: vtctldata.SetShardTabletControlRequest.tablet_type:type_name -> topodata.TabletType - 280, // 135: vtctldata.SetShardTabletControlResponse.shard:type_name -> topodata.Shard - 278, // 136: vtctldata.SetWritableRequest.tablet_alias:type_name -> topodata.TabletAlias - 278, // 137: vtctldata.ShardReplicationAddRequest.tablet_alias:type_name -> topodata.TabletAlias - 298, // 138: vtctldata.ShardReplicationFixResponse.error:type_name -> topodata.ShardReplicationError - 259, // 139: vtctldata.ShardReplicationPositionsResponse.replication_statuses:type_name -> vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry - 260, // 140: vtctldata.ShardReplicationPositionsResponse.tablet_map:type_name -> vtctldata.ShardReplicationPositionsResponse.TabletMapEntry - 278, // 141: vtctldata.ShardReplicationRemoveRequest.tablet_alias:type_name -> topodata.TabletAlias - 278, // 142: vtctldata.SleepTabletRequest.tablet_alias:type_name -> topodata.TabletAlias - 279, // 143: vtctldata.SleepTabletRequest.duration:type_name -> vttime.Duration - 299, // 144: vtctldata.SourceShardAddRequest.key_range:type_name -> topodata.KeyRange - 280, // 145: vtctldata.SourceShardAddResponse.shard:type_name -> topodata.Shard - 280, // 146: vtctldata.SourceShardDeleteResponse.shard:type_name -> topodata.Shard - 278, // 147: vtctldata.StartReplicationRequest.tablet_alias:type_name -> topodata.TabletAlias - 278, // 148: vtctldata.StopReplicationRequest.tablet_alias:type_name -> topodata.TabletAlias - 278, // 149: vtctldata.TabletExternallyReparentedRequest.tablet:type_name -> topodata.TabletAlias - 278, // 150: vtctldata.TabletExternallyReparentedResponse.new_primary:type_name -> topodata.TabletAlias - 278, // 151: vtctldata.TabletExternallyReparentedResponse.old_primary:type_name -> topodata.TabletAlias - 281, // 152: vtctldata.UpdateCellInfoRequest.cell_info:type_name -> topodata.CellInfo - 281, // 153: vtctldata.UpdateCellInfoResponse.cell_info:type_name -> topodata.CellInfo - 300, // 154: vtctldata.UpdateCellsAliasRequest.cells_alias:type_name -> topodata.CellsAlias - 300, // 155: vtctldata.UpdateCellsAliasResponse.cells_alias:type_name -> topodata.CellsAlias - 261, // 156: vtctldata.ValidateResponse.results_by_keyspace:type_name -> vtctldata.ValidateResponse.ResultsByKeyspaceEntry - 262, // 157: vtctldata.ValidateKeyspaceResponse.results_by_shard:type_name -> vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry - 263, // 158: vtctldata.ValidateSchemaKeyspaceResponse.results_by_shard:type_name -> vtctldata.ValidateSchemaKeyspaceResponse.ResultsByShardEntry - 264, // 159: vtctldata.ValidateVersionKeyspaceResponse.results_by_shard:type_name -> vtctldata.ValidateVersionKeyspaceResponse.ResultsByShardEntry - 265, // 160: vtctldata.ValidateVSchemaResponse.results_by_shard:type_name -> vtctldata.ValidateVSchemaResponse.ResultsByShardEntry - 286, // 161: vtctldata.VDiffCreateRequest.tablet_types:type_name -> topodata.TabletType - 275, // 162: vtctldata.VDiffCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference - 279, // 163: vtctldata.VDiffCreateRequest.filtered_replication_wait_time:type_name -> vttime.Duration - 279, // 164: vtctldata.VDiffCreateRequest.wait_update_interval:type_name -> vttime.Duration - 279, // 165: vtctldata.VDiffCreateRequest.max_diff_duration:type_name -> vttime.Duration - 266, // 166: vtctldata.VDiffShowResponse.tablet_responses:type_name -> vtctldata.VDiffShowResponse.TabletResponsesEntry - 267, // 167: vtctldata.WorkflowDeleteResponse.details:type_name -> vtctldata.WorkflowDeleteResponse.TabletInfo - 271, // 168: vtctldata.WorkflowStatusResponse.table_copy_state:type_name -> vtctldata.WorkflowStatusResponse.TableCopyStateEntry - 272, // 169: vtctldata.WorkflowStatusResponse.shard_streams:type_name -> vtctldata.WorkflowStatusResponse.ShardStreamsEntry - 286, // 170: vtctldata.WorkflowSwitchTrafficRequest.tablet_types:type_name -> topodata.TabletType - 279, // 171: vtctldata.WorkflowSwitchTrafficRequest.max_replication_lag_allowed:type_name -> vttime.Duration - 279, // 172: vtctldata.WorkflowSwitchTrafficRequest.timeout:type_name -> vttime.Duration - 301, // 173: vtctldata.WorkflowUpdateRequest.tablet_request:type_name -> tabletmanagerdata.UpdateVReplicationWorkflowRequest - 273, // 174: vtctldata.WorkflowUpdateResponse.details:type_name -> vtctldata.WorkflowUpdateResponse.TabletInfo - 238, // 175: vtctldata.Workflow.ShardStreamsEntry.value:type_name -> vtctldata.Workflow.ShardStream - 239, // 176: vtctldata.Workflow.ShardStream.streams:type_name -> vtctldata.Workflow.Stream - 302, // 177: vtctldata.Workflow.ShardStream.tablet_controls:type_name -> topodata.Shard.TabletControl - 278, // 178: vtctldata.Workflow.Stream.tablet:type_name -> topodata.TabletAlias - 303, // 179: vtctldata.Workflow.Stream.binlog_source:type_name -> binlogdata.BinlogSource - 277, // 180: vtctldata.Workflow.Stream.transaction_timestamp:type_name -> vttime.Time - 277, // 181: vtctldata.Workflow.Stream.time_updated:type_name -> vttime.Time - 240, // 182: vtctldata.Workflow.Stream.copy_states:type_name -> vtctldata.Workflow.Stream.CopyState - 241, // 183: vtctldata.Workflow.Stream.logs:type_name -> vtctldata.Workflow.Stream.Log - 242, // 184: vtctldata.Workflow.Stream.throttler_status:type_name -> vtctldata.Workflow.Stream.ThrottlerStatus - 286, // 185: vtctldata.Workflow.Stream.tablet_types:type_name -> topodata.TabletType - 275, // 186: vtctldata.Workflow.Stream.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference - 277, // 187: vtctldata.Workflow.Stream.Log.created_at:type_name -> vttime.Time - 277, // 188: vtctldata.Workflow.Stream.Log.updated_at:type_name -> vttime.Time - 277, // 189: vtctldata.Workflow.Stream.ThrottlerStatus.time_throttled:type_name -> vttime.Time - 245, // 190: vtctldata.ApplyVSchemaResponse.UnknownVindexParamsEntry.value:type_name -> vtctldata.ApplyVSchemaResponse.ParamList - 10, // 191: vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry.value:type_name -> vtctldata.Shard - 300, // 192: vtctldata.GetCellsAliasesResponse.AliasesEntry.value:type_name -> topodata.CellsAlias - 253, // 193: vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry.value:type_name -> vtctldata.GetSrvKeyspaceNamesResponse.NameList - 304, // 194: vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry.value:type_name -> topodata.SrvKeyspace - 297, // 195: vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry.value:type_name -> vschema.SrvVSchema - 278, // 196: vtctldata.MoveTablesCreateResponse.TabletInfo.tablet:type_name -> topodata.TabletAlias - 305, // 197: vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry.value:type_name -> replicationdata.Status - 287, // 198: vtctldata.ShardReplicationPositionsResponse.TabletMapEntry.value:type_name -> topodata.Tablet - 207, // 199: vtctldata.ValidateResponse.ResultsByKeyspaceEntry.value:type_name -> vtctldata.ValidateKeyspaceResponse - 211, // 200: vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse - 211, // 201: vtctldata.ValidateSchemaKeyspaceResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse - 211, // 202: vtctldata.ValidateVersionKeyspaceResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse - 211, // 203: vtctldata.ValidateVSchemaResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse - 306, // 204: vtctldata.VDiffShowResponse.TabletResponsesEntry.value:type_name -> tabletmanagerdata.VDiffResponse - 278, // 205: vtctldata.WorkflowDeleteResponse.TabletInfo.tablet:type_name -> topodata.TabletAlias - 278, // 206: vtctldata.WorkflowStatusResponse.ShardStreamState.tablet:type_name -> topodata.TabletAlias - 269, // 207: vtctldata.WorkflowStatusResponse.ShardStreams.streams:type_name -> vtctldata.WorkflowStatusResponse.ShardStreamState - 268, // 208: vtctldata.WorkflowStatusResponse.TableCopyStateEntry.value:type_name -> vtctldata.WorkflowStatusResponse.TableCopyState - 270, // 209: vtctldata.WorkflowStatusResponse.ShardStreamsEntry.value:type_name -> vtctldata.WorkflowStatusResponse.ShardStreams - 278, // 210: vtctldata.WorkflowUpdateResponse.TabletInfo.tablet:type_name -> topodata.TabletAlias - 211, // [211:211] is the sub-list for method output_type - 211, // [211:211] is the sub-list for method input_type - 211, // [211:211] is the sub-list for extension type_name - 211, // [211:211] is the sub-list for extension extendee - 0, // [0:211] is the sub-list for field type_name + 254, // 80: vtctldata.GetShardReplicationResponse.shard_replication_by_cell:type_name -> vtctldata.GetShardReplicationResponse.ShardReplicationByCellEntry + 10, // 81: vtctldata.GetShardResponse.shard:type_name -> vtctldata.Shard + 286, // 82: vtctldata.GetShardRoutingRulesResponse.shard_routing_rules:type_name -> vschema.ShardRoutingRules + 255, // 83: vtctldata.GetSrvKeyspaceNamesResponse.names:type_name -> vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry + 257, // 84: vtctldata.GetSrvKeyspacesResponse.srv_keyspaces:type_name -> vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry + 299, // 85: vtctldata.UpdateThrottlerConfigRequest.throttled_app:type_name -> topodata.ThrottledAppRule + 300, // 86: vtctldata.GetSrvVSchemaResponse.srv_v_schema:type_name -> vschema.SrvVSchema + 258, // 87: vtctldata.GetSrvVSchemasResponse.srv_v_schemas:type_name -> vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry + 281, // 88: vtctldata.GetTabletRequest.tablet_alias:type_name -> topodata.TabletAlias + 290, // 89: vtctldata.GetTabletResponse.tablet:type_name -> topodata.Tablet + 281, // 90: vtctldata.GetTabletsRequest.tablet_aliases:type_name -> topodata.TabletAlias + 289, // 91: vtctldata.GetTabletsRequest.tablet_type:type_name -> topodata.TabletType + 290, // 92: vtctldata.GetTabletsResponse.tablets:type_name -> topodata.Tablet + 107, // 93: vtctldata.GetTopologyPathResponse.cell:type_name -> vtctldata.TopologyCell + 281, // 94: vtctldata.GetVersionRequest.tablet_alias:type_name -> topodata.TabletAlias + 288, // 95: vtctldata.GetVSchemaResponse.v_schema:type_name -> vschema.Keyspace + 11, // 96: vtctldata.GetWorkflowsResponse.workflows:type_name -> vtctldata.Workflow + 281, // 97: vtctldata.InitShardPrimaryRequest.primary_elect_tablet_alias:type_name -> topodata.TabletAlias + 282, // 98: vtctldata.InitShardPrimaryRequest.wait_replicas_timeout:type_name -> vttime.Duration + 277, // 99: vtctldata.InitShardPrimaryResponse.events:type_name -> logutil.Event + 259, // 100: vtctldata.LaunchSchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.LaunchSchemaMigrationResponse.RowsAffectedByShardEntry + 288, // 101: vtctldata.LookupVindexCreateRequest.vindex:type_name -> vschema.Keyspace + 289, // 102: vtctldata.LookupVindexCreateRequest.tablet_types:type_name -> topodata.TabletType + 278, // 103: vtctldata.LookupVindexCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference + 7, // 104: vtctldata.MaterializeCreateRequest.settings:type_name -> vtctldata.MaterializeSettings + 289, // 105: vtctldata.MigrateCreateRequest.tablet_types:type_name -> topodata.TabletType + 278, // 106: vtctldata.MigrateCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference + 289, // 107: vtctldata.MoveTablesCreateRequest.tablet_types:type_name -> topodata.TabletType + 278, // 108: vtctldata.MoveTablesCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference + 260, // 109: vtctldata.MoveTablesCreateResponse.details:type_name -> vtctldata.MoveTablesCreateResponse.TabletInfo + 281, // 110: vtctldata.PingTabletRequest.tablet_alias:type_name -> topodata.TabletAlias + 281, // 111: vtctldata.PlannedReparentShardRequest.new_primary:type_name -> topodata.TabletAlias + 281, // 112: vtctldata.PlannedReparentShardRequest.avoid_primary:type_name -> topodata.TabletAlias + 282, // 113: vtctldata.PlannedReparentShardRequest.wait_replicas_timeout:type_name -> vttime.Duration + 282, // 114: vtctldata.PlannedReparentShardRequest.tolerable_replication_lag:type_name -> vttime.Duration + 281, // 115: vtctldata.PlannedReparentShardResponse.promoted_primary:type_name -> topodata.TabletAlias + 277, // 116: vtctldata.PlannedReparentShardResponse.events:type_name -> logutil.Event + 281, // 117: vtctldata.RefreshStateRequest.tablet_alias:type_name -> topodata.TabletAlias + 281, // 118: vtctldata.ReloadSchemaRequest.tablet_alias:type_name -> topodata.TabletAlias + 277, // 119: vtctldata.ReloadSchemaKeyspaceResponse.events:type_name -> logutil.Event + 277, // 120: vtctldata.ReloadSchemaShardResponse.events:type_name -> logutil.Event + 281, // 121: vtctldata.ReparentTabletRequest.tablet:type_name -> topodata.TabletAlias + 281, // 122: vtctldata.ReparentTabletResponse.primary:type_name -> topodata.TabletAlias + 289, // 123: vtctldata.ReshardCreateRequest.tablet_types:type_name -> topodata.TabletType + 278, // 124: vtctldata.ReshardCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference + 281, // 125: vtctldata.RestoreFromBackupRequest.tablet_alias:type_name -> topodata.TabletAlias + 280, // 126: vtctldata.RestoreFromBackupRequest.backup_time:type_name -> vttime.Time + 280, // 127: vtctldata.RestoreFromBackupRequest.restore_to_timestamp:type_name -> vttime.Time + 281, // 128: vtctldata.RestoreFromBackupResponse.tablet_alias:type_name -> topodata.TabletAlias + 277, // 129: vtctldata.RestoreFromBackupResponse.event:type_name -> logutil.Event + 261, // 130: vtctldata.RetrySchemaMigrationResponse.rows_affected_by_shard:type_name -> vtctldata.RetrySchemaMigrationResponse.RowsAffectedByShardEntry + 281, // 131: vtctldata.RunHealthCheckRequest.tablet_alias:type_name -> topodata.TabletAlias + 279, // 132: vtctldata.SetKeyspaceDurabilityPolicyResponse.keyspace:type_name -> topodata.Keyspace + 279, // 133: vtctldata.SetKeyspaceShardingInfoResponse.keyspace:type_name -> topodata.Keyspace + 283, // 134: vtctldata.SetShardIsPrimaryServingResponse.shard:type_name -> topodata.Shard + 289, // 135: vtctldata.SetShardTabletControlRequest.tablet_type:type_name -> topodata.TabletType + 283, // 136: vtctldata.SetShardTabletControlResponse.shard:type_name -> topodata.Shard + 281, // 137: vtctldata.SetWritableRequest.tablet_alias:type_name -> topodata.TabletAlias + 281, // 138: vtctldata.ShardReplicationAddRequest.tablet_alias:type_name -> topodata.TabletAlias + 301, // 139: vtctldata.ShardReplicationFixResponse.error:type_name -> topodata.ShardReplicationError + 262, // 140: vtctldata.ShardReplicationPositionsResponse.replication_statuses:type_name -> vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry + 263, // 141: vtctldata.ShardReplicationPositionsResponse.tablet_map:type_name -> vtctldata.ShardReplicationPositionsResponse.TabletMapEntry + 281, // 142: vtctldata.ShardReplicationRemoveRequest.tablet_alias:type_name -> topodata.TabletAlias + 281, // 143: vtctldata.SleepTabletRequest.tablet_alias:type_name -> topodata.TabletAlias + 282, // 144: vtctldata.SleepTabletRequest.duration:type_name -> vttime.Duration + 302, // 145: vtctldata.SourceShardAddRequest.key_range:type_name -> topodata.KeyRange + 283, // 146: vtctldata.SourceShardAddResponse.shard:type_name -> topodata.Shard + 283, // 147: vtctldata.SourceShardDeleteResponse.shard:type_name -> topodata.Shard + 281, // 148: vtctldata.StartReplicationRequest.tablet_alias:type_name -> topodata.TabletAlias + 281, // 149: vtctldata.StopReplicationRequest.tablet_alias:type_name -> topodata.TabletAlias + 281, // 150: vtctldata.TabletExternallyReparentedRequest.tablet:type_name -> topodata.TabletAlias + 281, // 151: vtctldata.TabletExternallyReparentedResponse.new_primary:type_name -> topodata.TabletAlias + 281, // 152: vtctldata.TabletExternallyReparentedResponse.old_primary:type_name -> topodata.TabletAlias + 284, // 153: vtctldata.UpdateCellInfoRequest.cell_info:type_name -> topodata.CellInfo + 284, // 154: vtctldata.UpdateCellInfoResponse.cell_info:type_name -> topodata.CellInfo + 303, // 155: vtctldata.UpdateCellsAliasRequest.cells_alias:type_name -> topodata.CellsAlias + 303, // 156: vtctldata.UpdateCellsAliasResponse.cells_alias:type_name -> topodata.CellsAlias + 264, // 157: vtctldata.ValidateResponse.results_by_keyspace:type_name -> vtctldata.ValidateResponse.ResultsByKeyspaceEntry + 265, // 158: vtctldata.ValidateKeyspaceResponse.results_by_shard:type_name -> vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry + 266, // 159: vtctldata.ValidateSchemaKeyspaceResponse.results_by_shard:type_name -> vtctldata.ValidateSchemaKeyspaceResponse.ResultsByShardEntry + 267, // 160: vtctldata.ValidateVersionKeyspaceResponse.results_by_shard:type_name -> vtctldata.ValidateVersionKeyspaceResponse.ResultsByShardEntry + 268, // 161: vtctldata.ValidateVSchemaResponse.results_by_shard:type_name -> vtctldata.ValidateVSchemaResponse.ResultsByShardEntry + 289, // 162: vtctldata.VDiffCreateRequest.tablet_types:type_name -> topodata.TabletType + 278, // 163: vtctldata.VDiffCreateRequest.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference + 282, // 164: vtctldata.VDiffCreateRequest.filtered_replication_wait_time:type_name -> vttime.Duration + 282, // 165: vtctldata.VDiffCreateRequest.wait_update_interval:type_name -> vttime.Duration + 282, // 166: vtctldata.VDiffCreateRequest.max_diff_duration:type_name -> vttime.Duration + 269, // 167: vtctldata.VDiffShowResponse.tablet_responses:type_name -> vtctldata.VDiffShowResponse.TabletResponsesEntry + 270, // 168: vtctldata.WorkflowDeleteResponse.details:type_name -> vtctldata.WorkflowDeleteResponse.TabletInfo + 274, // 169: vtctldata.WorkflowStatusResponse.table_copy_state:type_name -> vtctldata.WorkflowStatusResponse.TableCopyStateEntry + 275, // 170: vtctldata.WorkflowStatusResponse.shard_streams:type_name -> vtctldata.WorkflowStatusResponse.ShardStreamsEntry + 289, // 171: vtctldata.WorkflowSwitchTrafficRequest.tablet_types:type_name -> topodata.TabletType + 282, // 172: vtctldata.WorkflowSwitchTrafficRequest.max_replication_lag_allowed:type_name -> vttime.Duration + 282, // 173: vtctldata.WorkflowSwitchTrafficRequest.timeout:type_name -> vttime.Duration + 304, // 174: vtctldata.WorkflowUpdateRequest.tablet_request:type_name -> tabletmanagerdata.UpdateVReplicationWorkflowRequest + 276, // 175: vtctldata.WorkflowUpdateResponse.details:type_name -> vtctldata.WorkflowUpdateResponse.TabletInfo + 240, // 176: vtctldata.Workflow.ShardStreamsEntry.value:type_name -> vtctldata.Workflow.ShardStream + 241, // 177: vtctldata.Workflow.ShardStream.streams:type_name -> vtctldata.Workflow.Stream + 305, // 178: vtctldata.Workflow.ShardStream.tablet_controls:type_name -> topodata.Shard.TabletControl + 281, // 179: vtctldata.Workflow.Stream.tablet:type_name -> topodata.TabletAlias + 306, // 180: vtctldata.Workflow.Stream.binlog_source:type_name -> binlogdata.BinlogSource + 280, // 181: vtctldata.Workflow.Stream.transaction_timestamp:type_name -> vttime.Time + 280, // 182: vtctldata.Workflow.Stream.time_updated:type_name -> vttime.Time + 242, // 183: vtctldata.Workflow.Stream.copy_states:type_name -> vtctldata.Workflow.Stream.CopyState + 243, // 184: vtctldata.Workflow.Stream.logs:type_name -> vtctldata.Workflow.Stream.Log + 244, // 185: vtctldata.Workflow.Stream.throttler_status:type_name -> vtctldata.Workflow.Stream.ThrottlerStatus + 289, // 186: vtctldata.Workflow.Stream.tablet_types:type_name -> topodata.TabletType + 278, // 187: vtctldata.Workflow.Stream.tablet_selection_preference:type_name -> tabletmanagerdata.TabletSelectionPreference + 280, // 188: vtctldata.Workflow.Stream.Log.created_at:type_name -> vttime.Time + 280, // 189: vtctldata.Workflow.Stream.Log.updated_at:type_name -> vttime.Time + 280, // 190: vtctldata.Workflow.Stream.ThrottlerStatus.time_throttled:type_name -> vttime.Time + 247, // 191: vtctldata.ApplyVSchemaResponse.UnknownVindexParamsEntry.value:type_name -> vtctldata.ApplyVSchemaResponse.ParamList + 10, // 192: vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry.value:type_name -> vtctldata.Shard + 303, // 193: vtctldata.GetCellsAliasesResponse.AliasesEntry.value:type_name -> topodata.CellsAlias + 307, // 194: vtctldata.GetShardReplicationResponse.ShardReplicationByCellEntry.value:type_name -> topodata.ShardReplication + 256, // 195: vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry.value:type_name -> vtctldata.GetSrvKeyspaceNamesResponse.NameList + 308, // 196: vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry.value:type_name -> topodata.SrvKeyspace + 300, // 197: vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry.value:type_name -> vschema.SrvVSchema + 281, // 198: vtctldata.MoveTablesCreateResponse.TabletInfo.tablet:type_name -> topodata.TabletAlias + 309, // 199: vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry.value:type_name -> replicationdata.Status + 290, // 200: vtctldata.ShardReplicationPositionsResponse.TabletMapEntry.value:type_name -> topodata.Tablet + 209, // 201: vtctldata.ValidateResponse.ResultsByKeyspaceEntry.value:type_name -> vtctldata.ValidateKeyspaceResponse + 213, // 202: vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse + 213, // 203: vtctldata.ValidateSchemaKeyspaceResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse + 213, // 204: vtctldata.ValidateVersionKeyspaceResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse + 213, // 205: vtctldata.ValidateVSchemaResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse + 310, // 206: vtctldata.VDiffShowResponse.TabletResponsesEntry.value:type_name -> tabletmanagerdata.VDiffResponse + 281, // 207: vtctldata.WorkflowDeleteResponse.TabletInfo.tablet:type_name -> topodata.TabletAlias + 281, // 208: vtctldata.WorkflowStatusResponse.ShardStreamState.tablet:type_name -> topodata.TabletAlias + 272, // 209: vtctldata.WorkflowStatusResponse.ShardStreams.streams:type_name -> vtctldata.WorkflowStatusResponse.ShardStreamState + 271, // 210: vtctldata.WorkflowStatusResponse.TableCopyStateEntry.value:type_name -> vtctldata.WorkflowStatusResponse.TableCopyState + 273, // 211: vtctldata.WorkflowStatusResponse.ShardStreamsEntry.value:type_name -> vtctldata.WorkflowStatusResponse.ShardStreams + 281, // 212: vtctldata.WorkflowUpdateResponse.TabletInfo.tablet:type_name -> topodata.TabletAlias + 213, // [213:213] is the sub-list for method output_type + 213, // [213:213] is the sub-list for method input_type + 213, // [213:213] is the sub-list for extension type_name + 213, // [213:213] is the sub-list for extension extendee + 0, // [0:213] is the sub-list for field type_name } func init() { file_vtctldata_proto_init() } @@ -19369,7 +19510,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetShardRequest); i { + switch v := v.(*GetShardReplicationRequest); i { case 0: return &v.state case 1: @@ -19381,7 +19522,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetShardResponse); i { + switch v := v.(*GetShardReplicationResponse); i { case 0: return &v.state case 1: @@ -19393,7 +19534,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetShardRoutingRulesRequest); i { + switch v := v.(*GetShardRequest); i { case 0: return &v.state case 1: @@ -19405,7 +19546,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetShardRoutingRulesResponse); i { + switch v := v.(*GetShardResponse); i { case 0: return &v.state case 1: @@ -19417,7 +19558,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvKeyspaceNamesRequest); i { + switch v := v.(*GetShardRoutingRulesRequest); i { case 0: return &v.state case 1: @@ -19429,7 +19570,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvKeyspaceNamesResponse); i { + switch v := v.(*GetShardRoutingRulesResponse); i { case 0: return &v.state case 1: @@ -19441,7 +19582,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvKeyspacesRequest); i { + switch v := v.(*GetSrvKeyspaceNamesRequest); i { case 0: return &v.state case 1: @@ -19453,7 +19594,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvKeyspacesResponse); i { + switch v := v.(*GetSrvKeyspaceNamesResponse); i { case 0: return &v.state case 1: @@ -19465,7 +19606,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateThrottlerConfigRequest); i { + switch v := v.(*GetSrvKeyspacesRequest); i { case 0: return &v.state case 1: @@ -19477,7 +19618,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateThrottlerConfigResponse); i { + switch v := v.(*GetSrvKeyspacesResponse); i { case 0: return &v.state case 1: @@ -19489,7 +19630,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvVSchemaRequest); i { + switch v := v.(*UpdateThrottlerConfigRequest); i { case 0: return &v.state case 1: @@ -19501,7 +19642,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvVSchemaResponse); i { + switch v := v.(*UpdateThrottlerConfigResponse); i { case 0: return &v.state case 1: @@ -19513,7 +19654,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvVSchemasRequest); i { + switch v := v.(*GetSrvVSchemaRequest); i { case 0: return &v.state case 1: @@ -19525,7 +19666,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSrvVSchemasResponse); i { + switch v := v.(*GetSrvVSchemaResponse); i { case 0: return &v.state case 1: @@ -19537,7 +19678,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTabletRequest); i { + switch v := v.(*GetSrvVSchemasRequest); i { case 0: return &v.state case 1: @@ -19549,7 +19690,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTabletResponse); i { + switch v := v.(*GetSrvVSchemasResponse); i { case 0: return &v.state case 1: @@ -19561,7 +19702,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTabletsRequest); i { + switch v := v.(*GetTabletRequest); i { case 0: return &v.state case 1: @@ -19573,7 +19714,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTabletsResponse); i { + switch v := v.(*GetTabletResponse); i { case 0: return &v.state case 1: @@ -19585,7 +19726,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTopologyPathRequest); i { + switch v := v.(*GetTabletsRequest); i { case 0: return &v.state case 1: @@ -19597,7 +19738,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetTopologyPathResponse); i { + switch v := v.(*GetTabletsResponse); i { case 0: return &v.state case 1: @@ -19609,7 +19750,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TopologyCell); i { + switch v := v.(*GetTopologyPathRequest); i { case 0: return &v.state case 1: @@ -19621,7 +19762,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetVSchemaRequest); i { + switch v := v.(*GetTopologyPathResponse); i { case 0: return &v.state case 1: @@ -19633,7 +19774,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetVersionRequest); i { + switch v := v.(*TopologyCell); i { case 0: return &v.state case 1: @@ -19645,7 +19786,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetVersionResponse); i { + switch v := v.(*GetVSchemaRequest); i { case 0: return &v.state case 1: @@ -19657,7 +19798,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetVSchemaResponse); i { + switch v := v.(*GetVersionRequest); i { case 0: return &v.state case 1: @@ -19669,7 +19810,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetWorkflowsRequest); i { + switch v := v.(*GetVersionResponse); i { case 0: return &v.state case 1: @@ -19681,7 +19822,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetWorkflowsResponse); i { + switch v := v.(*GetVSchemaResponse); i { case 0: return &v.state case 1: @@ -19693,7 +19834,7 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*InitShardPrimaryRequest); i { + switch v := v.(*GetWorkflowsRequest); i { case 0: return &v.state case 1: @@ -19705,6 +19846,30 @@ func file_vtctldata_proto_init() { } } file_vtctldata_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetWorkflowsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_vtctldata_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*InitShardPrimaryRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_vtctldata_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*InitShardPrimaryResponse); i { case 0: return &v.state @@ -19716,7 +19881,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LaunchSchemaMigrationRequest); i { case 0: return &v.state @@ -19728,7 +19893,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LaunchSchemaMigrationResponse); i { case 0: return &v.state @@ -19740,7 +19905,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LookupVindexCreateRequest); i { case 0: return &v.state @@ -19752,7 +19917,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LookupVindexCreateResponse); i { case 0: return &v.state @@ -19764,7 +19929,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LookupVindexExternalizeRequest); i { case 0: return &v.state @@ -19776,7 +19941,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LookupVindexExternalizeResponse); i { case 0: return &v.state @@ -19788,7 +19953,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MaterializeCreateRequest); i { case 0: return &v.state @@ -19800,7 +19965,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MaterializeCreateResponse); i { case 0: return &v.state @@ -19812,7 +19977,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MigrateCreateRequest); i { case 0: return &v.state @@ -19824,7 +19989,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MigrateCompleteRequest); i { case 0: return &v.state @@ -19836,7 +20001,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MigrateCompleteResponse); i { case 0: return &v.state @@ -19848,7 +20013,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountRegisterRequest); i { case 0: return &v.state @@ -19860,7 +20025,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountRegisterResponse); i { case 0: return &v.state @@ -19872,7 +20037,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountUnregisterRequest); i { case 0: return &v.state @@ -19884,7 +20049,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountUnregisterResponse); i { case 0: return &v.state @@ -19896,7 +20061,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountShowRequest); i { case 0: return &v.state @@ -19908,7 +20073,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountShowResponse); i { case 0: return &v.state @@ -19920,7 +20085,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[129].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountListRequest); i { case 0: return &v.state @@ -19932,7 +20097,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MountListResponse); i { case 0: return &v.state @@ -19944,7 +20109,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[129].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MoveTablesCreateRequest); i { case 0: return &v.state @@ -19956,7 +20121,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[132].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MoveTablesCreateResponse); i { case 0: return &v.state @@ -19968,7 +20133,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[133].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MoveTablesCompleteRequest); i { case 0: return &v.state @@ -19980,7 +20145,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[132].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[134].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MoveTablesCompleteResponse); i { case 0: return &v.state @@ -19992,7 +20157,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[133].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[135].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PingTabletRequest); i { case 0: return &v.state @@ -20004,7 +20169,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[134].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[136].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PingTabletResponse); i { case 0: return &v.state @@ -20016,7 +20181,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[135].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[137].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PlannedReparentShardRequest); i { case 0: return &v.state @@ -20028,7 +20193,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[136].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[138].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PlannedReparentShardResponse); i { case 0: return &v.state @@ -20040,7 +20205,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[137].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[139].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RebuildKeyspaceGraphRequest); i { case 0: return &v.state @@ -20052,7 +20217,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[138].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[140].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RebuildKeyspaceGraphResponse); i { case 0: return &v.state @@ -20064,7 +20229,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[139].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[141].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RebuildVSchemaGraphRequest); i { case 0: return &v.state @@ -20076,7 +20241,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[140].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[142].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RebuildVSchemaGraphResponse); i { case 0: return &v.state @@ -20088,7 +20253,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[141].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[143].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RefreshStateRequest); i { case 0: return &v.state @@ -20100,7 +20265,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[142].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[144].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RefreshStateResponse); i { case 0: return &v.state @@ -20112,7 +20277,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[143].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[145].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RefreshStateByShardRequest); i { case 0: return &v.state @@ -20124,7 +20289,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[144].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[146].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RefreshStateByShardResponse); i { case 0: return &v.state @@ -20136,7 +20301,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[145].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[147].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReloadSchemaRequest); i { case 0: return &v.state @@ -20148,7 +20313,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[146].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[148].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReloadSchemaResponse); i { case 0: return &v.state @@ -20160,7 +20325,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[147].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[149].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReloadSchemaKeyspaceRequest); i { case 0: return &v.state @@ -20172,7 +20337,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[148].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[150].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReloadSchemaKeyspaceResponse); i { case 0: return &v.state @@ -20184,7 +20349,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[149].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[151].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReloadSchemaShardRequest); i { case 0: return &v.state @@ -20196,7 +20361,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[150].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[152].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReloadSchemaShardResponse); i { case 0: return &v.state @@ -20208,7 +20373,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[151].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[153].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveBackupRequest); i { case 0: return &v.state @@ -20220,7 +20385,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[152].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[154].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveBackupResponse); i { case 0: return &v.state @@ -20232,7 +20397,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[153].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[155].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveKeyspaceCellRequest); i { case 0: return &v.state @@ -20244,7 +20409,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[154].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[156].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveKeyspaceCellResponse); i { case 0: return &v.state @@ -20256,7 +20421,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[155].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[157].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveShardCellRequest); i { case 0: return &v.state @@ -20268,7 +20433,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[156].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[158].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RemoveShardCellResponse); i { case 0: return &v.state @@ -20280,7 +20445,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[157].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[159].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReparentTabletRequest); i { case 0: return &v.state @@ -20292,7 +20457,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[158].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[160].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReparentTabletResponse); i { case 0: return &v.state @@ -20304,7 +20469,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[159].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[161].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReshardCreateRequest); i { case 0: return &v.state @@ -20316,7 +20481,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[160].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[162].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RestoreFromBackupRequest); i { case 0: return &v.state @@ -20328,7 +20493,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[161].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[163].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RestoreFromBackupResponse); i { case 0: return &v.state @@ -20340,7 +20505,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[162].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[164].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RetrySchemaMigrationRequest); i { case 0: return &v.state @@ -20352,7 +20517,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[163].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[165].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RetrySchemaMigrationResponse); i { case 0: return &v.state @@ -20364,7 +20529,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[164].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[166].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RunHealthCheckRequest); i { case 0: return &v.state @@ -20376,7 +20541,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[165].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[167].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RunHealthCheckResponse); i { case 0: return &v.state @@ -20388,7 +20553,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[166].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[168].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetKeyspaceDurabilityPolicyRequest); i { case 0: return &v.state @@ -20400,7 +20565,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[167].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[169].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetKeyspaceDurabilityPolicyResponse); i { case 0: return &v.state @@ -20412,7 +20577,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[168].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[170].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetKeyspaceShardingInfoRequest); i { case 0: return &v.state @@ -20424,7 +20589,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[169].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[171].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetKeyspaceShardingInfoResponse); i { case 0: return &v.state @@ -20436,7 +20601,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[170].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[172].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetShardIsPrimaryServingRequest); i { case 0: return &v.state @@ -20448,7 +20613,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[171].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[173].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetShardIsPrimaryServingResponse); i { case 0: return &v.state @@ -20460,7 +20625,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[172].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[174].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetShardTabletControlRequest); i { case 0: return &v.state @@ -20472,7 +20637,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[173].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[175].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetShardTabletControlResponse); i { case 0: return &v.state @@ -20484,7 +20649,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[174].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[176].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetWritableRequest); i { case 0: return &v.state @@ -20496,7 +20661,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[175].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[177].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetWritableResponse); i { case 0: return &v.state @@ -20508,7 +20673,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[176].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[178].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationAddRequest); i { case 0: return &v.state @@ -20520,7 +20685,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[177].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[179].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationAddResponse); i { case 0: return &v.state @@ -20532,7 +20697,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[178].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[180].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationFixRequest); i { case 0: return &v.state @@ -20544,7 +20709,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[179].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[181].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationFixResponse); i { case 0: return &v.state @@ -20556,7 +20721,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[180].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[182].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationPositionsRequest); i { case 0: return &v.state @@ -20568,7 +20733,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[181].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[183].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationPositionsResponse); i { case 0: return &v.state @@ -20580,7 +20745,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[182].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[184].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationRemoveRequest); i { case 0: return &v.state @@ -20592,7 +20757,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[183].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[185].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ShardReplicationRemoveResponse); i { case 0: return &v.state @@ -20604,7 +20769,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[184].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[186].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SleepTabletRequest); i { case 0: return &v.state @@ -20616,7 +20781,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[185].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[187].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SleepTabletResponse); i { case 0: return &v.state @@ -20628,7 +20793,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[186].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[188].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SourceShardAddRequest); i { case 0: return &v.state @@ -20640,7 +20805,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[187].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[189].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SourceShardAddResponse); i { case 0: return &v.state @@ -20652,7 +20817,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[188].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[190].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SourceShardDeleteRequest); i { case 0: return &v.state @@ -20664,7 +20829,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[189].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[191].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SourceShardDeleteResponse); i { case 0: return &v.state @@ -20676,7 +20841,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[190].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[192].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StartReplicationRequest); i { case 0: return &v.state @@ -20688,7 +20853,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[191].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[193].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StartReplicationResponse); i { case 0: return &v.state @@ -20700,7 +20865,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[192].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[194].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StopReplicationRequest); i { case 0: return &v.state @@ -20712,7 +20877,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[193].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[195].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StopReplicationResponse); i { case 0: return &v.state @@ -20724,7 +20889,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[194].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[196].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TabletExternallyReparentedRequest); i { case 0: return &v.state @@ -20736,7 +20901,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[195].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[197].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TabletExternallyReparentedResponse); i { case 0: return &v.state @@ -20748,7 +20913,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[196].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[198].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*UpdateCellInfoRequest); i { case 0: return &v.state @@ -20760,7 +20925,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[197].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[199].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*UpdateCellInfoResponse); i { case 0: return &v.state @@ -20772,7 +20937,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[198].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[200].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*UpdateCellsAliasRequest); i { case 0: return &v.state @@ -20784,7 +20949,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[199].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[201].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*UpdateCellsAliasResponse); i { case 0: return &v.state @@ -20796,7 +20961,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[200].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[202].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateRequest); i { case 0: return &v.state @@ -20808,7 +20973,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[201].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[203].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateResponse); i { case 0: return &v.state @@ -20820,7 +20985,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[202].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[204].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateKeyspaceRequest); i { case 0: return &v.state @@ -20832,7 +20997,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[203].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[205].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateKeyspaceResponse); i { case 0: return &v.state @@ -20844,7 +21009,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[204].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[206].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateSchemaKeyspaceRequest); i { case 0: return &v.state @@ -20856,7 +21021,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[205].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[207].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateSchemaKeyspaceResponse); i { case 0: return &v.state @@ -20868,7 +21033,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[206].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[208].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateShardRequest); i { case 0: return &v.state @@ -20880,7 +21045,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[207].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[209].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateShardResponse); i { case 0: return &v.state @@ -20892,7 +21057,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[208].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[210].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateVersionKeyspaceRequest); i { case 0: return &v.state @@ -20904,7 +21069,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[209].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[211].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateVersionKeyspaceResponse); i { case 0: return &v.state @@ -20916,7 +21081,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[210].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[212].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateVersionShardRequest); i { case 0: return &v.state @@ -20928,7 +21093,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[211].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[213].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateVersionShardResponse); i { case 0: return &v.state @@ -20940,7 +21105,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[212].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[214].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateVSchemaRequest); i { case 0: return &v.state @@ -20952,7 +21117,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[213].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[215].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ValidateVSchemaResponse); i { case 0: return &v.state @@ -20964,7 +21129,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[214].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[216].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffCreateRequest); i { case 0: return &v.state @@ -20976,7 +21141,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[215].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[217].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffCreateResponse); i { case 0: return &v.state @@ -20988,7 +21153,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[216].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[218].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffDeleteRequest); i { case 0: return &v.state @@ -21000,7 +21165,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[217].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[219].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffDeleteResponse); i { case 0: return &v.state @@ -21012,7 +21177,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[218].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[220].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffResumeRequest); i { case 0: return &v.state @@ -21024,7 +21189,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[219].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[221].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffResumeResponse); i { case 0: return &v.state @@ -21036,7 +21201,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[220].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[222].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffShowRequest); i { case 0: return &v.state @@ -21048,7 +21213,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[221].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[223].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffShowResponse); i { case 0: return &v.state @@ -21060,7 +21225,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[222].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[224].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffStopRequest); i { case 0: return &v.state @@ -21072,7 +21237,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[223].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[225].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VDiffStopResponse); i { case 0: return &v.state @@ -21084,7 +21249,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[224].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[226].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowDeleteRequest); i { case 0: return &v.state @@ -21096,7 +21261,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[225].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[227].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowDeleteResponse); i { case 0: return &v.state @@ -21108,7 +21273,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[226].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[228].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowStatusRequest); i { case 0: return &v.state @@ -21120,7 +21285,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[227].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[229].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowStatusResponse); i { case 0: return &v.state @@ -21132,7 +21297,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[228].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[230].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowSwitchTrafficRequest); i { case 0: return &v.state @@ -21144,7 +21309,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[229].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[231].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowSwitchTrafficResponse); i { case 0: return &v.state @@ -21156,7 +21321,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[230].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[232].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowUpdateRequest); i { case 0: return &v.state @@ -21168,7 +21333,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[231].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[233].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowUpdateResponse); i { case 0: return &v.state @@ -21180,7 +21345,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[233].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[235].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Workflow_ReplicationLocation); i { case 0: return &v.state @@ -21192,7 +21357,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[234].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[236].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Workflow_ShardStream); i { case 0: return &v.state @@ -21204,7 +21369,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[235].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[237].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Workflow_Stream); i { case 0: return &v.state @@ -21216,7 +21381,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[236].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[238].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Workflow_Stream_CopyState); i { case 0: return &v.state @@ -21228,7 +21393,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[237].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[239].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Workflow_Stream_Log); i { case 0: return &v.state @@ -21240,7 +21405,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[238].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[240].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Workflow_Stream_ThrottlerStatus); i { case 0: return &v.state @@ -21252,7 +21417,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[241].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[243].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ApplyVSchemaResponse_ParamList); i { case 0: return &v.state @@ -21264,7 +21429,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[249].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[252].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetSrvKeyspaceNamesResponse_NameList); i { case 0: return &v.state @@ -21276,7 +21441,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[253].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[256].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MoveTablesCreateResponse_TabletInfo); i { case 0: return &v.state @@ -21288,7 +21453,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[263].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[266].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowDeleteResponse_TabletInfo); i { case 0: return &v.state @@ -21300,7 +21465,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[264].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[267].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowStatusResponse_TableCopyState); i { case 0: return &v.state @@ -21312,7 +21477,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[265].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[268].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowStatusResponse_ShardStreamState); i { case 0: return &v.state @@ -21324,7 +21489,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[266].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[269].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowStatusResponse_ShardStreams); i { case 0: return &v.state @@ -21336,7 +21501,7 @@ func file_vtctldata_proto_init() { return nil } } - file_vtctldata_proto_msgTypes[269].Exporter = func(v interface{}, i int) interface{} { + file_vtctldata_proto_msgTypes[272].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WorkflowUpdateResponse_TabletInfo); i { case 0: return &v.state @@ -21355,7 +21520,7 @@ func file_vtctldata_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_vtctldata_proto_rawDesc, NumEnums: 4, - NumMessages: 270, + NumMessages: 273, NumExtensions: 0, NumServices: 0, }, diff --git a/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go b/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go index d62ee7c9cdb..cdddd3832cc 100644 --- a/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go +++ b/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go @@ -1977,6 +1977,53 @@ func (m *GetSchemaMigrationsResponse) CloneMessageVT() proto.Message { return m.CloneVT() } +func (m *GetShardReplicationRequest) CloneVT() *GetShardReplicationRequest { + if m == nil { + return (*GetShardReplicationRequest)(nil) + } + r := &GetShardReplicationRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetShardReplicationResponse) CloneVT() *GetShardReplicationResponse { + if m == nil { + return (*GetShardReplicationResponse)(nil) + } + r := &GetShardReplicationResponse{} + if rhs := m.ShardReplicationByCell; rhs != nil { + tmpContainer := make(map[string]*topodata.ShardReplication, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardReplicationByCell = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *GetShardRequest) CloneVT() *GetShardRequest { if m == nil { return (*GetShardRequest)(nil) @@ -10801,6 +10848,117 @@ func (m *GetSchemaMigrationsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, return len(dAtA) - i, nil } +func (m *GetShardReplicationRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetShardReplicationRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetShardReplicationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Cells) > 0 { + for iNdEx := len(m.Cells) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Cells[iNdEx]) + copy(dAtA[i:], m.Cells[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.Cells[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Shard) > 0 { + i -= len(m.Shard) + copy(dAtA[i:], m.Shard) + i = encodeVarint(dAtA, i, uint64(len(m.Shard))) + i-- + dAtA[i] = 0x12 + } + if len(m.Keyspace) > 0 { + i -= len(m.Keyspace) + copy(dAtA[i:], m.Keyspace) + i = encodeVarint(dAtA, i, uint64(len(m.Keyspace))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetShardReplicationResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetShardReplicationResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GetShardReplicationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.ShardReplicationByCell) > 0 { + for k := range m.ShardReplicationByCell { + v := m.ShardReplicationByCell[k] + baseI := i + size, err := v.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *GetShardRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil @@ -21607,6 +21765,53 @@ func (m *GetSchemaMigrationsResponse) SizeVT() (n int) { return n } +func (m *GetShardReplicationRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Keyspace) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.Shard) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + if len(m.Cells) > 0 { + for _, s := range m.Cells { + l = len(s) + n += 1 + l + sov(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *GetShardReplicationResponse) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ShardReplicationByCell) > 0 { + for k, v := range m.ShardReplicationByCell { + _ = k + _ = v + l = 0 + if v != nil { + l = v.SizeVT() + } + l += 1 + sov(uint64(l)) + mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l + n += mapEntrySize + 1 + sov(uint64(mapEntrySize)) + } + } + n += len(m.unknownFields) + return n +} + func (m *GetShardRequest) SizeVT() (n int) { if m == nil { return 0 @@ -38488,6 +38693,333 @@ func (m *GetSchemaMigrationsResponse) UnmarshalVT(dAtA []byte) error { } return nil } +func (m *GetShardReplicationRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetShardReplicationRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetShardReplicationRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + 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 ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Keyspace = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + 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 ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Shard = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cells", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + 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 ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cells = append(m.Cells, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetShardReplicationResponse) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetShardReplicationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetShardReplicationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ShardReplicationByCell", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ShardReplicationByCell == nil { + m.ShardReplicationByCell = make(map[string]*topodata.ShardReplication) + } + var mapkey string + var mapvalue *topodata.ShardReplication + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLength + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLength + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLength + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLength + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &topodata.ShardReplication{} + if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.ShardReplicationByCell[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *GetShardRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/go/vt/proto/vtctlservice/vtctlservice.pb.go b/go/vt/proto/vtctlservice/vtctlservice.pb.go index 96b3eeadd26..f99d7830f1b 100644 --- a/go/vt/proto/vtctlservice/vtctlservice.pb.go +++ b/go/vt/proto/vtctlservice/vtctlservice.pb.go @@ -51,7 +51,7 @@ var file_vtctlservice_proto_rawDesc = []byte{ 0x61, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x56, 0x74, 0x63, 0x74, 0x6c, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x32, 0x93, 0x51, 0x0a, 0x06, 0x56, 0x74, 0x63, 0x74, 0x6c, + 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x32, 0xfb, 0x51, 0x0a, 0x06, 0x56, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x12, 0x4e, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x41, 0x64, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, @@ -265,446 +265,452 @@ var file_vtctlservice_proto_rawDesc = []byte{ 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, - 0x12, 0x45, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x1a, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x68, - 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, - 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x12, 0x66, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x45, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x53, + 0x68, 0x61, 0x72, 0x64, 0x12, 0x1a, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, + 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, + 0x69, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, 0x74, 0x69, + 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, 0x74, - 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x66, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, - 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x47, 0x65, - 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0x21, 0x2e, + 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, + 0x68, 0x61, 0x72, 0x64, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x13, 0x47, 0x65, + 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, + 0x73, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, + 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, + 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, + 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, + 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0d, + 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, - 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, - 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, - 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, - 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x68, 0x72, 0x6f, 0x74, - 0x74, 0x6c, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x47, 0x65, - 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x12, 0x20, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, + 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, - 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, - 0x0a, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x12, 0x1c, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x47, 0x65, - 0x74, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, 0x68, 0x12, 0x21, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x70, - 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, - 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, - 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x12, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, - 0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x56, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, - 0x12, 0x51, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, - 0x12, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, - 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, - 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x10, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, 0x69, - 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x15, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, - 0x12, 0x63, 0x0a, 0x12, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x17, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, - 0x12, 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x6f, 0x6f, - 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x4d, 0x61, 0x74, - 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x23, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, - 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x55, 0x0a, 0x0d, 0x4d, - 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, - 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0d, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, - 0x74, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x4d, 0x6f, 0x75, 0x6e, - 0x74, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x21, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x55, 0x6e, 0x72, - 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, - 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x09, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, - 0x77, 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, - 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, - 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, - 0x0a, 0x09, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1b, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, 0x73, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x10, 0x4d, 0x6f, 0x76, 0x65, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x22, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, - 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x12, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x24, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, - 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0a, 0x50, 0x69, - 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x14, 0x50, 0x6c, 0x61, 0x6e, 0x6e, - 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, - 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x6c, 0x61, 0x6e, - 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, + 0x65, 0x6d, 0x61, 0x73, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x09, 0x47, + 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x74, 0x73, 0x12, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, + 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, + 0x79, 0x50, 0x61, 0x74, 0x68, 0x12, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x50, 0x61, 0x74, + 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, + 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4b, + 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x2e, 0x76, + 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x76, 0x74, 0x63, + 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0a, 0x47, + 0x65, 0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x51, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x12, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x10, 0x49, + 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, + 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x49, 0x6e, 0x69, 0x74, + 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x15, 0x4c, 0x61, + 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x76, + 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x12, 0x4c, 0x6f, 0x6f, 0x6b, + 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x24, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, + 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x72, 0x0a, + 0x17, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x12, 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, + 0x78, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x56, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x78, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x60, 0x0a, 0x11, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x76, 0x74, + 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, + 0x69, 0x7a, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x12, 0x55, 0x0a, 0x0d, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0d, 0x4d, 0x6f, + 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x76, 0x74, + 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x67, + 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x76, + 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x5a, 0x0a, 0x0f, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x65, 0x72, 0x12, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x09, + 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, 0x77, 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, 0x77, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x09, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, + 0x69, 0x73, 0x74, 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x75, + 0x6e, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x5b, 0x0a, 0x10, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x12, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, + 0x12, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, + 0x65, 0x74, 0x65, 0x12, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, + 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x6f, 0x76, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x43, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x4b, 0x0a, 0x0a, 0x50, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, + 0x12, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x69, 0x6e, + 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, + 0x69, 0x0a, 0x14, 0x50, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, + 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, - 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x69, 0x0a, 0x14, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, 0x79, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, - 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, - 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, + 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x6c, 0x61, 0x6e, + 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x14, 0x52, 0x65, + 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, + 0x70, 0x68, 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, - 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, - 0x13, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, - 0x72, 0x61, 0x70, 0x68, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, - 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x51, 0x0a, 0x0c, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, - 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x13, 0x52, 0x65, 0x66, 0x72, - 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, - 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, - 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, - 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, - 0x12, 0x51, 0x0a, 0x0c, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x12, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, - 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, - 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x14, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x26, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, - 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x53, 0x68, - 0x61, 0x72, 0x64, 0x12, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, + 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x13, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, 0x61, 0x70, 0x68, 0x12, 0x25, 0x2e, 0x76, + 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, + 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, + 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x51, 0x0a, + 0x0c, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1e, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, + 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, + 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x66, 0x0a, 0x13, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x66, 0x72, 0x65, + 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x51, 0x0a, 0x0c, 0x52, 0x65, 0x6c, 0x6f, + 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, - 0x12, 0x51, 0x0a, 0x0c, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, - 0x12, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, - 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, - 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x12, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, - 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x52, 0x65, 0x6d, 0x6f, - 0x76, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x21, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, - 0x61, 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x55, 0x0a, - 0x0d, 0x52, 0x65, 0x73, 0x68, 0x61, 0x72, 0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1f, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x73, 0x68, 0x61, - 0x72, 0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, - 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, - 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x12, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, - 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, - 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x69, 0x0a, 0x14, 0x52, 0x65, 0x74, 0x72, - 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x74, - 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, - 0x43, 0x68, 0x65, 0x63, 0x6b, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, + 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x14, 0x52, + 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x63, 0x65, 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, + 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, + 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x23, 0x2e, 0x76, 0x74, + 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6c, + 0x6f, 0x61, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x51, 0x0a, 0x0c, 0x52, 0x65, 0x6d, 0x6f, + 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x12, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, + 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, + 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x12, 0x52, + 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, + 0x6c, 0x12, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, + 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x5a, 0x0a, 0x0f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, + 0x65, 0x6c, 0x6c, 0x12, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65, + 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, + 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x20, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x70, 0x61, 0x72, + 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x55, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x68, 0x61, 0x72, 0x64, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x52, 0x65, 0x73, 0x68, 0x61, 0x72, 0x64, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, - 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7e, 0x0a, 0x1b, - 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, - 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x2d, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, + 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x11, + 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, + 0x70, 0x12, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x42, 0x61, + 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, + 0x12, 0x69, 0x0a, 0x14, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, + 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x65, 0x74, + 0x72, 0x79, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x52, + 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x12, 0x20, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, + 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x52, 0x75, 0x6e, 0x48, + 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x12, 0x7e, 0x0a, 0x1b, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, - 0x69, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x76, 0x74, 0x63, - 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, - 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x18, - 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, - 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x12, 0x2a, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, - 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, - 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, - 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, - 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x12, 0x27, 0x2e, 0x76, + 0x69, 0x63, 0x79, 0x12, 0x2d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, + 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, + 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x44, 0x75, 0x72, 0x61, 0x62, 0x69, + 0x6c, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, + 0x12, 0x2a, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, + 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x4e, 0x0a, 0x0b, 0x53, 0x65, 0x74, 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x12, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, - 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x57, - 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x66, 0x0a, 0x13, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x52, + 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x15, 0x53, + 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x12, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, + 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x0b, 0x53, 0x65, 0x74, + 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x74, 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x13, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, + 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, + 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x78, 0x0a, 0x19, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2b, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6f, 0x0a, 0x16, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, - 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x0b, - 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x1d, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x76, 0x74, 0x63, - 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, - 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, - 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x12, 0x20, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, - 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x23, 0x2e, 0x76, 0x74, 0x63, - 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, - 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x10, 0x53, 0x74, 0x61, 0x72, 0x74, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x2e, 0x76, 0x74, - 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x61, 0x72, - 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x7b, 0x0a, 0x1a, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, - 0x12, 0x2c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, - 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, - 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, - 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, - 0x65, 0x6e, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x57, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, - 0x6f, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x22, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, - 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, - 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x45, 0x0a, 0x08, 0x56, 0x61, 0x6c, 0x69, 0x64, - 0x61, 0x74, 0x65, 0x12, 0x1a, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5d, - 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, - 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6f, 0x0a, - 0x16, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, - 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, - 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, - 0x0a, 0x0d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, - 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, - 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x17, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, - 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, - 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x76, 0x74, 0x63, - 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x14, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, - 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, - 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, - 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x4e, 0x0a, 0x0b, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1d, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x4e, 0x0a, 0x0b, 0x56, 0x44, 0x69, 0x66, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1d, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x44, + 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x66, 0x0a, 0x13, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x12, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x78, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x78, 0x0a, 0x19, 0x53, 0x68, 0x61, + 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x12, 0x6f, 0x0a, 0x16, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x28, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x0b, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x74, 0x12, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x53, 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, + 0x6c, 0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x41, 0x64, 0x64, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x41, 0x64, + 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x41, 0x64, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, + 0x11, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x12, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x4e, 0x0a, 0x0b, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x12, 0x1d, + 0x5d, 0x0a, 0x10, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, + 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, + 0x0a, 0x0f, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, + 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7b, 0x0a, 0x1a, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, + 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x12, 0x2c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, + 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, + 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x5d, 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, + 0x6c, 0x69, 0x61, 0x73, 0x12, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, + 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, + 0x45, 0x0a, 0x08, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1a, 0x2e, 0x76, 0x74, + 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x22, 0x2e, 0x76, 0x74, 0x63, + 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6f, 0x0a, 0x16, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, + 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, + 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, + 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x17, + 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, + 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x29, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, + 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x69, 0x0a, 0x14, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x12, 0x26, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, + 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x72, + 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x56, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x21, + 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x22, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x0b, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x0b, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x0b, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x12, 0x1d, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, + 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x09, 0x56, 0x44, 0x69, 0x66, 0x66, + 0x53, 0x68, 0x6f, 0x77, 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, + 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x48, 0x0a, 0x09, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x74, 0x6f, 0x70, 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, - 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, - 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x52, - 0x65, 0x73, 0x75, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x48, 0x0a, 0x09, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x12, 0x1b, 0x2e, 0x76, - 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x68, - 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, - 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x68, 0x6f, 0x77, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a, 0x09, 0x56, 0x44, 0x69, - 0x66, 0x66, 0x53, 0x74, 0x6f, 0x70, 0x12, 0x1b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, - 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, - 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x20, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, - 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x15, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, - 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x12, 0x27, - 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, - 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, - 0x63, 0x68, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, - 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, - 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x2b, 0x5a, 0x29, - 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, - 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x74, 0x63, - 0x74, 0x6c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x33, + 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x76, 0x74, + 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x44, 0x69, 0x66, 0x66, 0x53, 0x74, 0x6f, + 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x20, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, + 0x15, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x54, + 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x12, 0x27, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, + 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, + 0x68, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x28, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, + 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0e, 0x57, + 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x20, 0x2e, + 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, + 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x21, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, + 0x66, 0x6c, 0x6f, 0x77, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x42, 0x2b, 0x5a, 0x29, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2e, 0x69, + 0x6f, 0x2f, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x74, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var file_vtctlservice_proto_goTypes = []interface{}{ @@ -746,188 +752,190 @@ var file_vtctlservice_proto_goTypes = []interface{}{ (*vtctldata.GetRoutingRulesRequest)(nil), // 35: vtctldata.GetRoutingRulesRequest (*vtctldata.GetSchemaRequest)(nil), // 36: vtctldata.GetSchemaRequest (*vtctldata.GetSchemaMigrationsRequest)(nil), // 37: vtctldata.GetSchemaMigrationsRequest - (*vtctldata.GetShardRequest)(nil), // 38: vtctldata.GetShardRequest - (*vtctldata.GetShardRoutingRulesRequest)(nil), // 39: vtctldata.GetShardRoutingRulesRequest - (*vtctldata.GetSrvKeyspaceNamesRequest)(nil), // 40: vtctldata.GetSrvKeyspaceNamesRequest - (*vtctldata.GetSrvKeyspacesRequest)(nil), // 41: vtctldata.GetSrvKeyspacesRequest - (*vtctldata.UpdateThrottlerConfigRequest)(nil), // 42: vtctldata.UpdateThrottlerConfigRequest - (*vtctldata.GetSrvVSchemaRequest)(nil), // 43: vtctldata.GetSrvVSchemaRequest - (*vtctldata.GetSrvVSchemasRequest)(nil), // 44: vtctldata.GetSrvVSchemasRequest - (*vtctldata.GetTabletRequest)(nil), // 45: vtctldata.GetTabletRequest - (*vtctldata.GetTabletsRequest)(nil), // 46: vtctldata.GetTabletsRequest - (*vtctldata.GetTopologyPathRequest)(nil), // 47: vtctldata.GetTopologyPathRequest - (*vtctldata.GetVersionRequest)(nil), // 48: vtctldata.GetVersionRequest - (*vtctldata.GetVSchemaRequest)(nil), // 49: vtctldata.GetVSchemaRequest - (*vtctldata.GetWorkflowsRequest)(nil), // 50: vtctldata.GetWorkflowsRequest - (*vtctldata.InitShardPrimaryRequest)(nil), // 51: vtctldata.InitShardPrimaryRequest - (*vtctldata.LaunchSchemaMigrationRequest)(nil), // 52: vtctldata.LaunchSchemaMigrationRequest - (*vtctldata.LookupVindexCreateRequest)(nil), // 53: vtctldata.LookupVindexCreateRequest - (*vtctldata.LookupVindexExternalizeRequest)(nil), // 54: vtctldata.LookupVindexExternalizeRequest - (*vtctldata.MaterializeCreateRequest)(nil), // 55: vtctldata.MaterializeCreateRequest - (*vtctldata.MigrateCreateRequest)(nil), // 56: vtctldata.MigrateCreateRequest - (*vtctldata.MountRegisterRequest)(nil), // 57: vtctldata.MountRegisterRequest - (*vtctldata.MountUnregisterRequest)(nil), // 58: vtctldata.MountUnregisterRequest - (*vtctldata.MountShowRequest)(nil), // 59: vtctldata.MountShowRequest - (*vtctldata.MountListRequest)(nil), // 60: vtctldata.MountListRequest - (*vtctldata.MoveTablesCreateRequest)(nil), // 61: vtctldata.MoveTablesCreateRequest - (*vtctldata.MoveTablesCompleteRequest)(nil), // 62: vtctldata.MoveTablesCompleteRequest - (*vtctldata.PingTabletRequest)(nil), // 63: vtctldata.PingTabletRequest - (*vtctldata.PlannedReparentShardRequest)(nil), // 64: vtctldata.PlannedReparentShardRequest - (*vtctldata.RebuildKeyspaceGraphRequest)(nil), // 65: vtctldata.RebuildKeyspaceGraphRequest - (*vtctldata.RebuildVSchemaGraphRequest)(nil), // 66: vtctldata.RebuildVSchemaGraphRequest - (*vtctldata.RefreshStateRequest)(nil), // 67: vtctldata.RefreshStateRequest - (*vtctldata.RefreshStateByShardRequest)(nil), // 68: vtctldata.RefreshStateByShardRequest - (*vtctldata.ReloadSchemaRequest)(nil), // 69: vtctldata.ReloadSchemaRequest - (*vtctldata.ReloadSchemaKeyspaceRequest)(nil), // 70: vtctldata.ReloadSchemaKeyspaceRequest - (*vtctldata.ReloadSchemaShardRequest)(nil), // 71: vtctldata.ReloadSchemaShardRequest - (*vtctldata.RemoveBackupRequest)(nil), // 72: vtctldata.RemoveBackupRequest - (*vtctldata.RemoveKeyspaceCellRequest)(nil), // 73: vtctldata.RemoveKeyspaceCellRequest - (*vtctldata.RemoveShardCellRequest)(nil), // 74: vtctldata.RemoveShardCellRequest - (*vtctldata.ReparentTabletRequest)(nil), // 75: vtctldata.ReparentTabletRequest - (*vtctldata.ReshardCreateRequest)(nil), // 76: vtctldata.ReshardCreateRequest - (*vtctldata.RestoreFromBackupRequest)(nil), // 77: vtctldata.RestoreFromBackupRequest - (*vtctldata.RetrySchemaMigrationRequest)(nil), // 78: vtctldata.RetrySchemaMigrationRequest - (*vtctldata.RunHealthCheckRequest)(nil), // 79: vtctldata.RunHealthCheckRequest - (*vtctldata.SetKeyspaceDurabilityPolicyRequest)(nil), // 80: vtctldata.SetKeyspaceDurabilityPolicyRequest - (*vtctldata.SetShardIsPrimaryServingRequest)(nil), // 81: vtctldata.SetShardIsPrimaryServingRequest - (*vtctldata.SetShardTabletControlRequest)(nil), // 82: vtctldata.SetShardTabletControlRequest - (*vtctldata.SetWritableRequest)(nil), // 83: vtctldata.SetWritableRequest - (*vtctldata.ShardReplicationAddRequest)(nil), // 84: vtctldata.ShardReplicationAddRequest - (*vtctldata.ShardReplicationFixRequest)(nil), // 85: vtctldata.ShardReplicationFixRequest - (*vtctldata.ShardReplicationPositionsRequest)(nil), // 86: vtctldata.ShardReplicationPositionsRequest - (*vtctldata.ShardReplicationRemoveRequest)(nil), // 87: vtctldata.ShardReplicationRemoveRequest - (*vtctldata.SleepTabletRequest)(nil), // 88: vtctldata.SleepTabletRequest - (*vtctldata.SourceShardAddRequest)(nil), // 89: vtctldata.SourceShardAddRequest - (*vtctldata.SourceShardDeleteRequest)(nil), // 90: vtctldata.SourceShardDeleteRequest - (*vtctldata.StartReplicationRequest)(nil), // 91: vtctldata.StartReplicationRequest - (*vtctldata.StopReplicationRequest)(nil), // 92: vtctldata.StopReplicationRequest - (*vtctldata.TabletExternallyReparentedRequest)(nil), // 93: vtctldata.TabletExternallyReparentedRequest - (*vtctldata.UpdateCellInfoRequest)(nil), // 94: vtctldata.UpdateCellInfoRequest - (*vtctldata.UpdateCellsAliasRequest)(nil), // 95: vtctldata.UpdateCellsAliasRequest - (*vtctldata.ValidateRequest)(nil), // 96: vtctldata.ValidateRequest - (*vtctldata.ValidateKeyspaceRequest)(nil), // 97: vtctldata.ValidateKeyspaceRequest - (*vtctldata.ValidateSchemaKeyspaceRequest)(nil), // 98: vtctldata.ValidateSchemaKeyspaceRequest - (*vtctldata.ValidateShardRequest)(nil), // 99: vtctldata.ValidateShardRequest - (*vtctldata.ValidateVersionKeyspaceRequest)(nil), // 100: vtctldata.ValidateVersionKeyspaceRequest - (*vtctldata.ValidateVersionShardRequest)(nil), // 101: vtctldata.ValidateVersionShardRequest - (*vtctldata.ValidateVSchemaRequest)(nil), // 102: vtctldata.ValidateVSchemaRequest - (*vtctldata.VDiffCreateRequest)(nil), // 103: vtctldata.VDiffCreateRequest - (*vtctldata.VDiffDeleteRequest)(nil), // 104: vtctldata.VDiffDeleteRequest - (*vtctldata.VDiffResumeRequest)(nil), // 105: vtctldata.VDiffResumeRequest - (*vtctldata.VDiffShowRequest)(nil), // 106: vtctldata.VDiffShowRequest - (*vtctldata.VDiffStopRequest)(nil), // 107: vtctldata.VDiffStopRequest - (*vtctldata.WorkflowDeleteRequest)(nil), // 108: vtctldata.WorkflowDeleteRequest - (*vtctldata.WorkflowStatusRequest)(nil), // 109: vtctldata.WorkflowStatusRequest - (*vtctldata.WorkflowSwitchTrafficRequest)(nil), // 110: vtctldata.WorkflowSwitchTrafficRequest - (*vtctldata.WorkflowUpdateRequest)(nil), // 111: vtctldata.WorkflowUpdateRequest - (*vtctldata.ExecuteVtctlCommandResponse)(nil), // 112: vtctldata.ExecuteVtctlCommandResponse - (*vtctldata.AddCellInfoResponse)(nil), // 113: vtctldata.AddCellInfoResponse - (*vtctldata.AddCellsAliasResponse)(nil), // 114: vtctldata.AddCellsAliasResponse - (*vtctldata.ApplyRoutingRulesResponse)(nil), // 115: vtctldata.ApplyRoutingRulesResponse - (*vtctldata.ApplySchemaResponse)(nil), // 116: vtctldata.ApplySchemaResponse - (*vtctldata.ApplyShardRoutingRulesResponse)(nil), // 117: vtctldata.ApplyShardRoutingRulesResponse - (*vtctldata.ApplyVSchemaResponse)(nil), // 118: vtctldata.ApplyVSchemaResponse - (*vtctldata.BackupResponse)(nil), // 119: vtctldata.BackupResponse - (*vtctldata.CancelSchemaMigrationResponse)(nil), // 120: vtctldata.CancelSchemaMigrationResponse - (*vtctldata.ChangeTabletTypeResponse)(nil), // 121: vtctldata.ChangeTabletTypeResponse - (*vtctldata.CleanupSchemaMigrationResponse)(nil), // 122: vtctldata.CleanupSchemaMigrationResponse - (*vtctldata.CompleteSchemaMigrationResponse)(nil), // 123: vtctldata.CompleteSchemaMigrationResponse - (*vtctldata.CreateKeyspaceResponse)(nil), // 124: vtctldata.CreateKeyspaceResponse - (*vtctldata.CreateShardResponse)(nil), // 125: vtctldata.CreateShardResponse - (*vtctldata.DeleteCellInfoResponse)(nil), // 126: vtctldata.DeleteCellInfoResponse - (*vtctldata.DeleteCellsAliasResponse)(nil), // 127: vtctldata.DeleteCellsAliasResponse - (*vtctldata.DeleteKeyspaceResponse)(nil), // 128: vtctldata.DeleteKeyspaceResponse - (*vtctldata.DeleteShardsResponse)(nil), // 129: vtctldata.DeleteShardsResponse - (*vtctldata.DeleteSrvVSchemaResponse)(nil), // 130: vtctldata.DeleteSrvVSchemaResponse - (*vtctldata.DeleteTabletsResponse)(nil), // 131: vtctldata.DeleteTabletsResponse - (*vtctldata.EmergencyReparentShardResponse)(nil), // 132: vtctldata.EmergencyReparentShardResponse - (*vtctldata.ExecuteFetchAsAppResponse)(nil), // 133: vtctldata.ExecuteFetchAsAppResponse - (*vtctldata.ExecuteFetchAsDBAResponse)(nil), // 134: vtctldata.ExecuteFetchAsDBAResponse - (*vtctldata.ExecuteHookResponse)(nil), // 135: vtctldata.ExecuteHookResponse - (*vtctldata.FindAllShardsInKeyspaceResponse)(nil), // 136: vtctldata.FindAllShardsInKeyspaceResponse - (*vtctldata.ForceCutOverSchemaMigrationResponse)(nil), // 137: vtctldata.ForceCutOverSchemaMigrationResponse - (*vtctldata.GetBackupsResponse)(nil), // 138: vtctldata.GetBackupsResponse - (*vtctldata.GetCellInfoResponse)(nil), // 139: vtctldata.GetCellInfoResponse - (*vtctldata.GetCellInfoNamesResponse)(nil), // 140: vtctldata.GetCellInfoNamesResponse - (*vtctldata.GetCellsAliasesResponse)(nil), // 141: vtctldata.GetCellsAliasesResponse - (*vtctldata.GetFullStatusResponse)(nil), // 142: vtctldata.GetFullStatusResponse - (*vtctldata.GetKeyspaceResponse)(nil), // 143: vtctldata.GetKeyspaceResponse - (*vtctldata.GetKeyspacesResponse)(nil), // 144: vtctldata.GetKeyspacesResponse - (*vtctldata.GetPermissionsResponse)(nil), // 145: vtctldata.GetPermissionsResponse - (*vtctldata.GetRoutingRulesResponse)(nil), // 146: vtctldata.GetRoutingRulesResponse - (*vtctldata.GetSchemaResponse)(nil), // 147: vtctldata.GetSchemaResponse - (*vtctldata.GetSchemaMigrationsResponse)(nil), // 148: vtctldata.GetSchemaMigrationsResponse - (*vtctldata.GetShardResponse)(nil), // 149: vtctldata.GetShardResponse - (*vtctldata.GetShardRoutingRulesResponse)(nil), // 150: vtctldata.GetShardRoutingRulesResponse - (*vtctldata.GetSrvKeyspaceNamesResponse)(nil), // 151: vtctldata.GetSrvKeyspaceNamesResponse - (*vtctldata.GetSrvKeyspacesResponse)(nil), // 152: vtctldata.GetSrvKeyspacesResponse - (*vtctldata.UpdateThrottlerConfigResponse)(nil), // 153: vtctldata.UpdateThrottlerConfigResponse - (*vtctldata.GetSrvVSchemaResponse)(nil), // 154: vtctldata.GetSrvVSchemaResponse - (*vtctldata.GetSrvVSchemasResponse)(nil), // 155: vtctldata.GetSrvVSchemasResponse - (*vtctldata.GetTabletResponse)(nil), // 156: vtctldata.GetTabletResponse - (*vtctldata.GetTabletsResponse)(nil), // 157: vtctldata.GetTabletsResponse - (*vtctldata.GetTopologyPathResponse)(nil), // 158: vtctldata.GetTopologyPathResponse - (*vtctldata.GetVersionResponse)(nil), // 159: vtctldata.GetVersionResponse - (*vtctldata.GetVSchemaResponse)(nil), // 160: vtctldata.GetVSchemaResponse - (*vtctldata.GetWorkflowsResponse)(nil), // 161: vtctldata.GetWorkflowsResponse - (*vtctldata.InitShardPrimaryResponse)(nil), // 162: vtctldata.InitShardPrimaryResponse - (*vtctldata.LaunchSchemaMigrationResponse)(nil), // 163: vtctldata.LaunchSchemaMigrationResponse - (*vtctldata.LookupVindexCreateResponse)(nil), // 164: vtctldata.LookupVindexCreateResponse - (*vtctldata.LookupVindexExternalizeResponse)(nil), // 165: vtctldata.LookupVindexExternalizeResponse - (*vtctldata.MaterializeCreateResponse)(nil), // 166: vtctldata.MaterializeCreateResponse - (*vtctldata.WorkflowStatusResponse)(nil), // 167: vtctldata.WorkflowStatusResponse - (*vtctldata.MountRegisterResponse)(nil), // 168: vtctldata.MountRegisterResponse - (*vtctldata.MountUnregisterResponse)(nil), // 169: vtctldata.MountUnregisterResponse - (*vtctldata.MountShowResponse)(nil), // 170: vtctldata.MountShowResponse - (*vtctldata.MountListResponse)(nil), // 171: vtctldata.MountListResponse - (*vtctldata.MoveTablesCompleteResponse)(nil), // 172: vtctldata.MoveTablesCompleteResponse - (*vtctldata.PingTabletResponse)(nil), // 173: vtctldata.PingTabletResponse - (*vtctldata.PlannedReparentShardResponse)(nil), // 174: vtctldata.PlannedReparentShardResponse - (*vtctldata.RebuildKeyspaceGraphResponse)(nil), // 175: vtctldata.RebuildKeyspaceGraphResponse - (*vtctldata.RebuildVSchemaGraphResponse)(nil), // 176: vtctldata.RebuildVSchemaGraphResponse - (*vtctldata.RefreshStateResponse)(nil), // 177: vtctldata.RefreshStateResponse - (*vtctldata.RefreshStateByShardResponse)(nil), // 178: vtctldata.RefreshStateByShardResponse - (*vtctldata.ReloadSchemaResponse)(nil), // 179: vtctldata.ReloadSchemaResponse - (*vtctldata.ReloadSchemaKeyspaceResponse)(nil), // 180: vtctldata.ReloadSchemaKeyspaceResponse - (*vtctldata.ReloadSchemaShardResponse)(nil), // 181: vtctldata.ReloadSchemaShardResponse - (*vtctldata.RemoveBackupResponse)(nil), // 182: vtctldata.RemoveBackupResponse - (*vtctldata.RemoveKeyspaceCellResponse)(nil), // 183: vtctldata.RemoveKeyspaceCellResponse - (*vtctldata.RemoveShardCellResponse)(nil), // 184: vtctldata.RemoveShardCellResponse - (*vtctldata.ReparentTabletResponse)(nil), // 185: vtctldata.ReparentTabletResponse - (*vtctldata.RestoreFromBackupResponse)(nil), // 186: vtctldata.RestoreFromBackupResponse - (*vtctldata.RetrySchemaMigrationResponse)(nil), // 187: vtctldata.RetrySchemaMigrationResponse - (*vtctldata.RunHealthCheckResponse)(nil), // 188: vtctldata.RunHealthCheckResponse - (*vtctldata.SetKeyspaceDurabilityPolicyResponse)(nil), // 189: vtctldata.SetKeyspaceDurabilityPolicyResponse - (*vtctldata.SetShardIsPrimaryServingResponse)(nil), // 190: vtctldata.SetShardIsPrimaryServingResponse - (*vtctldata.SetShardTabletControlResponse)(nil), // 191: vtctldata.SetShardTabletControlResponse - (*vtctldata.SetWritableResponse)(nil), // 192: vtctldata.SetWritableResponse - (*vtctldata.ShardReplicationAddResponse)(nil), // 193: vtctldata.ShardReplicationAddResponse - (*vtctldata.ShardReplicationFixResponse)(nil), // 194: vtctldata.ShardReplicationFixResponse - (*vtctldata.ShardReplicationPositionsResponse)(nil), // 195: vtctldata.ShardReplicationPositionsResponse - (*vtctldata.ShardReplicationRemoveResponse)(nil), // 196: vtctldata.ShardReplicationRemoveResponse - (*vtctldata.SleepTabletResponse)(nil), // 197: vtctldata.SleepTabletResponse - (*vtctldata.SourceShardAddResponse)(nil), // 198: vtctldata.SourceShardAddResponse - (*vtctldata.SourceShardDeleteResponse)(nil), // 199: vtctldata.SourceShardDeleteResponse - (*vtctldata.StartReplicationResponse)(nil), // 200: vtctldata.StartReplicationResponse - (*vtctldata.StopReplicationResponse)(nil), // 201: vtctldata.StopReplicationResponse - (*vtctldata.TabletExternallyReparentedResponse)(nil), // 202: vtctldata.TabletExternallyReparentedResponse - (*vtctldata.UpdateCellInfoResponse)(nil), // 203: vtctldata.UpdateCellInfoResponse - (*vtctldata.UpdateCellsAliasResponse)(nil), // 204: vtctldata.UpdateCellsAliasResponse - (*vtctldata.ValidateResponse)(nil), // 205: vtctldata.ValidateResponse - (*vtctldata.ValidateKeyspaceResponse)(nil), // 206: vtctldata.ValidateKeyspaceResponse - (*vtctldata.ValidateSchemaKeyspaceResponse)(nil), // 207: vtctldata.ValidateSchemaKeyspaceResponse - (*vtctldata.ValidateShardResponse)(nil), // 208: vtctldata.ValidateShardResponse - (*vtctldata.ValidateVersionKeyspaceResponse)(nil), // 209: vtctldata.ValidateVersionKeyspaceResponse - (*vtctldata.ValidateVersionShardResponse)(nil), // 210: vtctldata.ValidateVersionShardResponse - (*vtctldata.ValidateVSchemaResponse)(nil), // 211: vtctldata.ValidateVSchemaResponse - (*vtctldata.VDiffCreateResponse)(nil), // 212: vtctldata.VDiffCreateResponse - (*vtctldata.VDiffDeleteResponse)(nil), // 213: vtctldata.VDiffDeleteResponse - (*vtctldata.VDiffResumeResponse)(nil), // 214: vtctldata.VDiffResumeResponse - (*vtctldata.VDiffShowResponse)(nil), // 215: vtctldata.VDiffShowResponse - (*vtctldata.VDiffStopResponse)(nil), // 216: vtctldata.VDiffStopResponse - (*vtctldata.WorkflowDeleteResponse)(nil), // 217: vtctldata.WorkflowDeleteResponse - (*vtctldata.WorkflowSwitchTrafficResponse)(nil), // 218: vtctldata.WorkflowSwitchTrafficResponse - (*vtctldata.WorkflowUpdateResponse)(nil), // 219: vtctldata.WorkflowUpdateResponse + (*vtctldata.GetShardReplicationRequest)(nil), // 38: vtctldata.GetShardReplicationRequest + (*vtctldata.GetShardRequest)(nil), // 39: vtctldata.GetShardRequest + (*vtctldata.GetShardRoutingRulesRequest)(nil), // 40: vtctldata.GetShardRoutingRulesRequest + (*vtctldata.GetSrvKeyspaceNamesRequest)(nil), // 41: vtctldata.GetSrvKeyspaceNamesRequest + (*vtctldata.GetSrvKeyspacesRequest)(nil), // 42: vtctldata.GetSrvKeyspacesRequest + (*vtctldata.UpdateThrottlerConfigRequest)(nil), // 43: vtctldata.UpdateThrottlerConfigRequest + (*vtctldata.GetSrvVSchemaRequest)(nil), // 44: vtctldata.GetSrvVSchemaRequest + (*vtctldata.GetSrvVSchemasRequest)(nil), // 45: vtctldata.GetSrvVSchemasRequest + (*vtctldata.GetTabletRequest)(nil), // 46: vtctldata.GetTabletRequest + (*vtctldata.GetTabletsRequest)(nil), // 47: vtctldata.GetTabletsRequest + (*vtctldata.GetTopologyPathRequest)(nil), // 48: vtctldata.GetTopologyPathRequest + (*vtctldata.GetVersionRequest)(nil), // 49: vtctldata.GetVersionRequest + (*vtctldata.GetVSchemaRequest)(nil), // 50: vtctldata.GetVSchemaRequest + (*vtctldata.GetWorkflowsRequest)(nil), // 51: vtctldata.GetWorkflowsRequest + (*vtctldata.InitShardPrimaryRequest)(nil), // 52: vtctldata.InitShardPrimaryRequest + (*vtctldata.LaunchSchemaMigrationRequest)(nil), // 53: vtctldata.LaunchSchemaMigrationRequest + (*vtctldata.LookupVindexCreateRequest)(nil), // 54: vtctldata.LookupVindexCreateRequest + (*vtctldata.LookupVindexExternalizeRequest)(nil), // 55: vtctldata.LookupVindexExternalizeRequest + (*vtctldata.MaterializeCreateRequest)(nil), // 56: vtctldata.MaterializeCreateRequest + (*vtctldata.MigrateCreateRequest)(nil), // 57: vtctldata.MigrateCreateRequest + (*vtctldata.MountRegisterRequest)(nil), // 58: vtctldata.MountRegisterRequest + (*vtctldata.MountUnregisterRequest)(nil), // 59: vtctldata.MountUnregisterRequest + (*vtctldata.MountShowRequest)(nil), // 60: vtctldata.MountShowRequest + (*vtctldata.MountListRequest)(nil), // 61: vtctldata.MountListRequest + (*vtctldata.MoveTablesCreateRequest)(nil), // 62: vtctldata.MoveTablesCreateRequest + (*vtctldata.MoveTablesCompleteRequest)(nil), // 63: vtctldata.MoveTablesCompleteRequest + (*vtctldata.PingTabletRequest)(nil), // 64: vtctldata.PingTabletRequest + (*vtctldata.PlannedReparentShardRequest)(nil), // 65: vtctldata.PlannedReparentShardRequest + (*vtctldata.RebuildKeyspaceGraphRequest)(nil), // 66: vtctldata.RebuildKeyspaceGraphRequest + (*vtctldata.RebuildVSchemaGraphRequest)(nil), // 67: vtctldata.RebuildVSchemaGraphRequest + (*vtctldata.RefreshStateRequest)(nil), // 68: vtctldata.RefreshStateRequest + (*vtctldata.RefreshStateByShardRequest)(nil), // 69: vtctldata.RefreshStateByShardRequest + (*vtctldata.ReloadSchemaRequest)(nil), // 70: vtctldata.ReloadSchemaRequest + (*vtctldata.ReloadSchemaKeyspaceRequest)(nil), // 71: vtctldata.ReloadSchemaKeyspaceRequest + (*vtctldata.ReloadSchemaShardRequest)(nil), // 72: vtctldata.ReloadSchemaShardRequest + (*vtctldata.RemoveBackupRequest)(nil), // 73: vtctldata.RemoveBackupRequest + (*vtctldata.RemoveKeyspaceCellRequest)(nil), // 74: vtctldata.RemoveKeyspaceCellRequest + (*vtctldata.RemoveShardCellRequest)(nil), // 75: vtctldata.RemoveShardCellRequest + (*vtctldata.ReparentTabletRequest)(nil), // 76: vtctldata.ReparentTabletRequest + (*vtctldata.ReshardCreateRequest)(nil), // 77: vtctldata.ReshardCreateRequest + (*vtctldata.RestoreFromBackupRequest)(nil), // 78: vtctldata.RestoreFromBackupRequest + (*vtctldata.RetrySchemaMigrationRequest)(nil), // 79: vtctldata.RetrySchemaMigrationRequest + (*vtctldata.RunHealthCheckRequest)(nil), // 80: vtctldata.RunHealthCheckRequest + (*vtctldata.SetKeyspaceDurabilityPolicyRequest)(nil), // 81: vtctldata.SetKeyspaceDurabilityPolicyRequest + (*vtctldata.SetShardIsPrimaryServingRequest)(nil), // 82: vtctldata.SetShardIsPrimaryServingRequest + (*vtctldata.SetShardTabletControlRequest)(nil), // 83: vtctldata.SetShardTabletControlRequest + (*vtctldata.SetWritableRequest)(nil), // 84: vtctldata.SetWritableRequest + (*vtctldata.ShardReplicationAddRequest)(nil), // 85: vtctldata.ShardReplicationAddRequest + (*vtctldata.ShardReplicationFixRequest)(nil), // 86: vtctldata.ShardReplicationFixRequest + (*vtctldata.ShardReplicationPositionsRequest)(nil), // 87: vtctldata.ShardReplicationPositionsRequest + (*vtctldata.ShardReplicationRemoveRequest)(nil), // 88: vtctldata.ShardReplicationRemoveRequest + (*vtctldata.SleepTabletRequest)(nil), // 89: vtctldata.SleepTabletRequest + (*vtctldata.SourceShardAddRequest)(nil), // 90: vtctldata.SourceShardAddRequest + (*vtctldata.SourceShardDeleteRequest)(nil), // 91: vtctldata.SourceShardDeleteRequest + (*vtctldata.StartReplicationRequest)(nil), // 92: vtctldata.StartReplicationRequest + (*vtctldata.StopReplicationRequest)(nil), // 93: vtctldata.StopReplicationRequest + (*vtctldata.TabletExternallyReparentedRequest)(nil), // 94: vtctldata.TabletExternallyReparentedRequest + (*vtctldata.UpdateCellInfoRequest)(nil), // 95: vtctldata.UpdateCellInfoRequest + (*vtctldata.UpdateCellsAliasRequest)(nil), // 96: vtctldata.UpdateCellsAliasRequest + (*vtctldata.ValidateRequest)(nil), // 97: vtctldata.ValidateRequest + (*vtctldata.ValidateKeyspaceRequest)(nil), // 98: vtctldata.ValidateKeyspaceRequest + (*vtctldata.ValidateSchemaKeyspaceRequest)(nil), // 99: vtctldata.ValidateSchemaKeyspaceRequest + (*vtctldata.ValidateShardRequest)(nil), // 100: vtctldata.ValidateShardRequest + (*vtctldata.ValidateVersionKeyspaceRequest)(nil), // 101: vtctldata.ValidateVersionKeyspaceRequest + (*vtctldata.ValidateVersionShardRequest)(nil), // 102: vtctldata.ValidateVersionShardRequest + (*vtctldata.ValidateVSchemaRequest)(nil), // 103: vtctldata.ValidateVSchemaRequest + (*vtctldata.VDiffCreateRequest)(nil), // 104: vtctldata.VDiffCreateRequest + (*vtctldata.VDiffDeleteRequest)(nil), // 105: vtctldata.VDiffDeleteRequest + (*vtctldata.VDiffResumeRequest)(nil), // 106: vtctldata.VDiffResumeRequest + (*vtctldata.VDiffShowRequest)(nil), // 107: vtctldata.VDiffShowRequest + (*vtctldata.VDiffStopRequest)(nil), // 108: vtctldata.VDiffStopRequest + (*vtctldata.WorkflowDeleteRequest)(nil), // 109: vtctldata.WorkflowDeleteRequest + (*vtctldata.WorkflowStatusRequest)(nil), // 110: vtctldata.WorkflowStatusRequest + (*vtctldata.WorkflowSwitchTrafficRequest)(nil), // 111: vtctldata.WorkflowSwitchTrafficRequest + (*vtctldata.WorkflowUpdateRequest)(nil), // 112: vtctldata.WorkflowUpdateRequest + (*vtctldata.ExecuteVtctlCommandResponse)(nil), // 113: vtctldata.ExecuteVtctlCommandResponse + (*vtctldata.AddCellInfoResponse)(nil), // 114: vtctldata.AddCellInfoResponse + (*vtctldata.AddCellsAliasResponse)(nil), // 115: vtctldata.AddCellsAliasResponse + (*vtctldata.ApplyRoutingRulesResponse)(nil), // 116: vtctldata.ApplyRoutingRulesResponse + (*vtctldata.ApplySchemaResponse)(nil), // 117: vtctldata.ApplySchemaResponse + (*vtctldata.ApplyShardRoutingRulesResponse)(nil), // 118: vtctldata.ApplyShardRoutingRulesResponse + (*vtctldata.ApplyVSchemaResponse)(nil), // 119: vtctldata.ApplyVSchemaResponse + (*vtctldata.BackupResponse)(nil), // 120: vtctldata.BackupResponse + (*vtctldata.CancelSchemaMigrationResponse)(nil), // 121: vtctldata.CancelSchemaMigrationResponse + (*vtctldata.ChangeTabletTypeResponse)(nil), // 122: vtctldata.ChangeTabletTypeResponse + (*vtctldata.CleanupSchemaMigrationResponse)(nil), // 123: vtctldata.CleanupSchemaMigrationResponse + (*vtctldata.CompleteSchemaMigrationResponse)(nil), // 124: vtctldata.CompleteSchemaMigrationResponse + (*vtctldata.CreateKeyspaceResponse)(nil), // 125: vtctldata.CreateKeyspaceResponse + (*vtctldata.CreateShardResponse)(nil), // 126: vtctldata.CreateShardResponse + (*vtctldata.DeleteCellInfoResponse)(nil), // 127: vtctldata.DeleteCellInfoResponse + (*vtctldata.DeleteCellsAliasResponse)(nil), // 128: vtctldata.DeleteCellsAliasResponse + (*vtctldata.DeleteKeyspaceResponse)(nil), // 129: vtctldata.DeleteKeyspaceResponse + (*vtctldata.DeleteShardsResponse)(nil), // 130: vtctldata.DeleteShardsResponse + (*vtctldata.DeleteSrvVSchemaResponse)(nil), // 131: vtctldata.DeleteSrvVSchemaResponse + (*vtctldata.DeleteTabletsResponse)(nil), // 132: vtctldata.DeleteTabletsResponse + (*vtctldata.EmergencyReparentShardResponse)(nil), // 133: vtctldata.EmergencyReparentShardResponse + (*vtctldata.ExecuteFetchAsAppResponse)(nil), // 134: vtctldata.ExecuteFetchAsAppResponse + (*vtctldata.ExecuteFetchAsDBAResponse)(nil), // 135: vtctldata.ExecuteFetchAsDBAResponse + (*vtctldata.ExecuteHookResponse)(nil), // 136: vtctldata.ExecuteHookResponse + (*vtctldata.FindAllShardsInKeyspaceResponse)(nil), // 137: vtctldata.FindAllShardsInKeyspaceResponse + (*vtctldata.ForceCutOverSchemaMigrationResponse)(nil), // 138: vtctldata.ForceCutOverSchemaMigrationResponse + (*vtctldata.GetBackupsResponse)(nil), // 139: vtctldata.GetBackupsResponse + (*vtctldata.GetCellInfoResponse)(nil), // 140: vtctldata.GetCellInfoResponse + (*vtctldata.GetCellInfoNamesResponse)(nil), // 141: vtctldata.GetCellInfoNamesResponse + (*vtctldata.GetCellsAliasesResponse)(nil), // 142: vtctldata.GetCellsAliasesResponse + (*vtctldata.GetFullStatusResponse)(nil), // 143: vtctldata.GetFullStatusResponse + (*vtctldata.GetKeyspaceResponse)(nil), // 144: vtctldata.GetKeyspaceResponse + (*vtctldata.GetKeyspacesResponse)(nil), // 145: vtctldata.GetKeyspacesResponse + (*vtctldata.GetPermissionsResponse)(nil), // 146: vtctldata.GetPermissionsResponse + (*vtctldata.GetRoutingRulesResponse)(nil), // 147: vtctldata.GetRoutingRulesResponse + (*vtctldata.GetSchemaResponse)(nil), // 148: vtctldata.GetSchemaResponse + (*vtctldata.GetSchemaMigrationsResponse)(nil), // 149: vtctldata.GetSchemaMigrationsResponse + (*vtctldata.GetShardReplicationResponse)(nil), // 150: vtctldata.GetShardReplicationResponse + (*vtctldata.GetShardResponse)(nil), // 151: vtctldata.GetShardResponse + (*vtctldata.GetShardRoutingRulesResponse)(nil), // 152: vtctldata.GetShardRoutingRulesResponse + (*vtctldata.GetSrvKeyspaceNamesResponse)(nil), // 153: vtctldata.GetSrvKeyspaceNamesResponse + (*vtctldata.GetSrvKeyspacesResponse)(nil), // 154: vtctldata.GetSrvKeyspacesResponse + (*vtctldata.UpdateThrottlerConfigResponse)(nil), // 155: vtctldata.UpdateThrottlerConfigResponse + (*vtctldata.GetSrvVSchemaResponse)(nil), // 156: vtctldata.GetSrvVSchemaResponse + (*vtctldata.GetSrvVSchemasResponse)(nil), // 157: vtctldata.GetSrvVSchemasResponse + (*vtctldata.GetTabletResponse)(nil), // 158: vtctldata.GetTabletResponse + (*vtctldata.GetTabletsResponse)(nil), // 159: vtctldata.GetTabletsResponse + (*vtctldata.GetTopologyPathResponse)(nil), // 160: vtctldata.GetTopologyPathResponse + (*vtctldata.GetVersionResponse)(nil), // 161: vtctldata.GetVersionResponse + (*vtctldata.GetVSchemaResponse)(nil), // 162: vtctldata.GetVSchemaResponse + (*vtctldata.GetWorkflowsResponse)(nil), // 163: vtctldata.GetWorkflowsResponse + (*vtctldata.InitShardPrimaryResponse)(nil), // 164: vtctldata.InitShardPrimaryResponse + (*vtctldata.LaunchSchemaMigrationResponse)(nil), // 165: vtctldata.LaunchSchemaMigrationResponse + (*vtctldata.LookupVindexCreateResponse)(nil), // 166: vtctldata.LookupVindexCreateResponse + (*vtctldata.LookupVindexExternalizeResponse)(nil), // 167: vtctldata.LookupVindexExternalizeResponse + (*vtctldata.MaterializeCreateResponse)(nil), // 168: vtctldata.MaterializeCreateResponse + (*vtctldata.WorkflowStatusResponse)(nil), // 169: vtctldata.WorkflowStatusResponse + (*vtctldata.MountRegisterResponse)(nil), // 170: vtctldata.MountRegisterResponse + (*vtctldata.MountUnregisterResponse)(nil), // 171: vtctldata.MountUnregisterResponse + (*vtctldata.MountShowResponse)(nil), // 172: vtctldata.MountShowResponse + (*vtctldata.MountListResponse)(nil), // 173: vtctldata.MountListResponse + (*vtctldata.MoveTablesCompleteResponse)(nil), // 174: vtctldata.MoveTablesCompleteResponse + (*vtctldata.PingTabletResponse)(nil), // 175: vtctldata.PingTabletResponse + (*vtctldata.PlannedReparentShardResponse)(nil), // 176: vtctldata.PlannedReparentShardResponse + (*vtctldata.RebuildKeyspaceGraphResponse)(nil), // 177: vtctldata.RebuildKeyspaceGraphResponse + (*vtctldata.RebuildVSchemaGraphResponse)(nil), // 178: vtctldata.RebuildVSchemaGraphResponse + (*vtctldata.RefreshStateResponse)(nil), // 179: vtctldata.RefreshStateResponse + (*vtctldata.RefreshStateByShardResponse)(nil), // 180: vtctldata.RefreshStateByShardResponse + (*vtctldata.ReloadSchemaResponse)(nil), // 181: vtctldata.ReloadSchemaResponse + (*vtctldata.ReloadSchemaKeyspaceResponse)(nil), // 182: vtctldata.ReloadSchemaKeyspaceResponse + (*vtctldata.ReloadSchemaShardResponse)(nil), // 183: vtctldata.ReloadSchemaShardResponse + (*vtctldata.RemoveBackupResponse)(nil), // 184: vtctldata.RemoveBackupResponse + (*vtctldata.RemoveKeyspaceCellResponse)(nil), // 185: vtctldata.RemoveKeyspaceCellResponse + (*vtctldata.RemoveShardCellResponse)(nil), // 186: vtctldata.RemoveShardCellResponse + (*vtctldata.ReparentTabletResponse)(nil), // 187: vtctldata.ReparentTabletResponse + (*vtctldata.RestoreFromBackupResponse)(nil), // 188: vtctldata.RestoreFromBackupResponse + (*vtctldata.RetrySchemaMigrationResponse)(nil), // 189: vtctldata.RetrySchemaMigrationResponse + (*vtctldata.RunHealthCheckResponse)(nil), // 190: vtctldata.RunHealthCheckResponse + (*vtctldata.SetKeyspaceDurabilityPolicyResponse)(nil), // 191: vtctldata.SetKeyspaceDurabilityPolicyResponse + (*vtctldata.SetShardIsPrimaryServingResponse)(nil), // 192: vtctldata.SetShardIsPrimaryServingResponse + (*vtctldata.SetShardTabletControlResponse)(nil), // 193: vtctldata.SetShardTabletControlResponse + (*vtctldata.SetWritableResponse)(nil), // 194: vtctldata.SetWritableResponse + (*vtctldata.ShardReplicationAddResponse)(nil), // 195: vtctldata.ShardReplicationAddResponse + (*vtctldata.ShardReplicationFixResponse)(nil), // 196: vtctldata.ShardReplicationFixResponse + (*vtctldata.ShardReplicationPositionsResponse)(nil), // 197: vtctldata.ShardReplicationPositionsResponse + (*vtctldata.ShardReplicationRemoveResponse)(nil), // 198: vtctldata.ShardReplicationRemoveResponse + (*vtctldata.SleepTabletResponse)(nil), // 199: vtctldata.SleepTabletResponse + (*vtctldata.SourceShardAddResponse)(nil), // 200: vtctldata.SourceShardAddResponse + (*vtctldata.SourceShardDeleteResponse)(nil), // 201: vtctldata.SourceShardDeleteResponse + (*vtctldata.StartReplicationResponse)(nil), // 202: vtctldata.StartReplicationResponse + (*vtctldata.StopReplicationResponse)(nil), // 203: vtctldata.StopReplicationResponse + (*vtctldata.TabletExternallyReparentedResponse)(nil), // 204: vtctldata.TabletExternallyReparentedResponse + (*vtctldata.UpdateCellInfoResponse)(nil), // 205: vtctldata.UpdateCellInfoResponse + (*vtctldata.UpdateCellsAliasResponse)(nil), // 206: vtctldata.UpdateCellsAliasResponse + (*vtctldata.ValidateResponse)(nil), // 207: vtctldata.ValidateResponse + (*vtctldata.ValidateKeyspaceResponse)(nil), // 208: vtctldata.ValidateKeyspaceResponse + (*vtctldata.ValidateSchemaKeyspaceResponse)(nil), // 209: vtctldata.ValidateSchemaKeyspaceResponse + (*vtctldata.ValidateShardResponse)(nil), // 210: vtctldata.ValidateShardResponse + (*vtctldata.ValidateVersionKeyspaceResponse)(nil), // 211: vtctldata.ValidateVersionKeyspaceResponse + (*vtctldata.ValidateVersionShardResponse)(nil), // 212: vtctldata.ValidateVersionShardResponse + (*vtctldata.ValidateVSchemaResponse)(nil), // 213: vtctldata.ValidateVSchemaResponse + (*vtctldata.VDiffCreateResponse)(nil), // 214: vtctldata.VDiffCreateResponse + (*vtctldata.VDiffDeleteResponse)(nil), // 215: vtctldata.VDiffDeleteResponse + (*vtctldata.VDiffResumeResponse)(nil), // 216: vtctldata.VDiffResumeResponse + (*vtctldata.VDiffShowResponse)(nil), // 217: vtctldata.VDiffShowResponse + (*vtctldata.VDiffStopResponse)(nil), // 218: vtctldata.VDiffStopResponse + (*vtctldata.WorkflowDeleteResponse)(nil), // 219: vtctldata.WorkflowDeleteResponse + (*vtctldata.WorkflowSwitchTrafficResponse)(nil), // 220: vtctldata.WorkflowSwitchTrafficResponse + (*vtctldata.WorkflowUpdateResponse)(nil), // 221: vtctldata.WorkflowUpdateResponse } var file_vtctlservice_proto_depIdxs = []int32{ 0, // 0: vtctlservice.Vtctl.ExecuteVtctlCommand:input_type -> vtctldata.ExecuteVtctlCommandRequest @@ -968,194 +976,196 @@ var file_vtctlservice_proto_depIdxs = []int32{ 35, // 35: vtctlservice.Vtctld.GetRoutingRules:input_type -> vtctldata.GetRoutingRulesRequest 36, // 36: vtctlservice.Vtctld.GetSchema:input_type -> vtctldata.GetSchemaRequest 37, // 37: vtctlservice.Vtctld.GetSchemaMigrations:input_type -> vtctldata.GetSchemaMigrationsRequest - 38, // 38: vtctlservice.Vtctld.GetShard:input_type -> vtctldata.GetShardRequest - 39, // 39: vtctlservice.Vtctld.GetShardRoutingRules:input_type -> vtctldata.GetShardRoutingRulesRequest - 40, // 40: vtctlservice.Vtctld.GetSrvKeyspaceNames:input_type -> vtctldata.GetSrvKeyspaceNamesRequest - 41, // 41: vtctlservice.Vtctld.GetSrvKeyspaces:input_type -> vtctldata.GetSrvKeyspacesRequest - 42, // 42: vtctlservice.Vtctld.UpdateThrottlerConfig:input_type -> vtctldata.UpdateThrottlerConfigRequest - 43, // 43: vtctlservice.Vtctld.GetSrvVSchema:input_type -> vtctldata.GetSrvVSchemaRequest - 44, // 44: vtctlservice.Vtctld.GetSrvVSchemas:input_type -> vtctldata.GetSrvVSchemasRequest - 45, // 45: vtctlservice.Vtctld.GetTablet:input_type -> vtctldata.GetTabletRequest - 46, // 46: vtctlservice.Vtctld.GetTablets:input_type -> vtctldata.GetTabletsRequest - 47, // 47: vtctlservice.Vtctld.GetTopologyPath:input_type -> vtctldata.GetTopologyPathRequest - 48, // 48: vtctlservice.Vtctld.GetVersion:input_type -> vtctldata.GetVersionRequest - 49, // 49: vtctlservice.Vtctld.GetVSchema:input_type -> vtctldata.GetVSchemaRequest - 50, // 50: vtctlservice.Vtctld.GetWorkflows:input_type -> vtctldata.GetWorkflowsRequest - 51, // 51: vtctlservice.Vtctld.InitShardPrimary:input_type -> vtctldata.InitShardPrimaryRequest - 52, // 52: vtctlservice.Vtctld.LaunchSchemaMigration:input_type -> vtctldata.LaunchSchemaMigrationRequest - 53, // 53: vtctlservice.Vtctld.LookupVindexCreate:input_type -> vtctldata.LookupVindexCreateRequest - 54, // 54: vtctlservice.Vtctld.LookupVindexExternalize:input_type -> vtctldata.LookupVindexExternalizeRequest - 55, // 55: vtctlservice.Vtctld.MaterializeCreate:input_type -> vtctldata.MaterializeCreateRequest - 56, // 56: vtctlservice.Vtctld.MigrateCreate:input_type -> vtctldata.MigrateCreateRequest - 57, // 57: vtctlservice.Vtctld.MountRegister:input_type -> vtctldata.MountRegisterRequest - 58, // 58: vtctlservice.Vtctld.MountUnregister:input_type -> vtctldata.MountUnregisterRequest - 59, // 59: vtctlservice.Vtctld.MountShow:input_type -> vtctldata.MountShowRequest - 60, // 60: vtctlservice.Vtctld.MountList:input_type -> vtctldata.MountListRequest - 61, // 61: vtctlservice.Vtctld.MoveTablesCreate:input_type -> vtctldata.MoveTablesCreateRequest - 62, // 62: vtctlservice.Vtctld.MoveTablesComplete:input_type -> vtctldata.MoveTablesCompleteRequest - 63, // 63: vtctlservice.Vtctld.PingTablet:input_type -> vtctldata.PingTabletRequest - 64, // 64: vtctlservice.Vtctld.PlannedReparentShard:input_type -> vtctldata.PlannedReparentShardRequest - 65, // 65: vtctlservice.Vtctld.RebuildKeyspaceGraph:input_type -> vtctldata.RebuildKeyspaceGraphRequest - 66, // 66: vtctlservice.Vtctld.RebuildVSchemaGraph:input_type -> vtctldata.RebuildVSchemaGraphRequest - 67, // 67: vtctlservice.Vtctld.RefreshState:input_type -> vtctldata.RefreshStateRequest - 68, // 68: vtctlservice.Vtctld.RefreshStateByShard:input_type -> vtctldata.RefreshStateByShardRequest - 69, // 69: vtctlservice.Vtctld.ReloadSchema:input_type -> vtctldata.ReloadSchemaRequest - 70, // 70: vtctlservice.Vtctld.ReloadSchemaKeyspace:input_type -> vtctldata.ReloadSchemaKeyspaceRequest - 71, // 71: vtctlservice.Vtctld.ReloadSchemaShard:input_type -> vtctldata.ReloadSchemaShardRequest - 72, // 72: vtctlservice.Vtctld.RemoveBackup:input_type -> vtctldata.RemoveBackupRequest - 73, // 73: vtctlservice.Vtctld.RemoveKeyspaceCell:input_type -> vtctldata.RemoveKeyspaceCellRequest - 74, // 74: vtctlservice.Vtctld.RemoveShardCell:input_type -> vtctldata.RemoveShardCellRequest - 75, // 75: vtctlservice.Vtctld.ReparentTablet:input_type -> vtctldata.ReparentTabletRequest - 76, // 76: vtctlservice.Vtctld.ReshardCreate:input_type -> vtctldata.ReshardCreateRequest - 77, // 77: vtctlservice.Vtctld.RestoreFromBackup:input_type -> vtctldata.RestoreFromBackupRequest - 78, // 78: vtctlservice.Vtctld.RetrySchemaMigration:input_type -> vtctldata.RetrySchemaMigrationRequest - 79, // 79: vtctlservice.Vtctld.RunHealthCheck:input_type -> vtctldata.RunHealthCheckRequest - 80, // 80: vtctlservice.Vtctld.SetKeyspaceDurabilityPolicy:input_type -> vtctldata.SetKeyspaceDurabilityPolicyRequest - 81, // 81: vtctlservice.Vtctld.SetShardIsPrimaryServing:input_type -> vtctldata.SetShardIsPrimaryServingRequest - 82, // 82: vtctlservice.Vtctld.SetShardTabletControl:input_type -> vtctldata.SetShardTabletControlRequest - 83, // 83: vtctlservice.Vtctld.SetWritable:input_type -> vtctldata.SetWritableRequest - 84, // 84: vtctlservice.Vtctld.ShardReplicationAdd:input_type -> vtctldata.ShardReplicationAddRequest - 85, // 85: vtctlservice.Vtctld.ShardReplicationFix:input_type -> vtctldata.ShardReplicationFixRequest - 86, // 86: vtctlservice.Vtctld.ShardReplicationPositions:input_type -> vtctldata.ShardReplicationPositionsRequest - 87, // 87: vtctlservice.Vtctld.ShardReplicationRemove:input_type -> vtctldata.ShardReplicationRemoveRequest - 88, // 88: vtctlservice.Vtctld.SleepTablet:input_type -> vtctldata.SleepTabletRequest - 89, // 89: vtctlservice.Vtctld.SourceShardAdd:input_type -> vtctldata.SourceShardAddRequest - 90, // 90: vtctlservice.Vtctld.SourceShardDelete:input_type -> vtctldata.SourceShardDeleteRequest - 91, // 91: vtctlservice.Vtctld.StartReplication:input_type -> vtctldata.StartReplicationRequest - 92, // 92: vtctlservice.Vtctld.StopReplication:input_type -> vtctldata.StopReplicationRequest - 93, // 93: vtctlservice.Vtctld.TabletExternallyReparented:input_type -> vtctldata.TabletExternallyReparentedRequest - 94, // 94: vtctlservice.Vtctld.UpdateCellInfo:input_type -> vtctldata.UpdateCellInfoRequest - 95, // 95: vtctlservice.Vtctld.UpdateCellsAlias:input_type -> vtctldata.UpdateCellsAliasRequest - 96, // 96: vtctlservice.Vtctld.Validate:input_type -> vtctldata.ValidateRequest - 97, // 97: vtctlservice.Vtctld.ValidateKeyspace:input_type -> vtctldata.ValidateKeyspaceRequest - 98, // 98: vtctlservice.Vtctld.ValidateSchemaKeyspace:input_type -> vtctldata.ValidateSchemaKeyspaceRequest - 99, // 99: vtctlservice.Vtctld.ValidateShard:input_type -> vtctldata.ValidateShardRequest - 100, // 100: vtctlservice.Vtctld.ValidateVersionKeyspace:input_type -> vtctldata.ValidateVersionKeyspaceRequest - 101, // 101: vtctlservice.Vtctld.ValidateVersionShard:input_type -> vtctldata.ValidateVersionShardRequest - 102, // 102: vtctlservice.Vtctld.ValidateVSchema:input_type -> vtctldata.ValidateVSchemaRequest - 103, // 103: vtctlservice.Vtctld.VDiffCreate:input_type -> vtctldata.VDiffCreateRequest - 104, // 104: vtctlservice.Vtctld.VDiffDelete:input_type -> vtctldata.VDiffDeleteRequest - 105, // 105: vtctlservice.Vtctld.VDiffResume:input_type -> vtctldata.VDiffResumeRequest - 106, // 106: vtctlservice.Vtctld.VDiffShow:input_type -> vtctldata.VDiffShowRequest - 107, // 107: vtctlservice.Vtctld.VDiffStop:input_type -> vtctldata.VDiffStopRequest - 108, // 108: vtctlservice.Vtctld.WorkflowDelete:input_type -> vtctldata.WorkflowDeleteRequest - 109, // 109: vtctlservice.Vtctld.WorkflowStatus:input_type -> vtctldata.WorkflowStatusRequest - 110, // 110: vtctlservice.Vtctld.WorkflowSwitchTraffic:input_type -> vtctldata.WorkflowSwitchTrafficRequest - 111, // 111: vtctlservice.Vtctld.WorkflowUpdate:input_type -> vtctldata.WorkflowUpdateRequest - 112, // 112: vtctlservice.Vtctl.ExecuteVtctlCommand:output_type -> vtctldata.ExecuteVtctlCommandResponse - 113, // 113: vtctlservice.Vtctld.AddCellInfo:output_type -> vtctldata.AddCellInfoResponse - 114, // 114: vtctlservice.Vtctld.AddCellsAlias:output_type -> vtctldata.AddCellsAliasResponse - 115, // 115: vtctlservice.Vtctld.ApplyRoutingRules:output_type -> vtctldata.ApplyRoutingRulesResponse - 116, // 116: vtctlservice.Vtctld.ApplySchema:output_type -> vtctldata.ApplySchemaResponse - 117, // 117: vtctlservice.Vtctld.ApplyShardRoutingRules:output_type -> vtctldata.ApplyShardRoutingRulesResponse - 118, // 118: vtctlservice.Vtctld.ApplyVSchema:output_type -> vtctldata.ApplyVSchemaResponse - 119, // 119: vtctlservice.Vtctld.Backup:output_type -> vtctldata.BackupResponse - 119, // 120: vtctlservice.Vtctld.BackupShard:output_type -> vtctldata.BackupResponse - 120, // 121: vtctlservice.Vtctld.CancelSchemaMigration:output_type -> vtctldata.CancelSchemaMigrationResponse - 121, // 122: vtctlservice.Vtctld.ChangeTabletType:output_type -> vtctldata.ChangeTabletTypeResponse - 122, // 123: vtctlservice.Vtctld.CleanupSchemaMigration:output_type -> vtctldata.CleanupSchemaMigrationResponse - 123, // 124: vtctlservice.Vtctld.CompleteSchemaMigration:output_type -> vtctldata.CompleteSchemaMigrationResponse - 124, // 125: vtctlservice.Vtctld.CreateKeyspace:output_type -> vtctldata.CreateKeyspaceResponse - 125, // 126: vtctlservice.Vtctld.CreateShard:output_type -> vtctldata.CreateShardResponse - 126, // 127: vtctlservice.Vtctld.DeleteCellInfo:output_type -> vtctldata.DeleteCellInfoResponse - 127, // 128: vtctlservice.Vtctld.DeleteCellsAlias:output_type -> vtctldata.DeleteCellsAliasResponse - 128, // 129: vtctlservice.Vtctld.DeleteKeyspace:output_type -> vtctldata.DeleteKeyspaceResponse - 129, // 130: vtctlservice.Vtctld.DeleteShards:output_type -> vtctldata.DeleteShardsResponse - 130, // 131: vtctlservice.Vtctld.DeleteSrvVSchema:output_type -> vtctldata.DeleteSrvVSchemaResponse - 131, // 132: vtctlservice.Vtctld.DeleteTablets:output_type -> vtctldata.DeleteTabletsResponse - 132, // 133: vtctlservice.Vtctld.EmergencyReparentShard:output_type -> vtctldata.EmergencyReparentShardResponse - 133, // 134: vtctlservice.Vtctld.ExecuteFetchAsApp:output_type -> vtctldata.ExecuteFetchAsAppResponse - 134, // 135: vtctlservice.Vtctld.ExecuteFetchAsDBA:output_type -> vtctldata.ExecuteFetchAsDBAResponse - 135, // 136: vtctlservice.Vtctld.ExecuteHook:output_type -> vtctldata.ExecuteHookResponse - 136, // 137: vtctlservice.Vtctld.FindAllShardsInKeyspace:output_type -> vtctldata.FindAllShardsInKeyspaceResponse - 137, // 138: vtctlservice.Vtctld.ForceCutOverSchemaMigration:output_type -> vtctldata.ForceCutOverSchemaMigrationResponse - 138, // 139: vtctlservice.Vtctld.GetBackups:output_type -> vtctldata.GetBackupsResponse - 139, // 140: vtctlservice.Vtctld.GetCellInfo:output_type -> vtctldata.GetCellInfoResponse - 140, // 141: vtctlservice.Vtctld.GetCellInfoNames:output_type -> vtctldata.GetCellInfoNamesResponse - 141, // 142: vtctlservice.Vtctld.GetCellsAliases:output_type -> vtctldata.GetCellsAliasesResponse - 142, // 143: vtctlservice.Vtctld.GetFullStatus:output_type -> vtctldata.GetFullStatusResponse - 143, // 144: vtctlservice.Vtctld.GetKeyspace:output_type -> vtctldata.GetKeyspaceResponse - 144, // 145: vtctlservice.Vtctld.GetKeyspaces:output_type -> vtctldata.GetKeyspacesResponse - 145, // 146: vtctlservice.Vtctld.GetPermissions:output_type -> vtctldata.GetPermissionsResponse - 146, // 147: vtctlservice.Vtctld.GetRoutingRules:output_type -> vtctldata.GetRoutingRulesResponse - 147, // 148: vtctlservice.Vtctld.GetSchema:output_type -> vtctldata.GetSchemaResponse - 148, // 149: vtctlservice.Vtctld.GetSchemaMigrations:output_type -> vtctldata.GetSchemaMigrationsResponse - 149, // 150: vtctlservice.Vtctld.GetShard:output_type -> vtctldata.GetShardResponse - 150, // 151: vtctlservice.Vtctld.GetShardRoutingRules:output_type -> vtctldata.GetShardRoutingRulesResponse - 151, // 152: vtctlservice.Vtctld.GetSrvKeyspaceNames:output_type -> vtctldata.GetSrvKeyspaceNamesResponse - 152, // 153: vtctlservice.Vtctld.GetSrvKeyspaces:output_type -> vtctldata.GetSrvKeyspacesResponse - 153, // 154: vtctlservice.Vtctld.UpdateThrottlerConfig:output_type -> vtctldata.UpdateThrottlerConfigResponse - 154, // 155: vtctlservice.Vtctld.GetSrvVSchema:output_type -> vtctldata.GetSrvVSchemaResponse - 155, // 156: vtctlservice.Vtctld.GetSrvVSchemas:output_type -> vtctldata.GetSrvVSchemasResponse - 156, // 157: vtctlservice.Vtctld.GetTablet:output_type -> vtctldata.GetTabletResponse - 157, // 158: vtctlservice.Vtctld.GetTablets:output_type -> vtctldata.GetTabletsResponse - 158, // 159: vtctlservice.Vtctld.GetTopologyPath:output_type -> vtctldata.GetTopologyPathResponse - 159, // 160: vtctlservice.Vtctld.GetVersion:output_type -> vtctldata.GetVersionResponse - 160, // 161: vtctlservice.Vtctld.GetVSchema:output_type -> vtctldata.GetVSchemaResponse - 161, // 162: vtctlservice.Vtctld.GetWorkflows:output_type -> vtctldata.GetWorkflowsResponse - 162, // 163: vtctlservice.Vtctld.InitShardPrimary:output_type -> vtctldata.InitShardPrimaryResponse - 163, // 164: vtctlservice.Vtctld.LaunchSchemaMigration:output_type -> vtctldata.LaunchSchemaMigrationResponse - 164, // 165: vtctlservice.Vtctld.LookupVindexCreate:output_type -> vtctldata.LookupVindexCreateResponse - 165, // 166: vtctlservice.Vtctld.LookupVindexExternalize:output_type -> vtctldata.LookupVindexExternalizeResponse - 166, // 167: vtctlservice.Vtctld.MaterializeCreate:output_type -> vtctldata.MaterializeCreateResponse - 167, // 168: vtctlservice.Vtctld.MigrateCreate:output_type -> vtctldata.WorkflowStatusResponse - 168, // 169: vtctlservice.Vtctld.MountRegister:output_type -> vtctldata.MountRegisterResponse - 169, // 170: vtctlservice.Vtctld.MountUnregister:output_type -> vtctldata.MountUnregisterResponse - 170, // 171: vtctlservice.Vtctld.MountShow:output_type -> vtctldata.MountShowResponse - 171, // 172: vtctlservice.Vtctld.MountList:output_type -> vtctldata.MountListResponse - 167, // 173: vtctlservice.Vtctld.MoveTablesCreate:output_type -> vtctldata.WorkflowStatusResponse - 172, // 174: vtctlservice.Vtctld.MoveTablesComplete:output_type -> vtctldata.MoveTablesCompleteResponse - 173, // 175: vtctlservice.Vtctld.PingTablet:output_type -> vtctldata.PingTabletResponse - 174, // 176: vtctlservice.Vtctld.PlannedReparentShard:output_type -> vtctldata.PlannedReparentShardResponse - 175, // 177: vtctlservice.Vtctld.RebuildKeyspaceGraph:output_type -> vtctldata.RebuildKeyspaceGraphResponse - 176, // 178: vtctlservice.Vtctld.RebuildVSchemaGraph:output_type -> vtctldata.RebuildVSchemaGraphResponse - 177, // 179: vtctlservice.Vtctld.RefreshState:output_type -> vtctldata.RefreshStateResponse - 178, // 180: vtctlservice.Vtctld.RefreshStateByShard:output_type -> vtctldata.RefreshStateByShardResponse - 179, // 181: vtctlservice.Vtctld.ReloadSchema:output_type -> vtctldata.ReloadSchemaResponse - 180, // 182: vtctlservice.Vtctld.ReloadSchemaKeyspace:output_type -> vtctldata.ReloadSchemaKeyspaceResponse - 181, // 183: vtctlservice.Vtctld.ReloadSchemaShard:output_type -> vtctldata.ReloadSchemaShardResponse - 182, // 184: vtctlservice.Vtctld.RemoveBackup:output_type -> vtctldata.RemoveBackupResponse - 183, // 185: vtctlservice.Vtctld.RemoveKeyspaceCell:output_type -> vtctldata.RemoveKeyspaceCellResponse - 184, // 186: vtctlservice.Vtctld.RemoveShardCell:output_type -> vtctldata.RemoveShardCellResponse - 185, // 187: vtctlservice.Vtctld.ReparentTablet:output_type -> vtctldata.ReparentTabletResponse - 167, // 188: vtctlservice.Vtctld.ReshardCreate:output_type -> vtctldata.WorkflowStatusResponse - 186, // 189: vtctlservice.Vtctld.RestoreFromBackup:output_type -> vtctldata.RestoreFromBackupResponse - 187, // 190: vtctlservice.Vtctld.RetrySchemaMigration:output_type -> vtctldata.RetrySchemaMigrationResponse - 188, // 191: vtctlservice.Vtctld.RunHealthCheck:output_type -> vtctldata.RunHealthCheckResponse - 189, // 192: vtctlservice.Vtctld.SetKeyspaceDurabilityPolicy:output_type -> vtctldata.SetKeyspaceDurabilityPolicyResponse - 190, // 193: vtctlservice.Vtctld.SetShardIsPrimaryServing:output_type -> vtctldata.SetShardIsPrimaryServingResponse - 191, // 194: vtctlservice.Vtctld.SetShardTabletControl:output_type -> vtctldata.SetShardTabletControlResponse - 192, // 195: vtctlservice.Vtctld.SetWritable:output_type -> vtctldata.SetWritableResponse - 193, // 196: vtctlservice.Vtctld.ShardReplicationAdd:output_type -> vtctldata.ShardReplicationAddResponse - 194, // 197: vtctlservice.Vtctld.ShardReplicationFix:output_type -> vtctldata.ShardReplicationFixResponse - 195, // 198: vtctlservice.Vtctld.ShardReplicationPositions:output_type -> vtctldata.ShardReplicationPositionsResponse - 196, // 199: vtctlservice.Vtctld.ShardReplicationRemove:output_type -> vtctldata.ShardReplicationRemoveResponse - 197, // 200: vtctlservice.Vtctld.SleepTablet:output_type -> vtctldata.SleepTabletResponse - 198, // 201: vtctlservice.Vtctld.SourceShardAdd:output_type -> vtctldata.SourceShardAddResponse - 199, // 202: vtctlservice.Vtctld.SourceShardDelete:output_type -> vtctldata.SourceShardDeleteResponse - 200, // 203: vtctlservice.Vtctld.StartReplication:output_type -> vtctldata.StartReplicationResponse - 201, // 204: vtctlservice.Vtctld.StopReplication:output_type -> vtctldata.StopReplicationResponse - 202, // 205: vtctlservice.Vtctld.TabletExternallyReparented:output_type -> vtctldata.TabletExternallyReparentedResponse - 203, // 206: vtctlservice.Vtctld.UpdateCellInfo:output_type -> vtctldata.UpdateCellInfoResponse - 204, // 207: vtctlservice.Vtctld.UpdateCellsAlias:output_type -> vtctldata.UpdateCellsAliasResponse - 205, // 208: vtctlservice.Vtctld.Validate:output_type -> vtctldata.ValidateResponse - 206, // 209: vtctlservice.Vtctld.ValidateKeyspace:output_type -> vtctldata.ValidateKeyspaceResponse - 207, // 210: vtctlservice.Vtctld.ValidateSchemaKeyspace:output_type -> vtctldata.ValidateSchemaKeyspaceResponse - 208, // 211: vtctlservice.Vtctld.ValidateShard:output_type -> vtctldata.ValidateShardResponse - 209, // 212: vtctlservice.Vtctld.ValidateVersionKeyspace:output_type -> vtctldata.ValidateVersionKeyspaceResponse - 210, // 213: vtctlservice.Vtctld.ValidateVersionShard:output_type -> vtctldata.ValidateVersionShardResponse - 211, // 214: vtctlservice.Vtctld.ValidateVSchema:output_type -> vtctldata.ValidateVSchemaResponse - 212, // 215: vtctlservice.Vtctld.VDiffCreate:output_type -> vtctldata.VDiffCreateResponse - 213, // 216: vtctlservice.Vtctld.VDiffDelete:output_type -> vtctldata.VDiffDeleteResponse - 214, // 217: vtctlservice.Vtctld.VDiffResume:output_type -> vtctldata.VDiffResumeResponse - 215, // 218: vtctlservice.Vtctld.VDiffShow:output_type -> vtctldata.VDiffShowResponse - 216, // 219: vtctlservice.Vtctld.VDiffStop:output_type -> vtctldata.VDiffStopResponse - 217, // 220: vtctlservice.Vtctld.WorkflowDelete:output_type -> vtctldata.WorkflowDeleteResponse - 167, // 221: vtctlservice.Vtctld.WorkflowStatus:output_type -> vtctldata.WorkflowStatusResponse - 218, // 222: vtctlservice.Vtctld.WorkflowSwitchTraffic:output_type -> vtctldata.WorkflowSwitchTrafficResponse - 219, // 223: vtctlservice.Vtctld.WorkflowUpdate:output_type -> vtctldata.WorkflowUpdateResponse - 112, // [112:224] is the sub-list for method output_type - 0, // [0:112] is the sub-list for method input_type + 38, // 38: vtctlservice.Vtctld.GetShardReplication:input_type -> vtctldata.GetShardReplicationRequest + 39, // 39: vtctlservice.Vtctld.GetShard:input_type -> vtctldata.GetShardRequest + 40, // 40: vtctlservice.Vtctld.GetShardRoutingRules:input_type -> vtctldata.GetShardRoutingRulesRequest + 41, // 41: vtctlservice.Vtctld.GetSrvKeyspaceNames:input_type -> vtctldata.GetSrvKeyspaceNamesRequest + 42, // 42: vtctlservice.Vtctld.GetSrvKeyspaces:input_type -> vtctldata.GetSrvKeyspacesRequest + 43, // 43: vtctlservice.Vtctld.UpdateThrottlerConfig:input_type -> vtctldata.UpdateThrottlerConfigRequest + 44, // 44: vtctlservice.Vtctld.GetSrvVSchema:input_type -> vtctldata.GetSrvVSchemaRequest + 45, // 45: vtctlservice.Vtctld.GetSrvVSchemas:input_type -> vtctldata.GetSrvVSchemasRequest + 46, // 46: vtctlservice.Vtctld.GetTablet:input_type -> vtctldata.GetTabletRequest + 47, // 47: vtctlservice.Vtctld.GetTablets:input_type -> vtctldata.GetTabletsRequest + 48, // 48: vtctlservice.Vtctld.GetTopologyPath:input_type -> vtctldata.GetTopologyPathRequest + 49, // 49: vtctlservice.Vtctld.GetVersion:input_type -> vtctldata.GetVersionRequest + 50, // 50: vtctlservice.Vtctld.GetVSchema:input_type -> vtctldata.GetVSchemaRequest + 51, // 51: vtctlservice.Vtctld.GetWorkflows:input_type -> vtctldata.GetWorkflowsRequest + 52, // 52: vtctlservice.Vtctld.InitShardPrimary:input_type -> vtctldata.InitShardPrimaryRequest + 53, // 53: vtctlservice.Vtctld.LaunchSchemaMigration:input_type -> vtctldata.LaunchSchemaMigrationRequest + 54, // 54: vtctlservice.Vtctld.LookupVindexCreate:input_type -> vtctldata.LookupVindexCreateRequest + 55, // 55: vtctlservice.Vtctld.LookupVindexExternalize:input_type -> vtctldata.LookupVindexExternalizeRequest + 56, // 56: vtctlservice.Vtctld.MaterializeCreate:input_type -> vtctldata.MaterializeCreateRequest + 57, // 57: vtctlservice.Vtctld.MigrateCreate:input_type -> vtctldata.MigrateCreateRequest + 58, // 58: vtctlservice.Vtctld.MountRegister:input_type -> vtctldata.MountRegisterRequest + 59, // 59: vtctlservice.Vtctld.MountUnregister:input_type -> vtctldata.MountUnregisterRequest + 60, // 60: vtctlservice.Vtctld.MountShow:input_type -> vtctldata.MountShowRequest + 61, // 61: vtctlservice.Vtctld.MountList:input_type -> vtctldata.MountListRequest + 62, // 62: vtctlservice.Vtctld.MoveTablesCreate:input_type -> vtctldata.MoveTablesCreateRequest + 63, // 63: vtctlservice.Vtctld.MoveTablesComplete:input_type -> vtctldata.MoveTablesCompleteRequest + 64, // 64: vtctlservice.Vtctld.PingTablet:input_type -> vtctldata.PingTabletRequest + 65, // 65: vtctlservice.Vtctld.PlannedReparentShard:input_type -> vtctldata.PlannedReparentShardRequest + 66, // 66: vtctlservice.Vtctld.RebuildKeyspaceGraph:input_type -> vtctldata.RebuildKeyspaceGraphRequest + 67, // 67: vtctlservice.Vtctld.RebuildVSchemaGraph:input_type -> vtctldata.RebuildVSchemaGraphRequest + 68, // 68: vtctlservice.Vtctld.RefreshState:input_type -> vtctldata.RefreshStateRequest + 69, // 69: vtctlservice.Vtctld.RefreshStateByShard:input_type -> vtctldata.RefreshStateByShardRequest + 70, // 70: vtctlservice.Vtctld.ReloadSchema:input_type -> vtctldata.ReloadSchemaRequest + 71, // 71: vtctlservice.Vtctld.ReloadSchemaKeyspace:input_type -> vtctldata.ReloadSchemaKeyspaceRequest + 72, // 72: vtctlservice.Vtctld.ReloadSchemaShard:input_type -> vtctldata.ReloadSchemaShardRequest + 73, // 73: vtctlservice.Vtctld.RemoveBackup:input_type -> vtctldata.RemoveBackupRequest + 74, // 74: vtctlservice.Vtctld.RemoveKeyspaceCell:input_type -> vtctldata.RemoveKeyspaceCellRequest + 75, // 75: vtctlservice.Vtctld.RemoveShardCell:input_type -> vtctldata.RemoveShardCellRequest + 76, // 76: vtctlservice.Vtctld.ReparentTablet:input_type -> vtctldata.ReparentTabletRequest + 77, // 77: vtctlservice.Vtctld.ReshardCreate:input_type -> vtctldata.ReshardCreateRequest + 78, // 78: vtctlservice.Vtctld.RestoreFromBackup:input_type -> vtctldata.RestoreFromBackupRequest + 79, // 79: vtctlservice.Vtctld.RetrySchemaMigration:input_type -> vtctldata.RetrySchemaMigrationRequest + 80, // 80: vtctlservice.Vtctld.RunHealthCheck:input_type -> vtctldata.RunHealthCheckRequest + 81, // 81: vtctlservice.Vtctld.SetKeyspaceDurabilityPolicy:input_type -> vtctldata.SetKeyspaceDurabilityPolicyRequest + 82, // 82: vtctlservice.Vtctld.SetShardIsPrimaryServing:input_type -> vtctldata.SetShardIsPrimaryServingRequest + 83, // 83: vtctlservice.Vtctld.SetShardTabletControl:input_type -> vtctldata.SetShardTabletControlRequest + 84, // 84: vtctlservice.Vtctld.SetWritable:input_type -> vtctldata.SetWritableRequest + 85, // 85: vtctlservice.Vtctld.ShardReplicationAdd:input_type -> vtctldata.ShardReplicationAddRequest + 86, // 86: vtctlservice.Vtctld.ShardReplicationFix:input_type -> vtctldata.ShardReplicationFixRequest + 87, // 87: vtctlservice.Vtctld.ShardReplicationPositions:input_type -> vtctldata.ShardReplicationPositionsRequest + 88, // 88: vtctlservice.Vtctld.ShardReplicationRemove:input_type -> vtctldata.ShardReplicationRemoveRequest + 89, // 89: vtctlservice.Vtctld.SleepTablet:input_type -> vtctldata.SleepTabletRequest + 90, // 90: vtctlservice.Vtctld.SourceShardAdd:input_type -> vtctldata.SourceShardAddRequest + 91, // 91: vtctlservice.Vtctld.SourceShardDelete:input_type -> vtctldata.SourceShardDeleteRequest + 92, // 92: vtctlservice.Vtctld.StartReplication:input_type -> vtctldata.StartReplicationRequest + 93, // 93: vtctlservice.Vtctld.StopReplication:input_type -> vtctldata.StopReplicationRequest + 94, // 94: vtctlservice.Vtctld.TabletExternallyReparented:input_type -> vtctldata.TabletExternallyReparentedRequest + 95, // 95: vtctlservice.Vtctld.UpdateCellInfo:input_type -> vtctldata.UpdateCellInfoRequest + 96, // 96: vtctlservice.Vtctld.UpdateCellsAlias:input_type -> vtctldata.UpdateCellsAliasRequest + 97, // 97: vtctlservice.Vtctld.Validate:input_type -> vtctldata.ValidateRequest + 98, // 98: vtctlservice.Vtctld.ValidateKeyspace:input_type -> vtctldata.ValidateKeyspaceRequest + 99, // 99: vtctlservice.Vtctld.ValidateSchemaKeyspace:input_type -> vtctldata.ValidateSchemaKeyspaceRequest + 100, // 100: vtctlservice.Vtctld.ValidateShard:input_type -> vtctldata.ValidateShardRequest + 101, // 101: vtctlservice.Vtctld.ValidateVersionKeyspace:input_type -> vtctldata.ValidateVersionKeyspaceRequest + 102, // 102: vtctlservice.Vtctld.ValidateVersionShard:input_type -> vtctldata.ValidateVersionShardRequest + 103, // 103: vtctlservice.Vtctld.ValidateVSchema:input_type -> vtctldata.ValidateVSchemaRequest + 104, // 104: vtctlservice.Vtctld.VDiffCreate:input_type -> vtctldata.VDiffCreateRequest + 105, // 105: vtctlservice.Vtctld.VDiffDelete:input_type -> vtctldata.VDiffDeleteRequest + 106, // 106: vtctlservice.Vtctld.VDiffResume:input_type -> vtctldata.VDiffResumeRequest + 107, // 107: vtctlservice.Vtctld.VDiffShow:input_type -> vtctldata.VDiffShowRequest + 108, // 108: vtctlservice.Vtctld.VDiffStop:input_type -> vtctldata.VDiffStopRequest + 109, // 109: vtctlservice.Vtctld.WorkflowDelete:input_type -> vtctldata.WorkflowDeleteRequest + 110, // 110: vtctlservice.Vtctld.WorkflowStatus:input_type -> vtctldata.WorkflowStatusRequest + 111, // 111: vtctlservice.Vtctld.WorkflowSwitchTraffic:input_type -> vtctldata.WorkflowSwitchTrafficRequest + 112, // 112: vtctlservice.Vtctld.WorkflowUpdate:input_type -> vtctldata.WorkflowUpdateRequest + 113, // 113: vtctlservice.Vtctl.ExecuteVtctlCommand:output_type -> vtctldata.ExecuteVtctlCommandResponse + 114, // 114: vtctlservice.Vtctld.AddCellInfo:output_type -> vtctldata.AddCellInfoResponse + 115, // 115: vtctlservice.Vtctld.AddCellsAlias:output_type -> vtctldata.AddCellsAliasResponse + 116, // 116: vtctlservice.Vtctld.ApplyRoutingRules:output_type -> vtctldata.ApplyRoutingRulesResponse + 117, // 117: vtctlservice.Vtctld.ApplySchema:output_type -> vtctldata.ApplySchemaResponse + 118, // 118: vtctlservice.Vtctld.ApplyShardRoutingRules:output_type -> vtctldata.ApplyShardRoutingRulesResponse + 119, // 119: vtctlservice.Vtctld.ApplyVSchema:output_type -> vtctldata.ApplyVSchemaResponse + 120, // 120: vtctlservice.Vtctld.Backup:output_type -> vtctldata.BackupResponse + 120, // 121: vtctlservice.Vtctld.BackupShard:output_type -> vtctldata.BackupResponse + 121, // 122: vtctlservice.Vtctld.CancelSchemaMigration:output_type -> vtctldata.CancelSchemaMigrationResponse + 122, // 123: vtctlservice.Vtctld.ChangeTabletType:output_type -> vtctldata.ChangeTabletTypeResponse + 123, // 124: vtctlservice.Vtctld.CleanupSchemaMigration:output_type -> vtctldata.CleanupSchemaMigrationResponse + 124, // 125: vtctlservice.Vtctld.CompleteSchemaMigration:output_type -> vtctldata.CompleteSchemaMigrationResponse + 125, // 126: vtctlservice.Vtctld.CreateKeyspace:output_type -> vtctldata.CreateKeyspaceResponse + 126, // 127: vtctlservice.Vtctld.CreateShard:output_type -> vtctldata.CreateShardResponse + 127, // 128: vtctlservice.Vtctld.DeleteCellInfo:output_type -> vtctldata.DeleteCellInfoResponse + 128, // 129: vtctlservice.Vtctld.DeleteCellsAlias:output_type -> vtctldata.DeleteCellsAliasResponse + 129, // 130: vtctlservice.Vtctld.DeleteKeyspace:output_type -> vtctldata.DeleteKeyspaceResponse + 130, // 131: vtctlservice.Vtctld.DeleteShards:output_type -> vtctldata.DeleteShardsResponse + 131, // 132: vtctlservice.Vtctld.DeleteSrvVSchema:output_type -> vtctldata.DeleteSrvVSchemaResponse + 132, // 133: vtctlservice.Vtctld.DeleteTablets:output_type -> vtctldata.DeleteTabletsResponse + 133, // 134: vtctlservice.Vtctld.EmergencyReparentShard:output_type -> vtctldata.EmergencyReparentShardResponse + 134, // 135: vtctlservice.Vtctld.ExecuteFetchAsApp:output_type -> vtctldata.ExecuteFetchAsAppResponse + 135, // 136: vtctlservice.Vtctld.ExecuteFetchAsDBA:output_type -> vtctldata.ExecuteFetchAsDBAResponse + 136, // 137: vtctlservice.Vtctld.ExecuteHook:output_type -> vtctldata.ExecuteHookResponse + 137, // 138: vtctlservice.Vtctld.FindAllShardsInKeyspace:output_type -> vtctldata.FindAllShardsInKeyspaceResponse + 138, // 139: vtctlservice.Vtctld.ForceCutOverSchemaMigration:output_type -> vtctldata.ForceCutOverSchemaMigrationResponse + 139, // 140: vtctlservice.Vtctld.GetBackups:output_type -> vtctldata.GetBackupsResponse + 140, // 141: vtctlservice.Vtctld.GetCellInfo:output_type -> vtctldata.GetCellInfoResponse + 141, // 142: vtctlservice.Vtctld.GetCellInfoNames:output_type -> vtctldata.GetCellInfoNamesResponse + 142, // 143: vtctlservice.Vtctld.GetCellsAliases:output_type -> vtctldata.GetCellsAliasesResponse + 143, // 144: vtctlservice.Vtctld.GetFullStatus:output_type -> vtctldata.GetFullStatusResponse + 144, // 145: vtctlservice.Vtctld.GetKeyspace:output_type -> vtctldata.GetKeyspaceResponse + 145, // 146: vtctlservice.Vtctld.GetKeyspaces:output_type -> vtctldata.GetKeyspacesResponse + 146, // 147: vtctlservice.Vtctld.GetPermissions:output_type -> vtctldata.GetPermissionsResponse + 147, // 148: vtctlservice.Vtctld.GetRoutingRules:output_type -> vtctldata.GetRoutingRulesResponse + 148, // 149: vtctlservice.Vtctld.GetSchema:output_type -> vtctldata.GetSchemaResponse + 149, // 150: vtctlservice.Vtctld.GetSchemaMigrations:output_type -> vtctldata.GetSchemaMigrationsResponse + 150, // 151: vtctlservice.Vtctld.GetShardReplication:output_type -> vtctldata.GetShardReplicationResponse + 151, // 152: vtctlservice.Vtctld.GetShard:output_type -> vtctldata.GetShardResponse + 152, // 153: vtctlservice.Vtctld.GetShardRoutingRules:output_type -> vtctldata.GetShardRoutingRulesResponse + 153, // 154: vtctlservice.Vtctld.GetSrvKeyspaceNames:output_type -> vtctldata.GetSrvKeyspaceNamesResponse + 154, // 155: vtctlservice.Vtctld.GetSrvKeyspaces:output_type -> vtctldata.GetSrvKeyspacesResponse + 155, // 156: vtctlservice.Vtctld.UpdateThrottlerConfig:output_type -> vtctldata.UpdateThrottlerConfigResponse + 156, // 157: vtctlservice.Vtctld.GetSrvVSchema:output_type -> vtctldata.GetSrvVSchemaResponse + 157, // 158: vtctlservice.Vtctld.GetSrvVSchemas:output_type -> vtctldata.GetSrvVSchemasResponse + 158, // 159: vtctlservice.Vtctld.GetTablet:output_type -> vtctldata.GetTabletResponse + 159, // 160: vtctlservice.Vtctld.GetTablets:output_type -> vtctldata.GetTabletsResponse + 160, // 161: vtctlservice.Vtctld.GetTopologyPath:output_type -> vtctldata.GetTopologyPathResponse + 161, // 162: vtctlservice.Vtctld.GetVersion:output_type -> vtctldata.GetVersionResponse + 162, // 163: vtctlservice.Vtctld.GetVSchema:output_type -> vtctldata.GetVSchemaResponse + 163, // 164: vtctlservice.Vtctld.GetWorkflows:output_type -> vtctldata.GetWorkflowsResponse + 164, // 165: vtctlservice.Vtctld.InitShardPrimary:output_type -> vtctldata.InitShardPrimaryResponse + 165, // 166: vtctlservice.Vtctld.LaunchSchemaMigration:output_type -> vtctldata.LaunchSchemaMigrationResponse + 166, // 167: vtctlservice.Vtctld.LookupVindexCreate:output_type -> vtctldata.LookupVindexCreateResponse + 167, // 168: vtctlservice.Vtctld.LookupVindexExternalize:output_type -> vtctldata.LookupVindexExternalizeResponse + 168, // 169: vtctlservice.Vtctld.MaterializeCreate:output_type -> vtctldata.MaterializeCreateResponse + 169, // 170: vtctlservice.Vtctld.MigrateCreate:output_type -> vtctldata.WorkflowStatusResponse + 170, // 171: vtctlservice.Vtctld.MountRegister:output_type -> vtctldata.MountRegisterResponse + 171, // 172: vtctlservice.Vtctld.MountUnregister:output_type -> vtctldata.MountUnregisterResponse + 172, // 173: vtctlservice.Vtctld.MountShow:output_type -> vtctldata.MountShowResponse + 173, // 174: vtctlservice.Vtctld.MountList:output_type -> vtctldata.MountListResponse + 169, // 175: vtctlservice.Vtctld.MoveTablesCreate:output_type -> vtctldata.WorkflowStatusResponse + 174, // 176: vtctlservice.Vtctld.MoveTablesComplete:output_type -> vtctldata.MoveTablesCompleteResponse + 175, // 177: vtctlservice.Vtctld.PingTablet:output_type -> vtctldata.PingTabletResponse + 176, // 178: vtctlservice.Vtctld.PlannedReparentShard:output_type -> vtctldata.PlannedReparentShardResponse + 177, // 179: vtctlservice.Vtctld.RebuildKeyspaceGraph:output_type -> vtctldata.RebuildKeyspaceGraphResponse + 178, // 180: vtctlservice.Vtctld.RebuildVSchemaGraph:output_type -> vtctldata.RebuildVSchemaGraphResponse + 179, // 181: vtctlservice.Vtctld.RefreshState:output_type -> vtctldata.RefreshStateResponse + 180, // 182: vtctlservice.Vtctld.RefreshStateByShard:output_type -> vtctldata.RefreshStateByShardResponse + 181, // 183: vtctlservice.Vtctld.ReloadSchema:output_type -> vtctldata.ReloadSchemaResponse + 182, // 184: vtctlservice.Vtctld.ReloadSchemaKeyspace:output_type -> vtctldata.ReloadSchemaKeyspaceResponse + 183, // 185: vtctlservice.Vtctld.ReloadSchemaShard:output_type -> vtctldata.ReloadSchemaShardResponse + 184, // 186: vtctlservice.Vtctld.RemoveBackup:output_type -> vtctldata.RemoveBackupResponse + 185, // 187: vtctlservice.Vtctld.RemoveKeyspaceCell:output_type -> vtctldata.RemoveKeyspaceCellResponse + 186, // 188: vtctlservice.Vtctld.RemoveShardCell:output_type -> vtctldata.RemoveShardCellResponse + 187, // 189: vtctlservice.Vtctld.ReparentTablet:output_type -> vtctldata.ReparentTabletResponse + 169, // 190: vtctlservice.Vtctld.ReshardCreate:output_type -> vtctldata.WorkflowStatusResponse + 188, // 191: vtctlservice.Vtctld.RestoreFromBackup:output_type -> vtctldata.RestoreFromBackupResponse + 189, // 192: vtctlservice.Vtctld.RetrySchemaMigration:output_type -> vtctldata.RetrySchemaMigrationResponse + 190, // 193: vtctlservice.Vtctld.RunHealthCheck:output_type -> vtctldata.RunHealthCheckResponse + 191, // 194: vtctlservice.Vtctld.SetKeyspaceDurabilityPolicy:output_type -> vtctldata.SetKeyspaceDurabilityPolicyResponse + 192, // 195: vtctlservice.Vtctld.SetShardIsPrimaryServing:output_type -> vtctldata.SetShardIsPrimaryServingResponse + 193, // 196: vtctlservice.Vtctld.SetShardTabletControl:output_type -> vtctldata.SetShardTabletControlResponse + 194, // 197: vtctlservice.Vtctld.SetWritable:output_type -> vtctldata.SetWritableResponse + 195, // 198: vtctlservice.Vtctld.ShardReplicationAdd:output_type -> vtctldata.ShardReplicationAddResponse + 196, // 199: vtctlservice.Vtctld.ShardReplicationFix:output_type -> vtctldata.ShardReplicationFixResponse + 197, // 200: vtctlservice.Vtctld.ShardReplicationPositions:output_type -> vtctldata.ShardReplicationPositionsResponse + 198, // 201: vtctlservice.Vtctld.ShardReplicationRemove:output_type -> vtctldata.ShardReplicationRemoveResponse + 199, // 202: vtctlservice.Vtctld.SleepTablet:output_type -> vtctldata.SleepTabletResponse + 200, // 203: vtctlservice.Vtctld.SourceShardAdd:output_type -> vtctldata.SourceShardAddResponse + 201, // 204: vtctlservice.Vtctld.SourceShardDelete:output_type -> vtctldata.SourceShardDeleteResponse + 202, // 205: vtctlservice.Vtctld.StartReplication:output_type -> vtctldata.StartReplicationResponse + 203, // 206: vtctlservice.Vtctld.StopReplication:output_type -> vtctldata.StopReplicationResponse + 204, // 207: vtctlservice.Vtctld.TabletExternallyReparented:output_type -> vtctldata.TabletExternallyReparentedResponse + 205, // 208: vtctlservice.Vtctld.UpdateCellInfo:output_type -> vtctldata.UpdateCellInfoResponse + 206, // 209: vtctlservice.Vtctld.UpdateCellsAlias:output_type -> vtctldata.UpdateCellsAliasResponse + 207, // 210: vtctlservice.Vtctld.Validate:output_type -> vtctldata.ValidateResponse + 208, // 211: vtctlservice.Vtctld.ValidateKeyspace:output_type -> vtctldata.ValidateKeyspaceResponse + 209, // 212: vtctlservice.Vtctld.ValidateSchemaKeyspace:output_type -> vtctldata.ValidateSchemaKeyspaceResponse + 210, // 213: vtctlservice.Vtctld.ValidateShard:output_type -> vtctldata.ValidateShardResponse + 211, // 214: vtctlservice.Vtctld.ValidateVersionKeyspace:output_type -> vtctldata.ValidateVersionKeyspaceResponse + 212, // 215: vtctlservice.Vtctld.ValidateVersionShard:output_type -> vtctldata.ValidateVersionShardResponse + 213, // 216: vtctlservice.Vtctld.ValidateVSchema:output_type -> vtctldata.ValidateVSchemaResponse + 214, // 217: vtctlservice.Vtctld.VDiffCreate:output_type -> vtctldata.VDiffCreateResponse + 215, // 218: vtctlservice.Vtctld.VDiffDelete:output_type -> vtctldata.VDiffDeleteResponse + 216, // 219: vtctlservice.Vtctld.VDiffResume:output_type -> vtctldata.VDiffResumeResponse + 217, // 220: vtctlservice.Vtctld.VDiffShow:output_type -> vtctldata.VDiffShowResponse + 218, // 221: vtctlservice.Vtctld.VDiffStop:output_type -> vtctldata.VDiffStopResponse + 219, // 222: vtctlservice.Vtctld.WorkflowDelete:output_type -> vtctldata.WorkflowDeleteResponse + 169, // 223: vtctlservice.Vtctld.WorkflowStatus:output_type -> vtctldata.WorkflowStatusResponse + 220, // 224: vtctlservice.Vtctld.WorkflowSwitchTraffic:output_type -> vtctldata.WorkflowSwitchTrafficResponse + 221, // 225: vtctlservice.Vtctld.WorkflowUpdate:output_type -> vtctldata.WorkflowUpdateResponse + 113, // [113:226] is the sub-list for method output_type + 0, // [0:113] is the sub-list for method input_type 0, // [0:0] is the sub-list for extension type_name 0, // [0:0] is the sub-list for extension extendee 0, // [0:0] is the sub-list for field type_name diff --git a/go/vt/proto/vtctlservice/vtctlservice_grpc.pb.go b/go/vt/proto/vtctlservice/vtctlservice_grpc.pb.go index e4774540d2a..27e726340e1 100644 --- a/go/vt/proto/vtctlservice/vtctlservice_grpc.pb.go +++ b/go/vt/proto/vtctlservice/vtctlservice_grpc.pb.go @@ -239,6 +239,8 @@ type VtctldClient interface { // Different fields in the request message result in different filtering // behaviors. See the documentation on GetSchemaMigrationsRequest for details. GetSchemaMigrations(ctx context.Context, in *vtctldata.GetSchemaMigrationsRequest, opts ...grpc.CallOption) (*vtctldata.GetSchemaMigrationsResponse, error) + // GetShardReplication returns the replication graph for a shard in a cell. + GetShardReplication(ctx context.Context, in *vtctldata.GetShardReplicationRequest, opts ...grpc.CallOption) (*vtctldata.GetShardReplicationResponse, error) // GetShard returns information about a shard in the topology. GetShard(ctx context.Context, in *vtctldata.GetShardRequest, opts ...grpc.CallOption) (*vtctldata.GetShardResponse, error) // GetShardRoutingRules returns the VSchema shard routing rules. @@ -841,6 +843,15 @@ func (c *vtctldClient) GetSchemaMigrations(ctx context.Context, in *vtctldata.Ge return out, nil } +func (c *vtctldClient) GetShardReplication(ctx context.Context, in *vtctldata.GetShardReplicationRequest, opts ...grpc.CallOption) (*vtctldata.GetShardReplicationResponse, error) { + out := new(vtctldata.GetShardReplicationResponse) + err := c.cc.Invoke(ctx, "/vtctlservice.Vtctld/GetShardReplication", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *vtctldClient) GetShard(ctx context.Context, in *vtctldata.GetShardRequest, opts ...grpc.CallOption) (*vtctldata.GetShardResponse, error) { out := new(vtctldata.GetShardResponse) err := c.cc.Invoke(ctx, "/vtctlservice.Vtctld/GetShard", in, out, opts...) @@ -1637,6 +1648,8 @@ type VtctldServer interface { // Different fields in the request message result in different filtering // behaviors. See the documentation on GetSchemaMigrationsRequest for details. GetSchemaMigrations(context.Context, *vtctldata.GetSchemaMigrationsRequest) (*vtctldata.GetSchemaMigrationsResponse, error) + // GetShardReplication returns the replication graph for a shard in a cell. + GetShardReplication(context.Context, *vtctldata.GetShardReplicationRequest) (*vtctldata.GetShardReplicationResponse, error) // GetShard returns information about a shard in the topology. GetShard(context.Context, *vtctldata.GetShardRequest) (*vtctldata.GetShardResponse, error) // GetShardRoutingRules returns the VSchema shard routing rules. @@ -1968,6 +1981,9 @@ func (UnimplementedVtctldServer) GetSchema(context.Context, *vtctldata.GetSchema func (UnimplementedVtctldServer) GetSchemaMigrations(context.Context, *vtctldata.GetSchemaMigrationsRequest) (*vtctldata.GetSchemaMigrationsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetSchemaMigrations not implemented") } +func (UnimplementedVtctldServer) GetShardReplication(context.Context, *vtctldata.GetShardReplicationRequest) (*vtctldata.GetShardReplicationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetShardReplication not implemented") +} func (UnimplementedVtctldServer) GetShard(context.Context, *vtctldata.GetShardRequest) (*vtctldata.GetShardResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetShard not implemented") } @@ -2875,6 +2891,24 @@ func _Vtctld_GetSchemaMigrations_Handler(srv interface{}, ctx context.Context, d return interceptor(ctx, in, info, handler) } +func _Vtctld_GetShardReplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(vtctldata.GetShardReplicationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(VtctldServer).GetShardReplication(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vtctlservice.Vtctld/GetShardReplication", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(VtctldServer).GetShardReplication(ctx, req.(*vtctldata.GetShardReplicationRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Vtctld_GetShard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(vtctldata.GetShardRequest) if err := dec(in); err != nil { @@ -4357,6 +4391,10 @@ var Vtctld_ServiceDesc = grpc.ServiceDesc{ MethodName: "GetSchemaMigrations", Handler: _Vtctld_GetSchemaMigrations_Handler, }, + { + MethodName: "GetShardReplication", + Handler: _Vtctld_GetShardReplication_Handler, + }, { MethodName: "GetShard", Handler: _Vtctld_GetShard_Handler, diff --git a/go/vt/vtctl/grpcvtctldclient/client_gen.go b/go/vt/vtctl/grpcvtctldclient/client_gen.go index c1d251487fd..062c4c5c2ae 100644 --- a/go/vt/vtctl/grpcvtctldclient/client_gen.go +++ b/go/vt/vtctl/grpcvtctldclient/client_gen.go @@ -371,6 +371,15 @@ func (client *gRPCVtctldClient) GetShard(ctx context.Context, in *vtctldatapb.Ge return client.c.GetShard(ctx, in, opts...) } +// GetShardReplication is part of the vtctlservicepb.VtctldClient interface. +func (client *gRPCVtctldClient) GetShardReplication(ctx context.Context, in *vtctldatapb.GetShardReplicationRequest, opts ...grpc.CallOption) (*vtctldatapb.GetShardReplicationResponse, error) { + if client.c == nil { + return nil, status.Error(codes.Unavailable, connClosedMsg) + } + + return client.c.GetShardReplication(ctx, in, opts...) +} + // GetShardRoutingRules is part of the vtctlservicepb.VtctldClient interface. func (client *gRPCVtctldClient) GetShardRoutingRules(ctx context.Context, in *vtctldatapb.GetShardRoutingRulesRequest, opts ...grpc.CallOption) (*vtctldatapb.GetShardRoutingRulesResponse, error) { if client.c == nil { diff --git a/go/vt/vtctl/grpcvtctldserver/server.go b/go/vt/vtctl/grpcvtctldserver/server.go index 0d131e36f96..585203be4e7 100644 --- a/go/vt/vtctl/grpcvtctldserver/server.go +++ b/go/vt/vtctl/grpcvtctldserver/server.go @@ -1767,6 +1767,43 @@ func (s *VtctldServer) GetShard(ctx context.Context, req *vtctldatapb.GetShardRe }, nil } +// GetShardReplication is part of the vtctlservicepb.VtctldServer interface. +func (s *VtctldServer) GetShardReplication(ctx context.Context, req *vtctldatapb.GetShardReplicationRequest) (resp *vtctldatapb.GetShardReplicationResponse, err error) { + span, ctx := trace.NewSpan(ctx, "VtctldServer.GetShardReplication") + defer span.Finish() + + defer panicHandler(&err) + + cells := req.Cells + if len(cells) == 0 { + ctx, cancel := context.WithTimeout(ctx, topo.RemoteOperationTimeout) + defer cancel() + + cells, err = s.ts.GetCellInfoNames(ctx) + if err != nil { + return nil, err + } + } + + span.Annotate("keyspace", req.Keyspace) + span.Annotate("shard", req.Shard) + span.Annotate("cells", strings.Join(cells, ",")) + + replicationByCell := make(map[string]*topodatapb.ShardReplication, len(cells)) + for _, cell := range cells { + data, err := s.ts.GetShardReplication(ctx, cell, req.Keyspace, req.Shard) + if err != nil { + return nil, err + } + + replicationByCell[cell] = data.ShardReplication + } + + return &vtctldatapb.GetShardReplicationResponse{ + ShardReplicationByCell: replicationByCell, + }, nil +} + // GetSrvKeyspaceNames is part of the vtctlservicepb.VtctldServer interface. func (s *VtctldServer) GetSrvKeyspaceNames(ctx context.Context, req *vtctldatapb.GetSrvKeyspaceNamesRequest) (resp *vtctldatapb.GetSrvKeyspaceNamesResponse, err error) { span, ctx := trace.NewSpan(ctx, "VtctldServer.GetSrvKeyspaceNames") diff --git a/go/vt/vtctl/grpcvtctldserver/server_test.go b/go/vt/vtctl/grpcvtctldserver/server_test.go index ed6ee6aca1f..1a473fdad75 100644 --- a/go/vt/vtctl/grpcvtctldserver/server_test.go +++ b/go/vt/vtctl/grpcvtctldserver/server_test.go @@ -6150,6 +6150,211 @@ func TestGetShard(t *testing.T) { } } +func TestGetShardReplication(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + shardReplicationByCell map[string]map[string]map[string]*topodatapb.ShardReplication + topoError error + req *vtctldatapb.GetShardReplicationRequest + expected *vtctldatapb.GetShardReplicationResponse + shouldErr bool + }{ + { + name: "success", + shardReplicationByCell: map[string]map[string]map[string]*topodatapb.ShardReplication{ + "zone1": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 100}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 101}}, + }, + }, + }, + }, + "zone2": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 200}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 201}}, + }, + }, + }, + }, + }, + req: &vtctldatapb.GetShardReplicationRequest{ + Keyspace: "ks1", + Shard: "0", + }, + expected: &vtctldatapb.GetShardReplicationResponse{ + ShardReplicationByCell: map[string]*topodatapb.ShardReplication{ + "zone1": { + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 100}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 101}}, + }, + }, + "zone2": { + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 200}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 201}}, + }, + }, + }, + }, + }, + { + name: "cell filtering", + shardReplicationByCell: map[string]map[string]map[string]*topodatapb.ShardReplication{ + "zone1": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 100}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 101}}, + }, + }, + }, + }, + "zone2": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 200}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 201}}, + }, + }, + }, + }, + }, + req: &vtctldatapb.GetShardReplicationRequest{ + Keyspace: "ks1", + Shard: "0", + Cells: []string{"zone2"}, + }, + expected: &vtctldatapb.GetShardReplicationResponse{ + ShardReplicationByCell: map[string]*topodatapb.ShardReplication{ + "zone2": { + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 200}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 201}}, + }, + }, + }, + }, + }, + { + name: "all cells topo down", + shardReplicationByCell: map[string]map[string]map[string]*topodatapb.ShardReplication{ + "zone1": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 100}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 101}}, + }, + }, + }, + }, + "zone2": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 200}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 201}}, + }, + }, + }, + }, + }, + req: &vtctldatapb.GetShardReplicationRequest{ + Keyspace: "ks1", + Shard: "0", + }, + topoError: errors.New("topo down for testing"), + shouldErr: true, + }, + { + name: "cell filtering topo down", + shardReplicationByCell: map[string]map[string]map[string]*topodatapb.ShardReplication{ + "zone1": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 100}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone1", Uid: 101}}, + }, + }, + }, + }, + "zone2": { + "ks1": { + "0": &topodatapb.ShardReplication{ + Nodes: []*topodatapb.ShardReplication_Node{ + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 200}}, + {TabletAlias: &topodatapb.TabletAlias{Cell: "zone2", Uid: 201}}, + }, + }, + }, + }, + }, + req: &vtctldatapb.GetShardReplicationRequest{ + Keyspace: "ks1", + Shard: "0", + Cells: []string{"zone2"}, + }, + topoError: errors.New("topo down for testing"), + shouldErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + cells := make([]string, 0, len(tt.shardReplicationByCell)) + for cell := range tt.shardReplicationByCell { + cells = append(cells, cell) + } + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + ts, factory := memorytopo.NewServerAndFactory(ctx, cells...) + + for cell, shardReplication := range tt.shardReplicationByCell { + for ks, shardRepl := range shardReplication { + for shard, repl := range shardRepl { + err := ts.UpdateShardReplicationFields(ctx, cell, ks, shard, func(sr *topodatapb.ShardReplication) error { + sr.Nodes = repl.Nodes + return nil + }) + require.NoError(t, err, "UpdateShardReplicationFields(%s, %s, %s, %+v) failed", cell, ks, shard, repl) + } + } + } + + if tt.topoError != nil { + factory.SetError(tt.topoError) + } + + vtctld := testutil.NewVtctldServerWithTabletManagerClient(t, ts, nil, func(ts *topo.Server) vtctlservicepb.VtctldServer { + return NewVtctldServer(vtenv.NewTestEnv(), ts) + }) + resp, err := vtctld.GetShardReplication(ctx, tt.req) + if tt.shouldErr { + assert.Error(t, err) + return + } + + require.NoError(t, err) + utils.MustMatch(t, tt.expected, resp) + }) + } +} + func TestGetSrvKeyspaceNames(t *testing.T) { t.Parallel() diff --git a/go/vt/vtctl/localvtctldclient/client_gen.go b/go/vt/vtctl/localvtctldclient/client_gen.go index cbde68f1b27..f2962833508 100644 --- a/go/vt/vtctl/localvtctldclient/client_gen.go +++ b/go/vt/vtctl/localvtctldclient/client_gen.go @@ -311,6 +311,11 @@ func (client *localVtctldClient) GetShard(ctx context.Context, in *vtctldatapb.G return client.s.GetShard(ctx, in) } +// GetShardReplication is part of the vtctlservicepb.VtctldClient interface. +func (client *localVtctldClient) GetShardReplication(ctx context.Context, in *vtctldatapb.GetShardReplicationRequest, opts ...grpc.CallOption) (*vtctldatapb.GetShardReplicationResponse, error) { + return client.s.GetShardReplication(ctx, in) +} + // GetShardRoutingRules is part of the vtctlservicepb.VtctldClient interface. func (client *localVtctldClient) GetShardRoutingRules(ctx context.Context, in *vtctldatapb.GetShardRoutingRulesRequest, opts ...grpc.CallOption) (*vtctldatapb.GetShardRoutingRulesResponse, error) { return client.s.GetShardRoutingRules(ctx, in) diff --git a/proto/vtctldata.proto b/proto/vtctldata.proto index fd80b7ea69d..92ed1c42c74 100644 --- a/proto/vtctldata.proto +++ b/proto/vtctldata.proto @@ -853,6 +853,18 @@ message GetSchemaMigrationsResponse { repeated SchemaMigration migrations = 1; } +message GetShardReplicationRequest { + string keyspace = 1; + string shard = 2; + // Cells is the list of cells to fetch data for. Omit to fetch data from all + // cells. + repeated string cells = 3; +} + +message GetShardReplicationResponse { + map shard_replication_by_cell = 1; +} + message GetShardRequest { string keyspace = 1; string shard_name = 2; diff --git a/proto/vtctlservice.proto b/proto/vtctlservice.proto index 3ce89af2995..c0cd349dbe8 100644 --- a/proto/vtctlservice.proto +++ b/proto/vtctlservice.proto @@ -134,6 +134,8 @@ service Vtctld { // Different fields in the request message result in different filtering // behaviors. See the documentation on GetSchemaMigrationsRequest for details. rpc GetSchemaMigrations(vtctldata.GetSchemaMigrationsRequest) returns (vtctldata.GetSchemaMigrationsResponse) {}; + // GetShardReplication returns the replication graph for a shard in a cell. + rpc GetShardReplication(vtctldata.GetShardReplicationRequest) returns (vtctldata.GetShardReplicationResponse) {}; // GetShard returns information about a shard in the topology. rpc GetShard(vtctldata.GetShardRequest) returns (vtctldata.GetShardResponse) {}; // GetShardRoutingRules returns the VSchema shard routing rules. diff --git a/web/vtadmin/src/proto/vtadmin.d.ts b/web/vtadmin/src/proto/vtadmin.d.ts index 20c1cbab8b8..53fc9df7e7f 100644 --- a/web/vtadmin/src/proto/vtadmin.d.ts +++ b/web/vtadmin/src/proto/vtadmin.d.ts @@ -52773,6 +52773,212 @@ export namespace vtctldata { public static getTypeUrl(typeUrlPrefix?: string): string; } + /** Properties of a GetShardReplicationRequest. */ + interface IGetShardReplicationRequest { + + /** GetShardReplicationRequest keyspace */ + keyspace?: (string|null); + + /** GetShardReplicationRequest shard */ + shard?: (string|null); + + /** GetShardReplicationRequest cells */ + cells?: (string[]|null); + } + + /** Represents a GetShardReplicationRequest. */ + class GetShardReplicationRequest implements IGetShardReplicationRequest { + + /** + * Constructs a new GetShardReplicationRequest. + * @param [properties] Properties to set + */ + constructor(properties?: vtctldata.IGetShardReplicationRequest); + + /** GetShardReplicationRequest keyspace. */ + public keyspace: string; + + /** GetShardReplicationRequest shard. */ + public shard: string; + + /** GetShardReplicationRequest cells. */ + public cells: string[]; + + /** + * Creates a new GetShardReplicationRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns GetShardReplicationRequest instance + */ + public static create(properties?: vtctldata.IGetShardReplicationRequest): vtctldata.GetShardReplicationRequest; + + /** + * Encodes the specified GetShardReplicationRequest message. Does not implicitly {@link vtctldata.GetShardReplicationRequest.verify|verify} messages. + * @param message GetShardReplicationRequest message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: vtctldata.IGetShardReplicationRequest, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified GetShardReplicationRequest message, length delimited. Does not implicitly {@link vtctldata.GetShardReplicationRequest.verify|verify} messages. + * @param message GetShardReplicationRequest message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: vtctldata.IGetShardReplicationRequest, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a GetShardReplicationRequest message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns GetShardReplicationRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): vtctldata.GetShardReplicationRequest; + + /** + * Decodes a GetShardReplicationRequest message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns GetShardReplicationRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): vtctldata.GetShardReplicationRequest; + + /** + * Verifies a GetShardReplicationRequest message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a GetShardReplicationRequest message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns GetShardReplicationRequest + */ + public static fromObject(object: { [k: string]: any }): vtctldata.GetShardReplicationRequest; + + /** + * Creates a plain object from a GetShardReplicationRequest message. Also converts values to other types if specified. + * @param message GetShardReplicationRequest + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: vtctldata.GetShardReplicationRequest, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this GetShardReplicationRequest to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for GetShardReplicationRequest + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } + + /** Properties of a GetShardReplicationResponse. */ + interface IGetShardReplicationResponse { + + /** GetShardReplicationResponse shard_replication_by_cell */ + shard_replication_by_cell?: ({ [k: string]: topodata.IShardReplication }|null); + } + + /** Represents a GetShardReplicationResponse. */ + class GetShardReplicationResponse implements IGetShardReplicationResponse { + + /** + * Constructs a new GetShardReplicationResponse. + * @param [properties] Properties to set + */ + constructor(properties?: vtctldata.IGetShardReplicationResponse); + + /** GetShardReplicationResponse shard_replication_by_cell. */ + public shard_replication_by_cell: { [k: string]: topodata.IShardReplication }; + + /** + * Creates a new GetShardReplicationResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns GetShardReplicationResponse instance + */ + public static create(properties?: vtctldata.IGetShardReplicationResponse): vtctldata.GetShardReplicationResponse; + + /** + * Encodes the specified GetShardReplicationResponse message. Does not implicitly {@link vtctldata.GetShardReplicationResponse.verify|verify} messages. + * @param message GetShardReplicationResponse message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encode(message: vtctldata.IGetShardReplicationResponse, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Encodes the specified GetShardReplicationResponse message, length delimited. Does not implicitly {@link vtctldata.GetShardReplicationResponse.verify|verify} messages. + * @param message GetShardReplicationResponse message or plain object to encode + * @param [writer] Writer to encode to + * @returns Writer + */ + public static encodeDelimited(message: vtctldata.IGetShardReplicationResponse, writer?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a GetShardReplicationResponse message from the specified reader or buffer. + * @param reader Reader or buffer to decode from + * @param [length] Message length if known beforehand + * @returns GetShardReplicationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): vtctldata.GetShardReplicationResponse; + + /** + * Decodes a GetShardReplicationResponse message from the specified reader or buffer, length delimited. + * @param reader Reader or buffer to decode from + * @returns GetShardReplicationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): vtctldata.GetShardReplicationResponse; + + /** + * Verifies a GetShardReplicationResponse message. + * @param message Plain object to verify + * @returns `null` if valid, otherwise the reason why it is not + */ + public static verify(message: { [k: string]: any }): (string|null); + + /** + * Creates a GetShardReplicationResponse message from a plain object. Also converts values to their respective internal types. + * @param object Plain object + * @returns GetShardReplicationResponse + */ + public static fromObject(object: { [k: string]: any }): vtctldata.GetShardReplicationResponse; + + /** + * Creates a plain object from a GetShardReplicationResponse message. Also converts values to other types if specified. + * @param message GetShardReplicationResponse + * @param [options] Conversion options + * @returns Plain object + */ + public static toObject(message: vtctldata.GetShardReplicationResponse, options?: $protobuf.IConversionOptions): { [k: string]: any }; + + /** + * Converts this GetShardReplicationResponse to JSON. + * @returns JSON object + */ + public toJSON(): { [k: string]: any }; + + /** + * Gets the default type url for GetShardReplicationResponse + * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns The default type url + */ + public static getTypeUrl(typeUrlPrefix?: string): string; + } + /** Properties of a GetShardRequest. */ interface IGetShardRequest { diff --git a/web/vtadmin/src/proto/vtadmin.js b/web/vtadmin/src/proto/vtadmin.js index 957efd73ed0..fc8c6a862fe 100644 --- a/web/vtadmin/src/proto/vtadmin.js +++ b/web/vtadmin/src/proto/vtadmin.js @@ -128946,6 +128946,518 @@ export const vtctldata = $root.vtctldata = (() => { return GetSchemaMigrationsResponse; })(); + vtctldata.GetShardReplicationRequest = (function() { + + /** + * Properties of a GetShardReplicationRequest. + * @memberof vtctldata + * @interface IGetShardReplicationRequest + * @property {string|null} [keyspace] GetShardReplicationRequest keyspace + * @property {string|null} [shard] GetShardReplicationRequest shard + * @property {Array.|null} [cells] GetShardReplicationRequest cells + */ + + /** + * Constructs a new GetShardReplicationRequest. + * @memberof vtctldata + * @classdesc Represents a GetShardReplicationRequest. + * @implements IGetShardReplicationRequest + * @constructor + * @param {vtctldata.IGetShardReplicationRequest=} [properties] Properties to set + */ + function GetShardReplicationRequest(properties) { + this.cells = []; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * GetShardReplicationRequest keyspace. + * @member {string} keyspace + * @memberof vtctldata.GetShardReplicationRequest + * @instance + */ + GetShardReplicationRequest.prototype.keyspace = ""; + + /** + * GetShardReplicationRequest shard. + * @member {string} shard + * @memberof vtctldata.GetShardReplicationRequest + * @instance + */ + GetShardReplicationRequest.prototype.shard = ""; + + /** + * GetShardReplicationRequest cells. + * @member {Array.} cells + * @memberof vtctldata.GetShardReplicationRequest + * @instance + */ + GetShardReplicationRequest.prototype.cells = $util.emptyArray; + + /** + * Creates a new GetShardReplicationRequest instance using the specified properties. + * @function create + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {vtctldata.IGetShardReplicationRequest=} [properties] Properties to set + * @returns {vtctldata.GetShardReplicationRequest} GetShardReplicationRequest instance + */ + GetShardReplicationRequest.create = function create(properties) { + return new GetShardReplicationRequest(properties); + }; + + /** + * Encodes the specified GetShardReplicationRequest message. Does not implicitly {@link vtctldata.GetShardReplicationRequest.verify|verify} messages. + * @function encode + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {vtctldata.IGetShardReplicationRequest} message GetShardReplicationRequest message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + GetShardReplicationRequest.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.keyspace != null && Object.hasOwnProperty.call(message, "keyspace")) + writer.uint32(/* id 1, wireType 2 =*/10).string(message.keyspace); + if (message.shard != null && Object.hasOwnProperty.call(message, "shard")) + writer.uint32(/* id 2, wireType 2 =*/18).string(message.shard); + if (message.cells != null && message.cells.length) + for (let i = 0; i < message.cells.length; ++i) + writer.uint32(/* id 3, wireType 2 =*/26).string(message.cells[i]); + return writer; + }; + + /** + * Encodes the specified GetShardReplicationRequest message, length delimited. Does not implicitly {@link vtctldata.GetShardReplicationRequest.verify|verify} messages. + * @function encodeDelimited + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {vtctldata.IGetShardReplicationRequest} message GetShardReplicationRequest message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + GetShardReplicationRequest.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a GetShardReplicationRequest message from the specified reader or buffer. + * @function decode + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {vtctldata.GetShardReplicationRequest} GetShardReplicationRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + GetShardReplicationRequest.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.vtctldata.GetShardReplicationRequest(); + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + message.keyspace = reader.string(); + break; + } + case 2: { + message.shard = reader.string(); + break; + } + case 3: { + if (!(message.cells && message.cells.length)) + message.cells = []; + message.cells.push(reader.string()); + break; + } + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a GetShardReplicationRequest message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {vtctldata.GetShardReplicationRequest} GetShardReplicationRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + GetShardReplicationRequest.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a GetShardReplicationRequest message. + * @function verify + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + GetShardReplicationRequest.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.keyspace != null && message.hasOwnProperty("keyspace")) + if (!$util.isString(message.keyspace)) + return "keyspace: string expected"; + if (message.shard != null && message.hasOwnProperty("shard")) + if (!$util.isString(message.shard)) + return "shard: string expected"; + if (message.cells != null && message.hasOwnProperty("cells")) { + if (!Array.isArray(message.cells)) + return "cells: array expected"; + for (let i = 0; i < message.cells.length; ++i) + if (!$util.isString(message.cells[i])) + return "cells: string[] expected"; + } + return null; + }; + + /** + * Creates a GetShardReplicationRequest message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {Object.} object Plain object + * @returns {vtctldata.GetShardReplicationRequest} GetShardReplicationRequest + */ + GetShardReplicationRequest.fromObject = function fromObject(object) { + if (object instanceof $root.vtctldata.GetShardReplicationRequest) + return object; + let message = new $root.vtctldata.GetShardReplicationRequest(); + if (object.keyspace != null) + message.keyspace = String(object.keyspace); + if (object.shard != null) + message.shard = String(object.shard); + if (object.cells) { + if (!Array.isArray(object.cells)) + throw TypeError(".vtctldata.GetShardReplicationRequest.cells: array expected"); + message.cells = []; + for (let i = 0; i < object.cells.length; ++i) + message.cells[i] = String(object.cells[i]); + } + return message; + }; + + /** + * Creates a plain object from a GetShardReplicationRequest message. Also converts values to other types if specified. + * @function toObject + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {vtctldata.GetShardReplicationRequest} message GetShardReplicationRequest + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + GetShardReplicationRequest.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.arrays || options.defaults) + object.cells = []; + if (options.defaults) { + object.keyspace = ""; + object.shard = ""; + } + if (message.keyspace != null && message.hasOwnProperty("keyspace")) + object.keyspace = message.keyspace; + if (message.shard != null && message.hasOwnProperty("shard")) + object.shard = message.shard; + if (message.cells && message.cells.length) { + object.cells = []; + for (let j = 0; j < message.cells.length; ++j) + object.cells[j] = message.cells[j]; + } + return object; + }; + + /** + * Converts this GetShardReplicationRequest to JSON. + * @function toJSON + * @memberof vtctldata.GetShardReplicationRequest + * @instance + * @returns {Object.} JSON object + */ + GetShardReplicationRequest.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for GetShardReplicationRequest + * @function getTypeUrl + * @memberof vtctldata.GetShardReplicationRequest + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + GetShardReplicationRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/vtctldata.GetShardReplicationRequest"; + }; + + return GetShardReplicationRequest; + })(); + + vtctldata.GetShardReplicationResponse = (function() { + + /** + * Properties of a GetShardReplicationResponse. + * @memberof vtctldata + * @interface IGetShardReplicationResponse + * @property {Object.|null} [shard_replication_by_cell] GetShardReplicationResponse shard_replication_by_cell + */ + + /** + * Constructs a new GetShardReplicationResponse. + * @memberof vtctldata + * @classdesc Represents a GetShardReplicationResponse. + * @implements IGetShardReplicationResponse + * @constructor + * @param {vtctldata.IGetShardReplicationResponse=} [properties] Properties to set + */ + function GetShardReplicationResponse(properties) { + this.shard_replication_by_cell = {}; + if (properties) + for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * GetShardReplicationResponse shard_replication_by_cell. + * @member {Object.} shard_replication_by_cell + * @memberof vtctldata.GetShardReplicationResponse + * @instance + */ + GetShardReplicationResponse.prototype.shard_replication_by_cell = $util.emptyObject; + + /** + * Creates a new GetShardReplicationResponse instance using the specified properties. + * @function create + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {vtctldata.IGetShardReplicationResponse=} [properties] Properties to set + * @returns {vtctldata.GetShardReplicationResponse} GetShardReplicationResponse instance + */ + GetShardReplicationResponse.create = function create(properties) { + return new GetShardReplicationResponse(properties); + }; + + /** + * Encodes the specified GetShardReplicationResponse message. Does not implicitly {@link vtctldata.GetShardReplicationResponse.verify|verify} messages. + * @function encode + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {vtctldata.IGetShardReplicationResponse} message GetShardReplicationResponse message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + GetShardReplicationResponse.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.shard_replication_by_cell != null && Object.hasOwnProperty.call(message, "shard_replication_by_cell")) + for (let keys = Object.keys(message.shard_replication_by_cell), i = 0; i < keys.length; ++i) { + writer.uint32(/* id 1, wireType 2 =*/10).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]); + $root.topodata.ShardReplication.encode(message.shard_replication_by_cell[keys[i]], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim().ldelim(); + } + return writer; + }; + + /** + * Encodes the specified GetShardReplicationResponse message, length delimited. Does not implicitly {@link vtctldata.GetShardReplicationResponse.verify|verify} messages. + * @function encodeDelimited + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {vtctldata.IGetShardReplicationResponse} message GetShardReplicationResponse message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + GetShardReplicationResponse.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a GetShardReplicationResponse message from the specified reader or buffer. + * @function decode + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {vtctldata.GetShardReplicationResponse} GetShardReplicationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + GetShardReplicationResponse.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + let end = length === undefined ? reader.len : reader.pos + length, message = new $root.vtctldata.GetShardReplicationResponse(), key, value; + while (reader.pos < end) { + let tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (message.shard_replication_by_cell === $util.emptyObject) + message.shard_replication_by_cell = {}; + let end2 = reader.uint32() + reader.pos; + key = ""; + value = null; + while (reader.pos < end2) { + let tag2 = reader.uint32(); + switch (tag2 >>> 3) { + case 1: + key = reader.string(); + break; + case 2: + value = $root.topodata.ShardReplication.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag2 & 7); + break; + } + } + message.shard_replication_by_cell[key] = value; + break; + } + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a GetShardReplicationResponse message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {vtctldata.GetShardReplicationResponse} GetShardReplicationResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + GetShardReplicationResponse.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a GetShardReplicationResponse message. + * @function verify + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + GetShardReplicationResponse.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.shard_replication_by_cell != null && message.hasOwnProperty("shard_replication_by_cell")) { + if (!$util.isObject(message.shard_replication_by_cell)) + return "shard_replication_by_cell: object expected"; + let key = Object.keys(message.shard_replication_by_cell); + for (let i = 0; i < key.length; ++i) { + let error = $root.topodata.ShardReplication.verify(message.shard_replication_by_cell[key[i]]); + if (error) + return "shard_replication_by_cell." + error; + } + } + return null; + }; + + /** + * Creates a GetShardReplicationResponse message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {Object.} object Plain object + * @returns {vtctldata.GetShardReplicationResponse} GetShardReplicationResponse + */ + GetShardReplicationResponse.fromObject = function fromObject(object) { + if (object instanceof $root.vtctldata.GetShardReplicationResponse) + return object; + let message = new $root.vtctldata.GetShardReplicationResponse(); + if (object.shard_replication_by_cell) { + if (typeof object.shard_replication_by_cell !== "object") + throw TypeError(".vtctldata.GetShardReplicationResponse.shard_replication_by_cell: object expected"); + message.shard_replication_by_cell = {}; + for (let keys = Object.keys(object.shard_replication_by_cell), i = 0; i < keys.length; ++i) { + if (typeof object.shard_replication_by_cell[keys[i]] !== "object") + throw TypeError(".vtctldata.GetShardReplicationResponse.shard_replication_by_cell: object expected"); + message.shard_replication_by_cell[keys[i]] = $root.topodata.ShardReplication.fromObject(object.shard_replication_by_cell[keys[i]]); + } + } + return message; + }; + + /** + * Creates a plain object from a GetShardReplicationResponse message. Also converts values to other types if specified. + * @function toObject + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {vtctldata.GetShardReplicationResponse} message GetShardReplicationResponse + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + GetShardReplicationResponse.toObject = function toObject(message, options) { + if (!options) + options = {}; + let object = {}; + if (options.objects || options.defaults) + object.shard_replication_by_cell = {}; + let keys2; + if (message.shard_replication_by_cell && (keys2 = Object.keys(message.shard_replication_by_cell)).length) { + object.shard_replication_by_cell = {}; + for (let j = 0; j < keys2.length; ++j) + object.shard_replication_by_cell[keys2[j]] = $root.topodata.ShardReplication.toObject(message.shard_replication_by_cell[keys2[j]], options); + } + return object; + }; + + /** + * Converts this GetShardReplicationResponse to JSON. + * @function toJSON + * @memberof vtctldata.GetShardReplicationResponse + * @instance + * @returns {Object.} JSON object + */ + GetShardReplicationResponse.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + /** + * Gets the default type url for GetShardReplicationResponse + * @function getTypeUrl + * @memberof vtctldata.GetShardReplicationResponse + * @static + * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com") + * @returns {string} The default type url + */ + GetShardReplicationResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) { + if (typeUrlPrefix === undefined) { + typeUrlPrefix = "type.googleapis.com"; + } + return typeUrlPrefix + "/vtctldata.GetShardReplicationResponse"; + }; + + return GetShardReplicationResponse; + })(); + vtctldata.GetShardRequest = (function() { /** From 9ff255de70d7709eb4c392139eed7b19057cd363 Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Sun, 3 Mar 2024 16:48:28 +0200 Subject: [PATCH 71/79] `onlineddl_scheduler` test: fix flakiness in artifact cleanup test (#15396) --- .../endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go b/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go index 01f7024f59c..5a72cbfc839 100644 --- a/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go +++ b/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go @@ -1025,6 +1025,9 @@ func testScheduler(t *testing.T) { t1uuid = testOnlineDDLStatement(t, createParams(trivialAlterT1Statement, ddlStrategy+" --postpone-completion --retain-artifacts=1s", "vtctl", "", "", true)) // skip wait onlineddl.WaitForMigrationStatus(t, &vtParams, shards, t1uuid, normalWaitTime, schema.OnlineDDLStatusRunning) }) + t.Run("wait for ready_to_complete", func(t *testing.T) { + waitForReadyToComplete(t, t1uuid, true) + }) var artifacts []string t.Run("validate artifact exists", func(t *testing.T) { rs := onlineddl.ReadMigrations(t, &vtParams, t1uuid) @@ -2512,7 +2515,7 @@ func checkTablesCount(t *testing.T, tablet *cluster.Vttablet, showTableName stri query := fmt.Sprintf(`show tables like '%%%s%%';`, showTableName) queryResult, err := tablet.VttabletProcess.QueryTablet(query, keyspaceName, true) require.Nil(t, err) - return assert.Equal(t, expectCount, len(queryResult.Rows)) + return assert.Equalf(t, expectCount, len(queryResult.Rows), "checkTablesCount cannot find table like '%%%s%%'", showTableName) } // checkMigratedTables checks the CREATE STATEMENT of a table after migration From 7a2af6f4728501bff2aabfa7f2c74226e687ba2d Mon Sep 17 00:00:00 2001 From: Arthur Schreiber Date: Mon, 4 Mar 2024 13:04:33 +0100 Subject: [PATCH 72/79] Make connection killing resilient to MySQL hangs (#14500) Signed-off-by: Arthur Schreiber Signed-off-by: Vicent Marti Signed-off-by: Daniel Joos Co-authored-by: Vicent Marti Co-authored-by: Daniel Joos --- go/mysql/fakesqldb/server.go | 13 +- .../vttablet/tabletserver/connpool/dbconn.go | 182 ++++++++++-------- .../tabletserver/connpool/dbconn_test.go | 104 ++++++++++ .../tabletserver/tabletserver_test.go | 16 ++ 4 files changed, 226 insertions(+), 89 deletions(-) diff --git a/go/mysql/fakesqldb/server.go b/go/mysql/fakesqldb/server.go index 09f0c42942e..d4ad5ad9dac 100644 --- a/go/mysql/fakesqldb/server.go +++ b/go/mysql/fakesqldb/server.go @@ -376,11 +376,11 @@ func (db *DB) HandleQuery(c *mysql.Conn, query string, callback func(*sqltypes.R } key := strings.ToLower(query) db.mu.Lock() - defer db.mu.Unlock() db.queryCalled[key]++ db.querylog = append(db.querylog, key) // Check if we should close the connection and provoke errno 2013. if db.shouldClose.Load() { + defer db.mu.Unlock() c.Close() // log error @@ -394,6 +394,8 @@ func (db *DB) HandleQuery(c *mysql.Conn, query string, callback func(*sqltypes.R // The driver may send this at connection time, and we don't want it to // interfere. if key == "set names utf8" || strings.HasPrefix(key, "set collation_connection = ") { + defer db.mu.Unlock() + // log error if err := callback(&sqltypes.Result{}); err != nil { log.Errorf("callback failed : %v", err) @@ -403,12 +405,14 @@ func (db *DB) HandleQuery(c *mysql.Conn, query string, callback func(*sqltypes.R // check if we should reject it. if err, ok := db.rejectedData[key]; ok { + db.mu.Unlock() return err } // Check explicit queries from AddQuery(). result, ok := db.data[key] if ok { + db.mu.Unlock() if f := result.BeforeFunc; f != nil { f() } @@ -419,12 +423,9 @@ func (db *DB) HandleQuery(c *mysql.Conn, query string, callback func(*sqltypes.R for _, pat := range db.patternData { if pat.expr.MatchString(query) { userCallback, ok := db.queryPatternUserCallback[pat.expr] + db.mu.Unlock() if ok { - // Since the user call back can be indefinitely stuck, we shouldn't hold the lock indefinitely. - // This is only test code, so no actual cause for concern. - db.mu.Unlock() userCallback(query) - db.mu.Lock() } if pat.err != "" { return fmt.Errorf(pat.err) @@ -433,6 +434,8 @@ func (db *DB) HandleQuery(c *mysql.Conn, query string, callback func(*sqltypes.R } } + defer db.mu.Unlock() + if db.neverFail.Load() { return callback(&sqltypes.Result{}) } diff --git a/go/vt/vttablet/tabletserver/connpool/dbconn.go b/go/vt/vttablet/tabletserver/connpool/dbconn.go index bedbdc66c0a..a41fcc7b7ec 100644 --- a/go/vt/vttablet/tabletserver/connpool/dbconn.go +++ b/go/vt/vttablet/tabletserver/connpool/dbconn.go @@ -40,6 +40,8 @@ import ( vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) +const defaultKillTimeout = 5 * time.Second + // Conn is a db connection for tabletserver. // It performs automatic reconnects as needed. // Its Execute function has a timeout that can kill @@ -52,11 +54,13 @@ type Conn struct { env tabletenv.Env dbaPool *dbconnpool.ConnectionPool stats *tabletenv.Stats - current atomic.Value + current atomic.Pointer[string] // err will be set if a query is killed through a Kill. errmu sync.Mutex err error + + killTimeout time.Duration } // NewConnection creates a new DBConn. It triggers a CheckMySQL if creation fails. @@ -71,12 +75,12 @@ func newPooledConn(ctx context.Context, pool *Pool, appParams dbconfigs.Connecto return nil, err } db := &Conn{ - conn: c, - env: pool.env, - stats: pool.env.Stats(), - dbaPool: pool.dbaPool, + conn: c, + env: pool.env, + stats: pool.env.Stats(), + dbaPool: pool.dbaPool, + killTimeout: defaultKillTimeout, } - db.current.Store("") return db, nil } @@ -87,12 +91,12 @@ func NewConn(ctx context.Context, params dbconfigs.Connector, dbaPool *dbconnpoo return nil, err } dbconn := &Conn{ - conn: c, - dbaPool: dbaPool, - stats: tabletenv.NewStats(servenv.NewExporter("Temp", "Tablet")), - env: env, + conn: c, + dbaPool: dbaPool, + stats: tabletenv.NewStats(servenv.NewExporter("Temp", "Tablet")), + env: env, + killTimeout: defaultKillTimeout, } - dbconn.current.Store("") if setting == nil { return dbconn, nil } @@ -153,8 +157,8 @@ func (dbc *Conn) Exec(ctx context.Context, query string, maxrows int, wantfields } func (dbc *Conn) execOnce(ctx context.Context, query string, maxrows int, wantfields bool) (*sqltypes.Result, error) { - dbc.current.Store(query) - defer dbc.current.Store("") + dbc.current.Store(&query) + defer dbc.current.Store(nil) // Check if the context is already past its deadline before // trying to execute the query. @@ -162,19 +166,33 @@ func (dbc *Conn) execOnce(ctx context.Context, query string, maxrows int, wantfi return nil, fmt.Errorf("%v before execution started", err) } - defer dbc.stats.MySQLTimings.Record("Exec", time.Now()) - - done, wg := dbc.setDeadline(ctx) - qr, err := dbc.conn.ExecuteFetch(query, maxrows, wantfields) + now := time.Now() + defer dbc.stats.MySQLTimings.Record("Exec", now) - if done != nil { - close(done) - wg.Wait() + type execResult struct { + result *sqltypes.Result + err error } - if dbcerr := dbc.Err(); dbcerr != nil { - return nil, dbcerr + + ch := make(chan execResult) + go func() { + result, err := dbc.conn.ExecuteFetch(query, maxrows, wantfields) + ch <- execResult{result, err} + }() + + select { + case <-ctx.Done(): + killCtx, cancel := context.WithTimeout(context.Background(), dbc.killTimeout) + defer cancel() + + _ = dbc.KillWithContext(killCtx, ctx.Err().Error(), time.Since(now)) + return nil, dbc.Err() + case r := <-ch: + if dbcErr := dbc.Err(); dbcErr != nil { + return nil, dbcErr + } + return r.result, r.err } - return qr, err } // ExecOnce executes the specified query, but does not retry on connection errors. @@ -250,22 +268,30 @@ func (dbc *Conn) Stream(ctx context.Context, query string, callback func(*sqltyp } func (dbc *Conn) streamOnce(ctx context.Context, query string, callback func(*sqltypes.Result) error, alloc func() *sqltypes.Result, streamBufferSize int) error { - defer dbc.stats.MySQLTimings.Record("ExecStream", time.Now()) + dbc.current.Store(&query) + defer dbc.current.Store(nil) - dbc.current.Store(query) - defer dbc.current.Store("") + now := time.Now() + defer dbc.stats.MySQLTimings.Record("ExecStream", now) - done, wg := dbc.setDeadline(ctx) - err := dbc.conn.ExecuteStreamFetch(query, callback, alloc, streamBufferSize) + ch := make(chan error) + go func() { + ch <- dbc.conn.ExecuteStreamFetch(query, callback, alloc, streamBufferSize) + }() - if done != nil { - close(done) - wg.Wait() - } - if dbcerr := dbc.Err(); dbcerr != nil { - return dbcerr + select { + case <-ctx.Done(): + killCtx, cancel := context.WithTimeout(context.Background(), dbc.killTimeout) + defer cancel() + + _ = dbc.KillWithContext(killCtx, ctx.Err().Error(), time.Since(now)) + return dbc.Err() + case err := <-ch: + if dbcErr := dbc.Err(); dbcErr != nil { + return dbcErr + } + return err } - return err } // StreamOnce executes the query and streams the results. But, does not retry on connection errors. @@ -363,10 +389,19 @@ func (dbc *Conn) IsClosed() bool { return dbc.conn.IsClosed() } -// Kill kills the currently executing query both on MySQL side +// Kill wraps KillWithContext using context.Background. +func (dbc *Conn) Kill(reason string, elapsed time.Duration) error { + return dbc.KillWithContext(context.Background(), reason, elapsed) +} + +// KillWithContext kills the currently executing query both on MySQL side // and on the connection side. If no query is executing, it's a no-op. // Kill will also not kill a query more than once. -func (dbc *Conn) Kill(reason string, elapsed time.Duration) error { +func (dbc *Conn) KillWithContext(ctx context.Context, reason string, elapsed time.Duration) error { + if cause := context.Cause(ctx); cause != nil { + return cause + } + dbc.stats.KillCounters.Add("Queries", 1) log.Infof("Due to %s, elapsed time: %v, killing query ID %v %s", reason, elapsed, dbc.conn.ID(), dbc.CurrentForLogging()) @@ -377,25 +412,43 @@ func (dbc *Conn) Kill(reason string, elapsed time.Duration) error { dbc.conn.Close() // Server side action. Kill the session. - killConn, err := dbc.dbaPool.Get(context.TODO()) + killConn, err := dbc.dbaPool.Get(ctx) if err != nil { log.Warningf("Failed to get conn from dba pool: %v", err) return err } defer killConn.Recycle() + + ch := make(chan error) sql := fmt.Sprintf("kill %d", dbc.conn.ID()) - _, err = killConn.Conn.ExecuteFetch(sql, 10000, false) - if err != nil { - log.Errorf("Could not kill query ID %v %s: %v", dbc.conn.ID(), - dbc.CurrentForLogging(), err) - return err + go func() { + _, err := killConn.Conn.ExecuteFetch(sql, -1, false) + ch <- err + }() + + select { + case <-ctx.Done(): + killConn.Close() + + dbc.stats.InternalErrors.Add("HungQuery", 1) + log.Warningf("Query may be hung: %s", dbc.CurrentForLogging()) + + return context.Cause(ctx) + case err := <-ch: + if err != nil { + log.Errorf("Could not kill query ID %v %s: %v", dbc.conn.ID(), dbc.CurrentForLogging(), err) + return err + } + return nil } - return nil } // Current returns the currently executing query. func (dbc *Conn) Current() string { - return dbc.current.Load().(string) + if q := dbc.current.Load(); q != nil { + return *q + } + return "" } // ID returns the connection id. @@ -437,45 +490,6 @@ func (dbc *Conn) Reconnect(ctx context.Context) error { return nil } -// setDeadline starts a goroutine that will kill the currently executing query -// if the deadline is exceeded. It returns a channel and a waitgroup. After the -// query is done executing, the caller is required to close the done channel -// and wait for the waitgroup to make sure that the necessary cleanup is done. -func (dbc *Conn) setDeadline(ctx context.Context) (chan bool, *sync.WaitGroup) { - if ctx.Done() == nil { - return nil, nil - } - done := make(chan bool) - var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() - startTime := time.Now() - select { - case <-ctx.Done(): - dbc.Kill(ctx.Err().Error(), time.Since(startTime)) - case <-done: - return - } - elapsed := time.Since(startTime) - - // Give 2x the elapsed time and some buffer as grace period - // for the query to get killed. - tmr2 := time.NewTimer(2*elapsed + 5*time.Second) - defer tmr2.Stop() - select { - case <-tmr2.C: - dbc.stats.InternalErrors.Add("HungQuery", 1) - log.Warningf("Query may be hung: %s", dbc.CurrentForLogging()) - case <-done: - return - } - <-done - log.Warningf("Hung query returned") - }() - return done, &wg -} - // CurrentForLogging applies transformations to the query making it suitable to log. // It applies sanitization rules based on tablet settings and limits the max length of // queries. diff --git a/go/vt/vttablet/tabletserver/connpool/dbconn_test.go b/go/vt/vttablet/tabletserver/connpool/dbconn_test.go index d22b8f1c311..09a85a3e11a 100644 --- a/go/vt/vttablet/tabletserver/connpool/dbconn_test.go +++ b/go/vt/vttablet/tabletserver/connpool/dbconn_test.go @@ -21,6 +21,7 @@ import ( "errors" "fmt" "strings" + "sync/atomic" "testing" "time" @@ -33,7 +34,9 @@ import ( "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/dbconfigs" querypb "vitess.io/vitess/go/vt/proto/query" + vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/vtenv" + "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv" ) @@ -297,6 +300,59 @@ func TestDBConnKill(t *testing.T) { } } +func TestDBKillWithContext(t *testing.T) { + db := fakesqldb.New(t) + defer db.Close() + connPool := newPool() + params := dbconfigs.New(db.ConnParams()) + connPool.Open(params, params, params) + defer connPool.Close() + dbConn, err := newPooledConn(context.Background(), connPool, params) + if dbConn != nil { + defer dbConn.Close() + } + require.NoError(t, err) + + query := fmt.Sprintf("kill %d", dbConn.ID()) + db.AddQuery(query, &sqltypes.Result{}) + db.SetBeforeFunc(query, func() { + // should take longer than our context deadline below. + time.Sleep(200 * time.Millisecond) + }) + + ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) + defer cancel() + + // KillWithContext should return context.DeadlineExceeded + err = dbConn.KillWithContext(ctx, "test kill", 0) + require.ErrorIs(t, err, context.DeadlineExceeded) +} + +func TestDBKillWithContextDoneContext(t *testing.T) { + db := fakesqldb.New(t) + defer db.Close() + connPool := newPool() + params := dbconfigs.New(db.ConnParams()) + connPool.Open(params, params, params) + defer connPool.Close() + dbConn, err := newPooledConn(context.Background(), connPool, params) + if dbConn != nil { + defer dbConn.Close() + } + require.NoError(t, err) + + query := fmt.Sprintf("kill %d", dbConn.ID()) + db.AddRejectedQuery(query, errors.New("rejected")) + + contextErr := errors.New("context error") + ctx, cancel := context.WithCancelCause(context.Background()) + cancel(contextErr) // cancel the context immediately + + // KillWithContext should return the cancellation cause + err = dbConn.KillWithContext(ctx, "test kill", 0) + require.ErrorIs(t, err, contextErr) +} + // TestDBConnClose tests that an Exec returns immediately if a connection // is asynchronously killed (and closed) in the middle of an execution. func TestDBConnClose(t *testing.T) { @@ -531,3 +587,51 @@ func TestDBConnReApplySetting(t *testing.T) { db.VerifyAllExecutedOrFail() } + +func TestDBExecOnceKillTimeout(t *testing.T) { + db := fakesqldb.New(t) + defer db.Close() + connPool := newPool() + params := dbconfigs.New(db.ConnParams()) + connPool.Open(params, params, params) + defer connPool.Close() + dbConn, err := newPooledConn(context.Background(), connPool, params) + if dbConn != nil { + defer dbConn.Close() + } + require.NoError(t, err) + + // A very long running query that will be killed. + expectedQuery := "select 1" + var timestampQuery atomic.Int64 + db.AddQuery(expectedQuery, &sqltypes.Result{}) + db.SetBeforeFunc(expectedQuery, func() { + timestampQuery.Store(time.Now().UnixMicro()) + // should take longer than our context deadline below. + time.Sleep(1000 * time.Millisecond) + }) + + // We expect a kill-query to be fired, too. + // It should also run into a timeout. + var timestampKill atomic.Int64 + dbConn.killTimeout = 100 * time.Millisecond + db.AddQueryPatternWithCallback(`kill \d+`, &sqltypes.Result{}, func(string) { + timestampKill.Store(time.Now().UnixMicro()) + // should take longer than the configured kill timeout above. + time.Sleep(200 * time.Millisecond) + }) + + ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) + defer cancel() + + result, err := dbConn.ExecOnce(ctx, "select 1", 1, false) + timeDone := time.Now() + + require.Error(t, err) + require.Equal(t, vtrpcpb.Code_CANCELED, vterrors.Code(err)) + require.Nil(t, result) + timeQuery := time.UnixMicro(timestampQuery.Load()) + timeKill := time.UnixMicro(timestampKill.Load()) + require.WithinDuration(t, timeQuery, timeKill, 150*time.Millisecond) + require.WithinDuration(t, timeKill, timeDone, 150*time.Millisecond) +} diff --git a/go/vt/vttablet/tabletserver/tabletserver_test.go b/go/vt/vttablet/tabletserver/tabletserver_test.go index df68c8b0a83..0374fb416a6 100644 --- a/go/vt/vttablet/tabletserver/tabletserver_test.go +++ b/go/vt/vttablet/tabletserver/tabletserver_test.go @@ -1122,6 +1122,20 @@ func TestSerializeTransactionsSameRow_ConcurrentTransactions(t *testing.T) { db.SetBeforeFunc("update test_table set name_string = 'tx1' where pk = 1 and `name` = 1 limit 10001", func() { close(tx1Started) + + // Wait for other queries to be pending. + <-allQueriesPending + }) + + db.SetBeforeFunc("update test_table set name_string = 'tx2' where pk = 1 and `name` = 1 limit 10001", + func() { + // Wait for other queries to be pending. + <-allQueriesPending + }) + + db.SetBeforeFunc("update test_table set name_string = 'tx3' where pk = 1 and `name` = 1 limit 10001", + func() { + // Wait for other queries to be pending. <-allQueriesPending }) @@ -1190,6 +1204,8 @@ func TestSerializeTransactionsSameRow_ConcurrentTransactions(t *testing.T) { // to allow more than connection attempt at a time. err := waitForTxSerializationPendingQueries(tsv, "test_table where pk = 1 and `name` = 1", 3) require.NoError(t, err) + + // Signal that all queries are pending now. close(allQueriesPending) wg.Wait() From 259d9636aaa65dc0c517d8e171f2dc28c0981cc8 Mon Sep 17 00:00:00 2001 From: Renan Rangel Date: Mon, 4 Mar 2024 19:32:16 +0000 Subject: [PATCH 73/79] prevent vtctld from creating tons of S3 connections (#15296) Signed-off-by: Renan Rangel Signed-off-by: 'Renan Rangel' --- go/vt/mysqlctl/s3backupstorage/s3.go | 25 +++++++++++++++-------- go/vt/mysqlctl/s3backupstorage/s3_test.go | 10 +++++++++ 2 files changed, 27 insertions(+), 8 deletions(-) diff --git a/go/vt/mysqlctl/s3backupstorage/s3.go b/go/vt/mysqlctl/s3backupstorage/s3.go index ef3bfc37b31..6f5f3737719 100644 --- a/go/vt/mysqlctl/s3backupstorage/s3.go +++ b/go/vt/mysqlctl/s3backupstorage/s3.go @@ -281,10 +281,21 @@ func (s3ServerSideEncryption *S3ServerSideEncryption) reset() { // S3BackupStorage implements the backupstorage.BackupStorage interface. type S3BackupStorage struct { - _client *s3.S3 - mu sync.Mutex - s3SSE S3ServerSideEncryption - params backupstorage.Params + _client *s3.S3 + mu sync.Mutex + s3SSE S3ServerSideEncryption + params backupstorage.Params + transport *http.Transport +} + +func newS3BackupStorage() *S3BackupStorage { + // This initialises a new transport based off http.DefaultTransport the first time and returns the same + // transport on subsequent calls so connections can be reused as part of the same transport. + tlsClientConf := &tls.Config{InsecureSkipVerify: tlsSkipVerifyCert} + transport := http.DefaultTransport.(*http.Transport).Clone() + transport.TLSClientConfig = tlsClientConf + + return &S3BackupStorage{params: backupstorage.NoParams(), transport: transport} } // ListBackups is part of the backupstorage.BackupStorage interface. @@ -445,9 +456,7 @@ func (bs *S3BackupStorage) client() (*s3.S3, error) { if bs._client == nil { logLevel := getLogLevel() - tlsClientConf := &tls.Config{InsecureSkipVerify: tlsSkipVerifyCert} - httpTransport := &http.Transport{TLSClientConfig: tlsClientConf} - httpClient := &http.Client{Transport: httpTransport} + httpClient := &http.Client{Transport: bs.transport} session, err := session.NewSession() if err != nil { @@ -497,7 +506,7 @@ func objName(parts ...string) *string { } func init() { - backupstorage.BackupStorageMap["s3"] = &S3BackupStorage{params: backupstorage.NoParams()} + backupstorage.BackupStorageMap["s3"] = newS3BackupStorage() logNameMap = logNameToLogLevel{ "LogOff": aws.LogOff, diff --git a/go/vt/mysqlctl/s3backupstorage/s3_test.go b/go/vt/mysqlctl/s3backupstorage/s3_test.go index a10432b78c2..ed97555e64b 100644 --- a/go/vt/mysqlctl/s3backupstorage/s3_test.go +++ b/go/vt/mysqlctl/s3backupstorage/s3_test.go @@ -276,3 +276,13 @@ func TestSSECustomerFileBase64Key(t *testing.T) { assert.Nil(t, sseData.customerKey, "customerKey expected to be nil") assert.Nil(t, sseData.customerMd5, "customerMd5 expected to be nil") } + +func TestNewS3Transport(t *testing.T) { + s3 := newS3BackupStorage() + + // checking some of the values are present in the returned transport and match the http.DefaultTransport. + assert.Equal(t, http.DefaultTransport.(*http.Transport).IdleConnTimeout, s3.transport.IdleConnTimeout) + assert.Equal(t, http.DefaultTransport.(*http.Transport).MaxIdleConns, s3.transport.MaxIdleConns) + assert.NotNil(t, s3.transport.DialContext) + assert.NotNil(t, s3.transport.Proxy) +} From 0eadbe83ccffff71af2bca7c62d0203f2f5fc757 Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Tue, 5 Mar 2024 09:35:16 +0530 Subject: [PATCH 74/79] Fixing Column aliases in outer join queries (#15384) Signed-off-by: Manan Gupta Signed-off-by: Florent Poinsard <35779988+frouioui@users.noreply.github.com> Co-authored-by: Florent Poinsard <35779988+frouioui@users.noreply.github.com> --- .../endtoend/vtgate/queries/misc/misc_test.go | 19 ++++++ go/vt/vtgate/engine/cached_size.go | 9 ++- go/vt/vtgate/engine/simple_projection.go | 27 ++++++-- go/vt/vtgate/engine/simple_projection_test.go | 15 +++-- .../planbuilder/operator_transformers.go | 9 +-- .../planbuilder/operators/projection.go | 16 +++-- .../ddl_cases_no_default_keyspace.json | 4 +- .../planbuilder/testdata/from_cases.json | 8 +-- .../testdata/info_schema57_cases.json | 4 +- .../testdata/info_schema80_cases.json | 4 +- .../planbuilder/testdata/rails_cases.json | 4 +- .../planbuilder/testdata/select_cases.json | 66 +++++++++++++++++-- go/vt/vtgate/semantics/early_rewriter.go | 6 +- go/vt/vtgate/semantics/early_rewriter_test.go | 32 ++++----- 14 files changed, 167 insertions(+), 56 deletions(-) diff --git a/go/test/endtoend/vtgate/queries/misc/misc_test.go b/go/test/endtoend/vtgate/queries/misc/misc_test.go index 472d725488c..ce7f83916ab 100644 --- a/go/test/endtoend/vtgate/queries/misc/misc_test.go +++ b/go/test/endtoend/vtgate/queries/misc/misc_test.go @@ -352,3 +352,22 @@ func TestTransactionModeVar(t *testing.T) { }) } } + +// TestAliasesInOuterJoinQueries tests that aliases work in queries that have outer join clauses. +func TestAliasesInOuterJoinQueries(t *testing.T) { + utils.SkipIfBinaryIsBelowVersion(t, 20, "vtgate") + + mcmp, closer := start(t) + defer closer() + + // Insert data into the 2 tables + mcmp.Exec("insert into t1(id1, id2) values (1,2), (42,5), (5, 42)") + mcmp.Exec("insert into tbl(id, unq_col, nonunq_col) values (1,2,3), (2,5,3), (3, 42, 2)") + + // Check that the select query works as intended and then run it again verifying the column names as well. + mcmp.AssertMatches("select t1.id1 as t0, t1.id1 as t1, tbl.unq_col as col from t1 left outer join tbl on t1.id2 = tbl.nonunq_col", `[[INT64(1) INT64(1) INT64(42)] [INT64(5) INT64(5) NULL] [INT64(42) INT64(42) NULL]]`) + mcmp.ExecWithColumnCompare("select t1.id1 as t0, t1.id1 as t1, tbl.unq_col as col from t1 left outer join tbl on t1.id2 = tbl.nonunq_col") + + mcmp.AssertMatches("select t1.id1 as t0, t1.id1 as t1, tbl.unq_col as col from t1 left outer join tbl on t1.id2 = tbl.nonunq_col order by t1.id2 limit 2", `[[INT64(1) INT64(1) INT64(42)] [INT64(42) INT64(42) NULL]]`) + mcmp.ExecWithColumnCompare("select t1.id1 as t0, t1.id1 as t1, tbl.unq_col as col from t1 left outer join tbl on t1.id2 = tbl.nonunq_col order by t1.id2 limit 2") +} diff --git a/go/vt/vtgate/engine/cached_size.go b/go/vt/vtgate/engine/cached_size.go index 32ecd9ff6a9..5ff7a7c96ce 100644 --- a/go/vt/vtgate/engine/cached_size.go +++ b/go/vt/vtgate/engine/cached_size.go @@ -1159,12 +1159,19 @@ func (cached *SimpleProjection) CachedSize(alloc bool) int64 { } size := int64(0) if alloc { - size += int64(48) + size += int64(64) } // field Cols []int { size += hack.RuntimeAllocSize(int64(cap(cached.Cols)) * int64(8)) } + // field ColNames []string + { + size += hack.RuntimeAllocSize(int64(cap(cached.ColNames)) * int64(16)) + for _, elem := range cached.ColNames { + size += hack.RuntimeAllocSize(int64(len(elem))) + } + } // field Input vitess.io/vitess/go/vt/vtgate/engine.Primitive if cc, ok := cached.Input.(cachedObject); ok { size += cc.CachedSize(true) diff --git a/go/vt/vtgate/engine/simple_projection.go b/go/vt/vtgate/engine/simple_projection.go index 1a4f4ce92c4..dc80e14b1e1 100644 --- a/go/vt/vtgate/engine/simple_projection.go +++ b/go/vt/vtgate/engine/simple_projection.go @@ -19,6 +19,8 @@ package engine import ( "context" + "google.golang.org/protobuf/proto" + "vitess.io/vitess/go/sqltypes" querypb "vitess.io/vitess/go/vt/proto/query" ) @@ -29,8 +31,10 @@ var _ Primitive = (*SimpleProjection)(nil) type SimpleProjection struct { // Cols defines the column numbers from the underlying primitive // to be returned. - Cols []int - Input Primitive + Cols []int + // ColNames are the column names to use for the columns. + ColNames []string + Input Primitive } // NeedsTransaction implements the Primitive interface @@ -104,8 +108,13 @@ func (sc *SimpleProjection) buildFields(inner *sqltypes.Result) []*querypb.Field return nil } fields := make([]*querypb.Field, 0, len(sc.Cols)) - for _, col := range sc.Cols { - fields = append(fields, inner.Fields[col]) + for idx, col := range sc.Cols { + field := inner.Fields[col] + if sc.ColNames[idx] != "" { + field = proto.Clone(field).(*querypb.Field) + field.Name = sc.ColNames[idx] + } + fields = append(fields, field) } return fields } @@ -114,6 +123,16 @@ func (sc *SimpleProjection) description() PrimitiveDescription { other := map[string]any{ "Columns": sc.Cols, } + emptyColNames := true + for _, cName := range sc.ColNames { + if cName != "" { + emptyColNames = false + break + } + } + if !emptyColNames { + other["ColumnNames"] = sc.ColNames + } return PrimitiveDescription{ OperatorType: "SimpleProjection", Other: other, diff --git a/go/vt/vtgate/engine/simple_projection_test.go b/go/vt/vtgate/engine/simple_projection_test.go index 6fdc288095c..37c5a4d1dc0 100644 --- a/go/vt/vtgate/engine/simple_projection_test.go +++ b/go/vt/vtgate/engine/simple_projection_test.go @@ -44,8 +44,9 @@ func TestSubqueryExecute(t *testing.T) { } sq := &SimpleProjection{ - Cols: []int{0, 2}, - Input: prim, + Cols: []int{0, 2}, + ColNames: []string{"", ""}, + Input: prim, } bv := map[string]*querypb.BindVariable{ @@ -93,8 +94,9 @@ func TestSubqueryStreamExecute(t *testing.T) { } sq := &SimpleProjection{ - Cols: []int{0, 2}, - Input: prim, + Cols: []int{0, 2}, + ColNames: []string{"", ""}, + Input: prim, } bv := map[string]*querypb.BindVariable{ @@ -142,8 +144,9 @@ func TestSubqueryGetFields(t *testing.T) { } sq := &SimpleProjection{ - Cols: []int{0, 2}, - Input: prim, + Cols: []int{0, 2}, + ColNames: []string{"", ""}, + Input: prim, } bv := map[string]*querypb.BindVariable{ diff --git a/go/vt/vtgate/planbuilder/operator_transformers.go b/go/vt/vtgate/planbuilder/operator_transformers.go index 4d5a5642dac..831dae4ade2 100644 --- a/go/vt/vtgate/planbuilder/operator_transformers.go +++ b/go/vt/vtgate/planbuilder/operator_transformers.go @@ -355,10 +355,10 @@ func transformProjection(ctx *plancontext.PlanningContext, op *operators.Project return nil, err } - if cols := op.AllOffsets(); cols != nil { + if cols, colNames := op.AllOffsets(); cols != nil { // if all this op is doing is passing through columns from the input, we // can use the faster SimpleProjection - return useSimpleProjection(ctx, op, cols, src) + return useSimpleProjection(ctx, op, cols, colNames, src) } ap, err := op.GetAliasedProjections() @@ -403,7 +403,7 @@ func getEvalEngingeExpr(ctx *plancontext.PlanningContext, pe *operators.ProjExpr // useSimpleProjection uses nothing at all if the output is already correct, // or SimpleProjection when we have to reorder or truncate the columns -func useSimpleProjection(ctx *plancontext.PlanningContext, op *operators.Projection, cols []int, src logicalPlan) (logicalPlan, error) { +func useSimpleProjection(ctx *plancontext.PlanningContext, op *operators.Projection, cols []int, colNames []string, src logicalPlan) (logicalPlan, error) { columns := op.Source.GetColumns(ctx) if len(columns) == len(cols) && elementsMatchIndices(cols) { // the columns are already in the right order. we don't need anything at all here @@ -412,7 +412,8 @@ func useSimpleProjection(ctx *plancontext.PlanningContext, op *operators.Project return &simpleProjection{ logicalPlanCommon: newBuilderCommon(src), eSimpleProj: &engine.SimpleProjection{ - Cols: cols, + Cols: cols, + ColNames: colNames, }, }, nil } diff --git a/go/vt/vtgate/planbuilder/operators/projection.go b/go/vt/vtgate/planbuilder/operators/projection.go index 1eae4e0e06e..f3604a30620 100644 --- a/go/vt/vtgate/planbuilder/operators/projection.go +++ b/go/vt/vtgate/planbuilder/operators/projection.go @@ -399,18 +399,23 @@ func (p *Projection) GetOrdering(ctx *plancontext.PlanningContext) []OrderBy { // AllOffsets returns a slice of integer offsets for all columns in the Projection // if all columns are of type Offset. If any column is not of type Offset, it returns nil. -func (p *Projection) AllOffsets() (cols []int) { +func (p *Projection) AllOffsets() (cols []int, colNames []string) { ap, err := p.GetAliasedProjections() if err != nil { - return nil + return nil, nil } for _, c := range ap { offset, ok := c.Info.(Offset) if !ok { - return nil + return nil, nil + } + colName := "" + if c.Original.As.NotEmpty() { + colName = c.Original.As.String() } cols = append(cols, int(offset)) + colNames = append(colNames, colName) } return } @@ -445,7 +450,7 @@ func (p *Projection) Compact(ctx *plancontext.PlanningContext) (Operator, *Apply needed := false for i, projection := range ap { e, ok := projection.Info.(Offset) - if !ok || int(e) != i { + if !ok || int(e) != i || projection.Original.As.NotEmpty() { needed = true break } @@ -475,6 +480,9 @@ func (p *Projection) compactWithJoin(ctx *plancontext.PlanningContext, join *App for _, col := range ap { switch colInfo := col.Info.(type) { case Offset: + if col.Original.As.NotEmpty() { + return p, NoRewrite + } newColumns = append(newColumns, join.Columns[colInfo]) newColumnsAST.add(join.JoinColumns.columns[colInfo]) case nil: diff --git a/go/vt/vtgate/planbuilder/testdata/ddl_cases_no_default_keyspace.json b/go/vt/vtgate/planbuilder/testdata/ddl_cases_no_default_keyspace.json index f9943319c2d..343b8d78b14 100644 --- a/go/vt/vtgate/planbuilder/testdata/ddl_cases_no_default_keyspace.json +++ b/go/vt/vtgate/planbuilder/testdata/ddl_cases_no_default_keyspace.json @@ -144,7 +144,7 @@ "Name": "user", "Sharded": true }, - "Query": "create view view_a as select a.user_id as user_id, a.col1 as col1, a.col2 as col2, b.user_id as user_id, b.col1 as col1, b.col2 as col2 from authoritative as a join authoritative as b on a.user_id = b.user_id" + "Query": "create view view_a as select a.user_id, a.col1, a.col2, b.user_id, b.col1, b.col2 from authoritative as a join authoritative as b on a.user_id = b.user_id" }, "TablesUsed": [ "user.view_a" @@ -201,7 +201,7 @@ "Name": "user", "Sharded": true }, - "Query": "create view view_a as select `user`.id, a.user_id as user_id, a.col1 as col1, a.col2 as col2, `user`.col1 from authoritative as a join `user` on a.user_id = `user`.id" + "Query": "create view view_a as select `user`.id, a.user_id, a.col1, a.col2, `user`.col1 from authoritative as a join `user` on a.user_id = `user`.id" }, "TablesUsed": [ "user.view_a" diff --git a/go/vt/vtgate/planbuilder/testdata/from_cases.json b/go/vt/vtgate/planbuilder/testdata/from_cases.json index 044036a4590..b8292888161 100644 --- a/go/vt/vtgate/planbuilder/testdata/from_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/from_cases.json @@ -3760,8 +3760,8 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select authoritative.col1 as col1, authoritative.user_id as user_id, authoritative.col2 as col2 from authoritative where 1 != 1", - "Query": "select authoritative.col1 as col1, authoritative.user_id as user_id, authoritative.col2 as col2 from authoritative", + "FieldQuery": "select authoritative.col1, authoritative.user_id, authoritative.col2 from authoritative where 1 != 1", + "Query": "select authoritative.col1, authoritative.user_id, authoritative.col2 from authoritative", "Table": "authoritative" }, { @@ -3771,8 +3771,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select unsharded_authoritative.col2 as col2 from unsharded_authoritative where 1 != 1", - "Query": "select unsharded_authoritative.col2 as col2 from unsharded_authoritative where unsharded_authoritative.col1 = :authoritative_col1", + "FieldQuery": "select unsharded_authoritative.col2 from unsharded_authoritative where 1 != 1", + "Query": "select unsharded_authoritative.col2 from unsharded_authoritative where unsharded_authoritative.col1 = :authoritative_col1", "Table": "unsharded_authoritative" } ] diff --git a/go/vt/vtgate/planbuilder/testdata/info_schema57_cases.json b/go/vt/vtgate/planbuilder/testdata/info_schema57_cases.json index 84b6f551b73..1727e372490 100644 --- a/go/vt/vtgate/planbuilder/testdata/info_schema57_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/info_schema57_cases.json @@ -750,8 +750,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select a.VARIABLE_NAME as VARIABLE_NAME, a.VARIABLE_VALUE as VARIABLE_VALUE, b.CHARACTER_SET_NAME as CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME as DEFAULT_COLLATE_NAME, b.DESCRIPTION as DESCRIPTION, b.MAXLEN as MAXLEN from information_schema.GLOBAL_STATUS as a, information_schema.CHARACTER_SETS as b where 1 != 1", - "Query": "select a.VARIABLE_NAME as VARIABLE_NAME, a.VARIABLE_VALUE as VARIABLE_VALUE, b.CHARACTER_SET_NAME as CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME as DEFAULT_COLLATE_NAME, b.DESCRIPTION as DESCRIPTION, b.MAXLEN as MAXLEN from information_schema.GLOBAL_STATUS as a, information_schema.CHARACTER_SETS as b", + "FieldQuery": "select a.VARIABLE_NAME, a.VARIABLE_VALUE, b.CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME, b.DESCRIPTION, b.MAXLEN from information_schema.GLOBAL_STATUS as a, information_schema.CHARACTER_SETS as b where 1 != 1", + "Query": "select a.VARIABLE_NAME, a.VARIABLE_VALUE, b.CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME, b.DESCRIPTION, b.MAXLEN from information_schema.GLOBAL_STATUS as a, information_schema.CHARACTER_SETS as b", "Table": "information_schema.CHARACTER_SETS, information_schema.GLOBAL_STATUS" } } diff --git a/go/vt/vtgate/planbuilder/testdata/info_schema80_cases.json b/go/vt/vtgate/planbuilder/testdata/info_schema80_cases.json index ce870bf2437..c951b70a8d0 100644 --- a/go/vt/vtgate/planbuilder/testdata/info_schema80_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/info_schema80_cases.json @@ -815,8 +815,8 @@ "Name": "main", "Sharded": false }, - "FieldQuery": "select a.CONSTRAINT_CATALOG as CONSTRAINT_CATALOG, a.CONSTRAINT_SCHEMA as CONSTRAINT_SCHEMA, a.CONSTRAINT_NAME as CONSTRAINT_NAME, a.CHECK_CLAUSE as CHECK_CLAUSE, b.CHARACTER_SET_NAME as CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME as DEFAULT_COLLATE_NAME, b.DESCRIPTION as DESCRIPTION, b.MAXLEN as MAXLEN from information_schema.CHECK_CONSTRAINTS as a, information_schema.CHARACTER_SETS as b where 1 != 1", - "Query": "select a.CONSTRAINT_CATALOG as CONSTRAINT_CATALOG, a.CONSTRAINT_SCHEMA as CONSTRAINT_SCHEMA, a.CONSTRAINT_NAME as CONSTRAINT_NAME, a.CHECK_CLAUSE as CHECK_CLAUSE, b.CHARACTER_SET_NAME as CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME as DEFAULT_COLLATE_NAME, b.DESCRIPTION as DESCRIPTION, b.MAXLEN as MAXLEN from information_schema.CHECK_CONSTRAINTS as a, information_schema.CHARACTER_SETS as b", + "FieldQuery": "select a.CONSTRAINT_CATALOG, a.CONSTRAINT_SCHEMA, a.CONSTRAINT_NAME, a.CHECK_CLAUSE, b.CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME, b.DESCRIPTION, b.MAXLEN from information_schema.CHECK_CONSTRAINTS as a, information_schema.CHARACTER_SETS as b where 1 != 1", + "Query": "select a.CONSTRAINT_CATALOG, a.CONSTRAINT_SCHEMA, a.CONSTRAINT_NAME, a.CHECK_CLAUSE, b.CHARACTER_SET_NAME, b.DEFAULT_COLLATE_NAME, b.DESCRIPTION, b.MAXLEN from information_schema.CHECK_CONSTRAINTS as a, information_schema.CHARACTER_SETS as b", "Table": "information_schema.CHARACTER_SETS, information_schema.CHECK_CONSTRAINTS" } } diff --git a/go/vt/vtgate/planbuilder/testdata/rails_cases.json b/go/vt/vtgate/planbuilder/testdata/rails_cases.json index ef36b79c855..c8ab8b7b9d8 100644 --- a/go/vt/vtgate/planbuilder/testdata/rails_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/rails_cases.json @@ -50,8 +50,8 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select author5s.id as id, author5s.`name` as `name`, author5s.created_at as created_at, author5s.updated_at as updated_at, book6s.supplier5_id, book6s.id from author5s, book6s where 1 != 1", - "Query": "select author5s.id as id, author5s.`name` as `name`, author5s.created_at as created_at, author5s.updated_at as updated_at, book6s.supplier5_id, book6s.id from author5s, book6s where book6s.author5_id = author5s.id", + "FieldQuery": "select author5s.id, author5s.`name`, author5s.created_at, author5s.updated_at, book6s.supplier5_id, book6s.id from author5s, book6s where 1 != 1", + "Query": "select author5s.id, author5s.`name`, author5s.created_at, author5s.updated_at, book6s.supplier5_id, book6s.id from author5s, book6s where book6s.author5_id = author5s.id", "Table": "author5s, book6s" }, { diff --git a/go/vt/vtgate/planbuilder/testdata/select_cases.json b/go/vt/vtgate/planbuilder/testdata/select_cases.json index 4a5f85b249d..e5e28415256 100644 --- a/go/vt/vtgate/planbuilder/testdata/select_cases.json +++ b/go/vt/vtgate/planbuilder/testdata/select_cases.json @@ -361,8 +361,8 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select a.user_id as user_id, a.col1 as col1, a.col2 as col2, b.user_id as user_id, b.col1 as col1, b.col2 as col2 from authoritative as a, authoritative as b where 1 != 1", - "Query": "select a.user_id as user_id, a.col1 as col1, a.col2 as col2, b.user_id as user_id, b.col1 as col1, b.col2 as col2 from authoritative as a, authoritative as b where a.user_id = b.user_id", + "FieldQuery": "select a.user_id, a.col1, a.col2, b.user_id, b.col1, b.col2 from authoritative as a, authoritative as b where 1 != 1", + "Query": "select a.user_id, a.col1, a.col2, b.user_id, b.col1, b.col2 from authoritative as a, authoritative as b where a.user_id = b.user_id", "Table": "authoritative" }, "TablesUsed": [ @@ -433,8 +433,8 @@ "Name": "user", "Sharded": true }, - "FieldQuery": "select `user`.id, a.user_id as user_id, a.col1 as col1, a.col2 as col2, `user`.col1 from authoritative as a, `user` where 1 != 1", - "Query": "select `user`.id, a.user_id as user_id, a.col1 as col1, a.col2 as col2, `user`.col1 from authoritative as a, `user` where a.user_id = `user`.id", + "FieldQuery": "select `user`.id, a.user_id, a.col1, a.col2, `user`.col1 from authoritative as a, `user` where 1 != 1", + "Query": "select `user`.id, a.user_id, a.col1, a.col2, `user`.col1 from authoritative as a, `user` where a.user_id = `user`.id", "Table": "`user`, authoritative" }, "TablesUsed": [ @@ -4997,5 +4997,63 @@ "user.user" ] } + }, + { + "comment": "column name aliases in outer join queries", + "query": "select name as t0, name as t1 from user left outer join user_extra on user.cola = user_extra.cola", + "plan": { + "QueryType": "SELECT", + "Original": "select name as t0, name as t1 from user left outer join user_extra on user.cola = user_extra.cola", + "Instructions": { + "OperatorType": "SimpleProjection", + "ColumnNames": [ + "t0", + "t1" + ], + "Columns": [ + 0, + 0 + ], + "Inputs": [ + { + "OperatorType": "Join", + "Variant": "LeftJoin", + "JoinColumnIndexes": "L:0", + "JoinVars": { + "user_cola": 1 + }, + "TableName": "`user`_user_extra", + "Inputs": [ + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select `name`, `user`.cola from `user` where 1 != 1", + "Query": "select `name`, `user`.cola from `user`", + "Table": "`user`" + }, + { + "OperatorType": "Route", + "Variant": "Scatter", + "Keyspace": { + "Name": "user", + "Sharded": true + }, + "FieldQuery": "select 1 from user_extra where 1 != 1", + "Query": "select 1 from user_extra where user_extra.cola = :user_cola", + "Table": "user_extra" + } + ] + } + ] + }, + "TablesUsed": [ + "user.user", + "user.user_extra" + ] + } } ] diff --git a/go/vt/vtgate/semantics/early_rewriter.go b/go/vt/vtgate/semantics/early_rewriter.go index db3c8cff396..16ffc9ee019 100644 --- a/go/vt/vtgate/semantics/early_rewriter.go +++ b/go/vt/vtgate/semantics/early_rewriter.go @@ -1237,17 +1237,13 @@ type expanderState struct { // addColumn adds columns to the expander state. If we have vschema info about the query, // we also store which columns were expanded func (e *expanderState) addColumn(col ColumnInfo, tbl TableInfo, tblName sqlparser.TableName) { - withQualifier := e.needsQualifier var colName *sqlparser.ColName var alias sqlparser.IdentifierCI - if withQualifier { + if e.needsQualifier { colName = sqlparser.NewColNameWithQualifier(col.Name, tblName) } else { colName = sqlparser.NewColName(col.Name) } - if e.needsQualifier { - alias = sqlparser.NewIdentifierCI(col.Name) - } e.colNames = append(e.colNames, &sqlparser.AliasedExpr{Expr: colName, As: alias}) e.storeExpandInfo(tbl, tblName, colName) } diff --git a/go/vt/vtgate/semantics/early_rewriter_test.go b/go/vt/vtgate/semantics/early_rewriter_test.go index a5c16ba6b78..c44d6f6307d 100644 --- a/go/vt/vtgate/semantics/early_rewriter_test.go +++ b/go/vt/vtgate/semantics/early_rewriter_test.go @@ -122,17 +122,17 @@ func TestExpandStar(t *testing.T) { expSQL: "select 42, a, b, c from t1", }, { sql: "select * from t1, t2", - expSQL: "select t1.a as a, t1.b as b, t1.c as c, t2.c1 as c1, t2.c2 as c2 from t1, t2", + expSQL: "select t1.a, t1.b, t1.c, t2.c1, t2.c2 from t1, t2", expanded: "main.t1.a, main.t1.b, main.t1.c, main.t2.c1, main.t2.c2", }, { sql: "select t1.* from t1, t2", - expSQL: "select t1.a as a, t1.b as b, t1.c as c from t1, t2", + expSQL: "select t1.a, t1.b, t1.c from t1, t2", }, { sql: "select *, t1.* from t1, t2", - expSQL: "select t1.a as a, t1.b as b, t1.c as c, t2.c1 as c1, t2.c2 as c2, t1.a as a, t1.b as b, t1.c as c from t1, t2", + expSQL: "select t1.a, t1.b, t1.c, t2.c1, t2.c2, t1.a, t1.b, t1.c from t1, t2", }, { // aliased table sql: "select * from t1 a, t2 b", - expSQL: "select a.a as a, a.b as b, a.c as c, b.c1 as c1, b.c2 as c2 from t1 as a, t2 as b", + expSQL: "select a.a, a.b, a.c, b.c1, b.c2 from t1 as a, t2 as b", }, { // t3 is non-authoritative table sql: "select * from t3", expSQL: "select * from t3", @@ -141,36 +141,36 @@ func TestExpandStar(t *testing.T) { expSQL: "select * from t1, t2, t3", }, { // t3 is non-authoritative table sql: "select t1.*, t2.*, t3.* from t1, t2, t3", - expSQL: "select t1.a as a, t1.b as b, t1.c as c, t2.c1 as c1, t2.c2 as c2, t3.* from t1, t2, t3", + expSQL: "select t1.a, t1.b, t1.c, t2.c1, t2.c2, t3.* from t1, t2, t3", }, { sql: "select foo.* from t1, t2", expErr: "Unknown table 'foo'", }, { sql: "select * from t1 join t2 on t1.a = t2.c1", - expSQL: "select t1.a as a, t1.b as b, t1.c as c, t2.c1 as c1, t2.c2 as c2 from t1 join t2 on t1.a = t2.c1", + expSQL: "select t1.a, t1.b, t1.c, t2.c1, t2.c2 from t1 join t2 on t1.a = t2.c1", }, { sql: "select * from t1 left join t2 on t1.a = t2.c1", - expSQL: "select t1.a as a, t1.b as b, t1.c as c, t2.c1 as c1, t2.c2 as c2 from t1 left join t2 on t1.a = t2.c1", + expSQL: "select t1.a, t1.b, t1.c, t2.c1, t2.c2 from t1 left join t2 on t1.a = t2.c1", }, { sql: "select * from t1 right join t2 on t1.a = t2.c1", - expSQL: "select t1.a as a, t1.b as b, t1.c as c, t2.c1 as c1, t2.c2 as c2 from t1 right join t2 on t1.a = t2.c1", + expSQL: "select t1.a, t1.b, t1.c, t2.c1, t2.c2 from t1 right join t2 on t1.a = t2.c1", }, { sql: "select * from t2 join t4 using (c1)", - expSQL: "select t2.c1 as c1, t2.c2 as c2, t4.c4 as c4 from t2 join t4 on t2.c1 = t4.c1", + expSQL: "select t2.c1, t2.c2, t4.c4 from t2 join t4 on t2.c1 = t4.c1", expanded: "main.t2.c1, main.t2.c2, main.t4.c4", }, { sql: "select * from t2 join t4 using (c1) join t2 as X using (c1)", - expSQL: "select t2.c1 as c1, t2.c2 as c2, t4.c4 as c4, X.c2 as c2 from t2 join t4 on t2.c1 = t4.c1 join t2 as X on t2.c1 = t4.c1 and t2.c1 = X.c1 and t4.c1 = X.c1", + expSQL: "select t2.c1, t2.c2, t4.c4, X.c2 from t2 join t4 on t2.c1 = t4.c1 join t2 as X on t2.c1 = t4.c1 and t2.c1 = X.c1 and t4.c1 = X.c1", }, { sql: "select * from t2 join t4 using (c1), t2 as t2b join t4 as t4b using (c1)", - expSQL: "select t2.c1 as c1, t2.c2 as c2, t4.c4 as c4, t2b.c1 as c1, t2b.c2 as c2, t4b.c4 as c4 from t2 join t4 on t2.c1 = t4.c1, t2 as t2b join t4 as t4b on t2b.c1 = t4b.c1", + expSQL: "select t2.c1, t2.c2, t4.c4, t2b.c1, t2b.c2, t4b.c4 from t2 join t4 on t2.c1 = t4.c1, t2 as t2b join t4 as t4b on t2b.c1 = t4b.c1", }, { sql: "select * from t1 join t5 using (b)", - expSQL: "select t1.b as b, t1.a as a, t1.c as c, t5.a as a from t1 join t5 on t1.b = t5.b", + expSQL: "select t1.b, t1.a, t1.c, t5.a from t1 join t5 on t1.b = t5.b", expanded: "main.t1.a, main.t1.b, main.t1.c, main.t5.a", }, { sql: "select * from t1 join t5 using (b) having b = 12", - expSQL: "select t1.b as b, t1.a as a, t1.c as c, t5.a as a from t1 join t5 on t1.b = t5.b having t1.b = 12", + expSQL: "select t1.b, t1.a, t1.c, t5.a from t1 join t5 on t1.b = t5.b having t1.b = 12", }, { sql: "select 1 from t1 join t5 using (b) where b = 12", expSQL: "select 1 from t1 join t5 on t1.b = t5.b where t1.b = 12", @@ -183,7 +183,7 @@ func TestExpandStar(t *testing.T) { }, { // if we are only star-expanding authoritative tables, we don't need to stop the expansion sql: "SELECT * FROM (SELECT t2.*, 12 AS foo FROM t3, t2) as results", - expSQL: "select c1, c2, foo from (select t2.c1 as c1, t2.c2 as c2, 12 as foo from t3, t2) as results", + expSQL: "select c1, c2, foo from (select t2.c1, t2.c2, 12 as foo from t3, t2) as results", }} for _, tcase := range tcases { t.Run(tcase.sql, func(t *testing.T) { @@ -761,11 +761,11 @@ func TestSemTableDependenciesAfterExpandStar(t *testing.T) { otherTbl: -1, sameTbl: 0, expandedCol: 1, }, { sql: "select t2.a, t1.a, t1.* from t1, t2", - expSQL: "select t2.a, t1.a, t1.a as a from t1, t2", + expSQL: "select t2.a, t1.a, t1.a from t1, t2", otherTbl: 0, sameTbl: 1, expandedCol: 2, }, { sql: "select t2.a, t.a, t.* from t1 t, t2", - expSQL: "select t2.a, t.a, t.a as a from t1 as t, t2", + expSQL: "select t2.a, t.a, t.a from t1 as t, t2", otherTbl: 0, sameTbl: 1, expandedCol: 2, }} for _, tcase := range tcases { From 9d861f8b991fb674034a6e0cf0366fb272ef2c08 Mon Sep 17 00:00:00 2001 From: Noble Mittal <62551163+beingnoble03@users.noreply.github.com> Date: Tue, 5 Mar 2024 09:42:44 +0530 Subject: [PATCH 75/79] Add required tests for `internal/flag` (#15220) Signed-off-by: Noble Mittal --- go/internal/flag/flag_test.go | 298 +++++++++++++++++++++++++++++++++ go/internal/flag/usage_test.go | 121 +++++++++++++ 2 files changed, 419 insertions(+) create mode 100644 go/internal/flag/flag_test.go create mode 100644 go/internal/flag/usage_test.go diff --git a/go/internal/flag/flag_test.go b/go/internal/flag/flag_test.go new file mode 100644 index 00000000000..1f1ff5dc5ec --- /dev/null +++ b/go/internal/flag/flag_test.go @@ -0,0 +1,298 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package flag + +import ( + goflag "flag" + "os" + "testing" + + "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" +) + +func TestPreventGlogVFlagFromClobberingVersionFlagShorthand(t *testing.T) { + oldCommandLine := goflag.CommandLine + defer func() { + goflag.CommandLine = oldCommandLine + }() + + goflag.CommandLine = goflag.NewFlagSet(os.Args[0], goflag.ExitOnError) + + var v bool + + goflag.BoolVar(&v, "v", true, "") + + testFlagSet := pflag.NewFlagSet("testFlagSet", pflag.ExitOnError) + PreventGlogVFlagFromClobberingVersionFlagShorthand(testFlagSet) + + f := testFlagSet.Lookup("v") + assert.NotNil(t, f) + assert.Equal(t, "", f.Shorthand) + + // The function should not panic if -v flag is already defined + assert.NotPanics(t, func() { PreventGlogVFlagFromClobberingVersionFlagShorthand(testFlagSet) }) +} + +func TestParse(t *testing.T) { + oldCommandLine := goflag.CommandLine + defer func() { + goflag.CommandLine = oldCommandLine + }() + + var testFlag bool + goflag.CommandLine = goflag.NewFlagSet(os.Args[0], goflag.ExitOnError) + goflag.BoolVar(&testFlag, "testFlag", true, "") + + testFlagSet := pflag.NewFlagSet("testFlagSet", pflag.ExitOnError) + + Parse(testFlagSet) + + f := testFlagSet.ShorthandLookup("h") + assert.NotNil(t, f) + assert.Equal(t, "false", f.DefValue) + + f = testFlagSet.Lookup("help") + assert.NotNil(t, f) + assert.Equal(t, "false", f.DefValue) + + testFlagSet = pflag.NewFlagSet("testFlagSet2", pflag.ExitOnError) + + // If shorthand "h" is already defined, shorthand for "help" should be empty + var h bool + testFlagSet.BoolVarP(&h, "testH", "h", false, "") + + Parse(testFlagSet) + f = testFlagSet.Lookup("help") + assert.NotNil(t, f) + assert.Equal(t, "", f.Shorthand) + + // Check if AddGoFlagSet was called + f = testFlagSet.Lookup("testFlag") + assert.NotNil(t, f) + assert.Equal(t, "true", f.DefValue) +} + +func TestIsFlagProvided(t *testing.T) { + oldPflagCommandLine := pflag.CommandLine + defer func() { + pflag.CommandLine = oldPflagCommandLine + }() + + pflag.CommandLine = pflag.NewFlagSet("testFlagSet", pflag.ExitOnError) + + flagName := "testFlag" + isProvided := IsFlagProvided(flagName) + assert.False(t, isProvided, "flag %q should not exist", flagName) + + var testFlag bool + pflag.BoolVar(&testFlag, flagName, false, "") + + // Should return false as testFlag is not set + isProvided = IsFlagProvided(flagName) + assert.False(t, isProvided, "flag %q should not be provided", flagName) + + pflag.Parse() + _ = pflag.Set(flagName, "true") + + // Should return true as testFlag is set + isProvided = IsFlagProvided(flagName) + assert.True(t, isProvided, "flag %q should be provided", flagName) +} + +func TestFilterTestFlags(t *testing.T) { + oldOsArgs := os.Args + defer func() { + os.Args = oldOsArgs + }() + + os.Args = []string{ + "-test.run", + "TestFilter", + "otherArgs1", + "otherArgs2", + "-test.run=TestFilter", + } + + otherArgs, testFlags := filterTestFlags() + + expectedTestFlags := []string{ + "-test.run", + "TestFilter", + "-test.run=TestFilter", + } + expectedOtherArgs := []string{ + "otherArgs1", + "otherArgs2", + } + + assert.Equal(t, expectedOtherArgs, otherArgs) + assert.Equal(t, expectedTestFlags, testFlags) +} + +func TestParseFlagsForTest(t *testing.T) { + oldOsArgs := os.Args + oldPflagCommandLine := pflag.CommandLine + oldCommandLine := goflag.CommandLine + + defer func() { + os.Args = oldOsArgs + pflag.CommandLine = oldPflagCommandLine + goflag.CommandLine = oldCommandLine + }() + + pflag.CommandLine = pflag.NewFlagSet("testFlagSet", pflag.ExitOnError) + + os.Args = []string{ + "-test.run", + "TestFilter", + "otherArgs1", + "otherArgs2", + "-test.run=TestFilter", + } + + ParseFlagsForTest() + + expectedOsArgs := []string{ + "otherArgs1", + "otherArgs2", + } + + assert.Equal(t, expectedOsArgs, os.Args) + assert.Equal(t, true, pflag.Parsed()) +} + +func TestParsed(t *testing.T) { + oldPflagCommandLine := pflag.CommandLine + oldCommandLine := goflag.CommandLine + + defer func() { + pflag.CommandLine = oldPflagCommandLine + goflag.CommandLine = oldCommandLine + }() + + pflag.CommandLine = pflag.NewFlagSet("testPflagSet", pflag.ExitOnError) + goflag.CommandLine = goflag.NewFlagSet("testGoflagSet", goflag.ExitOnError) + + b := Parsed() + assert.False(t, b, "command-line flags should not be parsed") + + pflag.Parse() + b = Parsed() + assert.True(t, b, "command-line flags should be parsed") +} + +func TestLookup(t *testing.T) { + oldPflagCommandLine := pflag.CommandLine + oldCommandLine := goflag.CommandLine + + defer func() { + pflag.CommandLine = oldPflagCommandLine + goflag.CommandLine = oldCommandLine + }() + + pflag.CommandLine = pflag.NewFlagSet("testPflagSet", pflag.ExitOnError) + goflag.CommandLine = goflag.NewFlagSet("testGoflagSet", goflag.ExitOnError) + + var testGoFlag, testPflag, testFlag bool + + goflag.BoolVar(&testGoFlag, "testGoFlag", true, "") + goflag.BoolVar(&testFlag, "t", true, "") + pflag.BoolVar(&testPflag, "testPflag", true, "") + + testCases := []struct { + shorthand string + name string + }{ + { + // If single character flag is passed, the shorthand should be the same + shorthand: "t", + name: "t", + }, + { + shorthand: "", + name: "testGoFlag", + }, + { + shorthand: "", + name: "testPflag", + }, + } + + for _, tt := range testCases { + f := Lookup(tt.name) + + assert.NotNil(t, f) + assert.Equal(t, tt.shorthand, f.Shorthand) + assert.Equal(t, tt.name, f.Name) + } + + f := Lookup("non-existent-flag") + assert.Nil(t, f) +} + +func TestArgs(t *testing.T) { + oldPflagCommandLine := pflag.CommandLine + oldOsArgs := os.Args + + defer func() { + pflag.CommandLine = oldPflagCommandLine + os.Args = oldOsArgs + }() + + pflag.CommandLine = pflag.NewFlagSet("testPflagSet", pflag.ExitOnError) + + os.Args = []string{ + "arg0", + "arg1", + "arg2", + "arg3", + } + + expectedArgs := []string{ + "arg1", + "arg2", + "arg3", + } + + pflag.Parse() + // Should work equivalent to pflag.Args if there's no double dash + args := Args() + assert.Equal(t, expectedArgs, args) + + arg := Arg(2) + assert.Equal(t, "arg3", arg) + + // Should return empty string if the index is greater than len of CommandLine.args + arg = Arg(3) + assert.Equal(t, "", arg) +} + +func TestIsZeroValue(t *testing.T) { + var testFlag string + + testFlagSet := goflag.NewFlagSet("testFlagSet", goflag.ExitOnError) + testFlagSet.StringVar(&testFlag, "testflag", "default", "Description of testflag") + + f := testFlagSet.Lookup("testflag") + + result := isZeroValue(f, "") + assert.True(t, result, "empty string should represent zero value for string flag") + + result = isZeroValue(f, "anyValue") + assert.False(t, result, "non-empty string should not represent zero value for string flag") +} diff --git a/go/internal/flag/usage_test.go b/go/internal/flag/usage_test.go new file mode 100644 index 00000000000..461cd2580ea --- /dev/null +++ b/go/internal/flag/usage_test.go @@ -0,0 +1,121 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package flag + +import ( + goflag "flag" + "io" + "os" + "strings" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSetUsage(t *testing.T) { + fs := goflag.NewFlagSet("test", goflag.ExitOnError) + fs.String("testflag", "default", "`test` flag") + + opts := UsageOptions{ + Preface: func(w io.Writer) { + _, _ = w.Write([]byte("test preface")) + }, + Epilogue: func(w io.Writer) { + _, _ = w.Write([]byte("test epilogue")) + }, + FlagFilter: func(f *goflag.Flag) bool { + return f.Value.String() == "default" + }, + } + + SetUsage(fs, opts) + + var builder strings.Builder + fs.SetOutput(&builder) + + _ = fs.Set("testflag", "not default") + fs.Usage() + + output := builder.String() + assert.NotContains(t, output, "test flag") + + // Set the value back to default + _ = fs.Set("testflag", "default") + fs.Usage() + output = builder.String() + + assert.Contains(t, output, "test preface") + assert.Contains(t, output, "--testflag test") + assert.Contains(t, output, "test epilogue") + assert.Contains(t, output, "test flag") +} + +func TestSetUsageWithNilFlagFilterAndPreface(t *testing.T) { + oldOsArgs := os.Args + defer func() { + os.Args = oldOsArgs + }() + + os.Args = []string{"testOsArg"} + fs := goflag.NewFlagSet("test", goflag.ExitOnError) + fs.String("testflag", "default", "`test` flag") + + opts := UsageOptions{ + Epilogue: func(w io.Writer) { + _, _ = w.Write([]byte("test epilogue")) + }, + } + + SetUsage(fs, opts) + + var builder strings.Builder + fs.SetOutput(&builder) + fs.Usage() + output := builder.String() + + assert.Contains(t, output, "Usage of testOsArg:") + assert.Contains(t, output, "--testflag test") + assert.Contains(t, output, "test epilogue") +} + +func TestSetUsageWithBoolFlag(t *testing.T) { + fs := goflag.NewFlagSet("test2", goflag.ExitOnError) + var tBool bool + fs.BoolVar(&tBool, "t", true, "`t` flag") + + opts := UsageOptions{ + Preface: func(w io.Writer) { + _, _ = w.Write([]byte("test preface")) + }, + Epilogue: func(w io.Writer) { + _, _ = w.Write([]byte("test epilogue")) + }, + FlagFilter: func(f *goflag.Flag) bool { + return f.Value.String() == "true" + }, + } + + SetUsage(fs, opts) + + var builder strings.Builder + fs.SetOutput(&builder) + fs.Usage() + output := builder.String() + + assert.Contains(t, output, "test preface") + assert.Contains(t, output, "-t\tt flag") +} From 171e305d73cf6670514dd392352bc9b5c7ac91f0 Mon Sep 17 00:00:00 2001 From: Noble Mittal <62551163+beingnoble03@users.noreply.github.com> Date: Tue, 5 Mar 2024 15:20:39 +0530 Subject: [PATCH 76/79] Add required tests for `go/netutil` (#15392) Signed-off-by: Noble Mittal --- go/netutil/conn_test.go | 70 +++++++++++++++++++++++++------------- go/netutil/netutil_test.go | 52 ++++++++++++++++++++-------- 2 files changed, 83 insertions(+), 39 deletions(-) diff --git a/go/netutil/conn_test.go b/go/netutil/conn_test.go index 78776035856..b27f81a6311 100644 --- a/go/netutil/conn_test.go +++ b/go/netutil/conn_test.go @@ -15,18 +15,17 @@ package netutil import ( "net" - "strings" "sync" "testing" "time" + + "github.com/stretchr/testify/assert" ) func createSocketPair(t *testing.T) (net.Listener, net.Conn, net.Conn) { // Create a listener. listener, err := net.Listen("tcp", "127.0.0.1:0") - if err != nil { - t.Fatalf("Listen failed: %v", err) - } + assert.NoError(t, err) addr := listener.Addr().String() // Dial a client, Accept a server. @@ -38,9 +37,7 @@ func createSocketPair(t *testing.T) (net.Listener, net.Conn, net.Conn) { defer wg.Done() var err error clientConn, err = net.Dial("tcp", addr) - if err != nil { - t.Errorf("Dial failed: %v", err) - } + assert.NoError(t, err) }() var serverConn net.Conn @@ -49,9 +46,7 @@ func createSocketPair(t *testing.T) (net.Listener, net.Conn, net.Conn) { defer wg.Done() var err error serverConn, err = listener.Accept() - if err != nil { - t.Errorf("Accept failed: %v", err) - } + assert.NoError(t, err) }() wg.Wait() @@ -77,13 +72,7 @@ func TestReadTimeout(t *testing.T) { select { case err := <-c: - if err == nil { - t.Fatalf("Expected error, got nil") - } - - if !strings.HasSuffix(err.Error(), "i/o timeout") { - t.Errorf("Expected error timeout, got %s", err) - } + assert.ErrorContains(t, err, "i/o timeout", "Expected error timeout") case <-time.After(10 * time.Second): t.Errorf("Timeout did not happen") } @@ -113,13 +102,7 @@ func TestWriteTimeout(t *testing.T) { select { case err := <-c: - if err == nil { - t.Fatalf("Expected error, got nil") - } - - if !strings.HasSuffix(err.Error(), "i/o timeout") { - t.Errorf("Expected error timeout, got %s", err) - } + assert.ErrorContains(t, err, "i/o timeout", "Expected error timeout") case <-time.After(10 * time.Second): t.Errorf("Timeout did not happen") } @@ -167,3 +150,42 @@ func TestNoTimeouts(t *testing.T) { // NOOP } } + +func TestSetDeadline(t *testing.T) { + listener, sConn, cConn := createSocketPair(t) + defer func() { + listener.Close() + sConn.Close() + cConn.Close() + }() + + cConnWithTimeout := NewConnWithTimeouts(cConn, 0, 24*time.Hour) + + assert.Panics(t, func() { _ = cConnWithTimeout.SetDeadline(time.Now()) }) +} + +func TestSetReadDeadline(t *testing.T) { + listener, sConn, cConn := createSocketPair(t) + defer func() { + listener.Close() + sConn.Close() + cConn.Close() + }() + + cConnWithTimeout := NewConnWithTimeouts(cConn, 0, 24*time.Hour) + + assert.Panics(t, func() { _ = cConnWithTimeout.SetReadDeadline(time.Now()) }) +} + +func TestSetWriteDeadline(t *testing.T) { + listener, sConn, cConn := createSocketPair(t) + defer func() { + listener.Close() + sConn.Close() + cConn.Close() + }() + + cConnWithTimeout := NewConnWithTimeouts(cConn, 0, 24*time.Hour) + + assert.Panics(t, func() { _ = cConnWithTimeout.SetWriteDeadline(time.Now()) }) +} diff --git a/go/netutil/netutil_test.go b/go/netutil/netutil_test.go index c0c0e16cfed..e5df2065033 100644 --- a/go/netutil/netutil_test.go +++ b/go/netutil/netutil_test.go @@ -17,7 +17,10 @@ limitations under the License. package netutil import ( + "net" "testing" + + "github.com/stretchr/testify/assert" ) func TestSplitHostPort(t *testing.T) { @@ -33,12 +36,9 @@ func TestSplitHostPort(t *testing.T) { } for input, want := range table { gotHost, gotPort, err := SplitHostPort(input) - if err != nil { - t.Errorf("SplitHostPort error: %v", err) - } - if gotHost != want.host || gotPort != want.port { - t.Errorf("SplitHostPort(%#v) = (%v, %v), want (%v, %v)", input, gotHost, gotPort, want.host, want.port) - } + assert.NoError(t, err) + assert.Equal(t, want.host, gotHost) + assert.Equal(t, want.port, gotPort) } } @@ -50,9 +50,7 @@ func TestSplitHostPortFail(t *testing.T) { } for _, input := range inputs { _, _, err := SplitHostPort(input) - if err == nil { - t.Errorf("expected error from SplitHostPort(%q), but got none", input) - } + assert.Error(t, err) } } @@ -66,9 +64,7 @@ func TestJoinHostPort(t *testing.T) { "[::1]:321": {host: "::1", port: 321}, } for want, input := range table { - if got := JoinHostPort(input.host, input.port); got != want { - t.Errorf("SplitHostPort(%v, %v) = %#v, want %#v", input.host, input.port, got, want) - } + assert.Equal(t, want, JoinHostPort(input.host, input.port)) } } @@ -83,8 +79,34 @@ func TestNormalizeIP(t *testing.T) { "127.": "127.", } for input, want := range table { - if got := NormalizeIP(input); got != want { - t.Errorf("NormalizeIP(%#v) = %#v, want %#v", input, got, want) - } + assert.Equal(t, want, NormalizeIP(input)) } } + +func TestDNSTracker(t *testing.T) { + refresh := DNSTracker("localhost") + _, err := refresh() + assert.NoError(t, err) + + refresh = DNSTracker("") + val, err := refresh() + assert.NoError(t, err) + assert.False(t, val, "DNS name resolution should not have changed") +} + +func TestAddrEqual(t *testing.T) { + addr1 := net.ParseIP("1.2.3.4") + addr2 := net.ParseIP("127.0.0.1") + + addrSet1 := []net.IP{addr1, addr2} + addrSet2 := []net.IP{addr1} + addrSet3 := []net.IP{addr2} + ok := addrEqual(addrSet1, addrSet2) + assert.False(t, ok, "addresses %q and %q should not be equal", addrSet1, addrSet2) + + ok = addrEqual(addrSet3, addrSet2) + assert.False(t, ok, "addresses %q and %q should not be equal", addrSet3, addrSet2) + + ok = addrEqual(addrSet1, addrSet1) + assert.True(t, ok, "addresses %q and %q should be equal", addrSet1, addrSet1) +} From 9be485fb0339c324824a6ed1fa98bbb79fd61c79 Mon Sep 17 00:00:00 2001 From: Maniaco <21123621+Its-Maniaco@users.noreply.github.com> Date: Tue, 5 Mar 2024 16:33:53 +0530 Subject: [PATCH 77/79] unit test for go/yaml2/yaml.go (#15027) Signed-off-by: Divya Pamecha <21123621+Its-Maniaco@users.noreply.github.com> Signed-off-by: Maniaco <21123621+Its-Maniaco@users.noreply.github.com> Signed-off-by: Manan Gupta Co-authored-by: Manan Gupta --- go/yaml2/yaml_test.go | 61 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 go/yaml2/yaml_test.go diff --git a/go/yaml2/yaml_test.go b/go/yaml2/yaml_test.go new file mode 100644 index 00000000000..6d6503711ca --- /dev/null +++ b/go/yaml2/yaml_test.go @@ -0,0 +1,61 @@ +/* +Copyright 2024 The Vitess Authors. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package yaml2 + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestYamlVars(t *testing.T) { + type TestStruct struct { + StringField string `yaml:"stringfield"` + IntField int `yaml:"intfield"` + BoolField bool `yaml:"boolfield"` + Float64Field float64 `yaml:"float64field"` + } + + inputData := TestStruct{ + "tricky text to test text", + 32, + true, + 3.141, + } + + //testing Marshal + var marshalData []byte + var err error + t.Run("Marshal", func(t *testing.T) { + marshalData, err = Marshal(inputData) + assert.NoError(t, err) + require.EqualValues(t, `BoolField: true +Float64Field: 3.141 +IntField: 32 +StringField: tricky text to test text +`, string(marshalData)) + }) + + //testing Unmarshal + t.Run("Unmarshal", func(t *testing.T) { + var unmarshalData TestStruct + err = Unmarshal(marshalData, &unmarshalData) + assert.NoError(t, err) + assert.Equal(t, inputData, unmarshalData) + + unmarshalData.StringField = "changed text" + assert.NotEqual(t, inputData, unmarshalData) + }) +} From 9a0073040d32d7fb5c0d7b3e62b359bd234bcda6 Mon Sep 17 00:00:00 2001 From: Vaibhav Malik <34866732+VaibhavMalik4187@users.noreply.github.com> Date: Tue, 5 Mar 2024 16:34:29 +0530 Subject: [PATCH 78/79] Added unit tests for cmd/internal/docgen package (#15019) Signed-off-by: VaibhavMalik4187 Signed-off-by: Manan Gupta Co-authored-by: Manan Gupta --- go/cmd/internal/docgen/docgen.go | 6 +- go/cmd/internal/docgen/docgen_test.go | 191 ++++++++++++++++++++++++++ 2 files changed, 194 insertions(+), 3 deletions(-) create mode 100644 go/cmd/internal/docgen/docgen_test.go diff --git a/go/cmd/internal/docgen/docgen.go b/go/cmd/internal/docgen/docgen.go index f52042e80af..eea935ed396 100644 --- a/go/cmd/internal/docgen/docgen.go +++ b/go/cmd/internal/docgen/docgen.go @@ -66,7 +66,7 @@ func GenerateMarkdownTree(cmd *cobra.Command, dir string) error { switch fi, err := os.Stat(dir); { case errors.Is(err, fs.ErrNotExist): if err := os.MkdirAll(dir, 0755); err != nil { - return err + return fmt.Errorf("failed to create \"%s\" directory: %w", dir, err) } case err != nil: return err @@ -194,7 +194,7 @@ func anonymizeHomedir(file string) (err error) { // We're replacing the stuff inside the square brackets in the example sed // below: // 's:Paths to search for config files in. (default \[.*\])$:Paths to search for config files in. (default \[\]):' - sed := exec.Command("sed", "-i", "", "-e", fmt.Sprintf("s:%s::i", wd), file) + sed := exec.Command("sed", "-i", "-e", fmt.Sprintf("s:%s::i", wd), file) if out, err := sed.CombinedOutput(); err != nil { return fmt.Errorf("%w: %s", err, out) } @@ -215,7 +215,7 @@ func getCommitID(ref string) (string, error) { gitShow := exec.Command("git", "show", "--pretty=format:%H", "--no-patch", ref) out, err := gitShow.Output() if err != nil { - return "", err + return "", fmt.Errorf("failed to get the commit id for reference \"%s\": %w", ref, err) } return string(out), nil diff --git a/go/cmd/internal/docgen/docgen_test.go b/go/cmd/internal/docgen/docgen_test.go new file mode 100644 index 00000000000..2370727cde5 --- /dev/null +++ b/go/cmd/internal/docgen/docgen_test.go @@ -0,0 +1,191 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package docgen + +import ( + "strings" + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/require" +) + +func TestGenerateMarkdownTree(t *testing.T) { + tests := []struct { + name string + dir string + cmd *cobra.Command + expectErr bool + }{ + { + name: "Empty dir", + dir: "", + cmd: &cobra.Command{}, + expectErr: true, + }, + { + name: "current dir", + dir: "./", + cmd: &cobra.Command{}, + expectErr: false, + }, + { + name: "Permission denied", + dir: "/root", + cmd: &cobra.Command{}, + expectErr: true, + }, + { + name: "Not a directory error", + dir: "./docgen.go", + cmd: &cobra.Command{}, + expectErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := GenerateMarkdownTree(tt.cmd, tt.dir) + if !tt.expectErr { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } +} + +func TestRestructure(t *testing.T) { + rootCmd := &cobra.Command{ + Use: "root-command", + } + cmd := &cobra.Command{ + Use: "random", + } + rootCmd.AddCommand(cmd) + cmds := []*cobra.Command{rootCmd} + + tests := []struct { + name string + rootDir string + dir string + cmds []*cobra.Command + expectErr bool + }{ + { + name: "Empty commands", + cmds: []*cobra.Command{}, + }, + { + name: "Non-empty commands", + rootDir: "../", + dir: "./", + cmds: cmds, + expectErr: true, + }, + { + name: "No subcommands", + rootDir: "../", + dir: "./", + cmds: []*cobra.Command{{Use: "help"}, {Use: "test-cmd"}}, + expectErr: true, + }, + { + name: "No subcommands with rootDir and dir unset", + cmds: []*cobra.Command{{Use: "random"}}, + expectErr: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := restructure(tt.rootDir, tt.dir, tt.name, tt.cmds) + if !tt.expectErr { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } +} + +func TestLinkHandler(t *testing.T) { + tests := []struct { + name string + fileName string + expectedStr string + }{ + { + name: "Normal value", + fileName: "Some_value", + expectedStr: "./some_value/", + }, + { + name: "Abnormal value", + fileName: `./.jash13_24`, + expectedStr: "../", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + str := linkHandler(tt.fileName) + require.Equal(t, tt.expectedStr, str) + }) + } +} + +func TestNewParentLinkSedCommand(t *testing.T) { + tests := []struct { + name string + parentDir string + fileName string + expectedOutput string + }{ + { + name: "Empty values", + expectedOutput: "sed -i -e s:(.//):(../):i ", + }, + { + name: "Normal value", + parentDir: "./", + fileName: "Some_value", + expectedOutput: "sed -i -e s:(././/):(../):i Some_value", + }, + { + name: "Abnormal value", + parentDir: "/root", + fileName: `./.jash13_24`, + expectedOutput: "sed -i -e s:(.//root/):(../):i ./.jash13_24", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cmd := newParentLinkSedCommand(tt.parentDir, tt.fileName) + // We only check for suffix because the sed command's actual path may differ on different machines. + require.True(t, strings.HasSuffix(cmd.String(), tt.expectedOutput)) + }) + } +} + +func TestGetCommitID(t *testing.T) { + // This function should return an error when the reference is not in the + // git tree. + _, err := getCommitID("invalid ref") + require.Error(t, err) +} From 9cd8ffcf4c7d7ef895ec58e4e64c9e51c894a988 Mon Sep 17 00:00:00 2001 From: Vaibhav Malik <34866732+VaibhavMalik4187@users.noreply.github.com> Date: Tue, 5 Mar 2024 18:30:00 +0530 Subject: [PATCH 79/79] Added unit tests for `go/cmd/rulesctl/` package (#15028) Signed-off-by: VaibhavMalik4187 Signed-off-by: Manan Gupta Co-authored-by: Manan Gupta --- go/cmd/rulesctl/cmd/add_test.go | 133 +++++++++++++++++++++ go/cmd/rulesctl/cmd/explain_test.go | 77 ++++++++++++ go/cmd/rulesctl/cmd/list_test.go | 103 ++++++++++++++++ go/cmd/rulesctl/cmd/main_test.go | 60 ++++++++++ go/cmd/rulesctl/cmd/remove_test.go | 114 ++++++++++++++++++ go/cmd/rulesctl/cmd/testdata/rules.json | 6 + go/cmd/rulesctl/common/common_test.go | 84 +++++++++++++ go/cmd/rulesctl/common/testdata/rules.json | 6 + 8 files changed, 583 insertions(+) create mode 100644 go/cmd/rulesctl/cmd/add_test.go create mode 100644 go/cmd/rulesctl/cmd/explain_test.go create mode 100644 go/cmd/rulesctl/cmd/list_test.go create mode 100644 go/cmd/rulesctl/cmd/main_test.go create mode 100644 go/cmd/rulesctl/cmd/remove_test.go create mode 100644 go/cmd/rulesctl/cmd/testdata/rules.json create mode 100644 go/cmd/rulesctl/common/common_test.go create mode 100644 go/cmd/rulesctl/common/testdata/rules.json diff --git a/go/cmd/rulesctl/cmd/add_test.go b/go/cmd/rulesctl/cmd/add_test.go new file mode 100644 index 00000000000..54c6623dab8 --- /dev/null +++ b/go/cmd/rulesctl/cmd/add_test.go @@ -0,0 +1,133 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "io" + "os" + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/require" +) + +func TestAdd(t *testing.T) { + cmd := Add() + require.NotNil(t, cmd) + require.Equal(t, "add-rule", cmd.Name()) + configFile = "./testdata/rules.json" + + tests := []struct { + name string + args []string + expectedOutput string + }{ + { + name: "Action fail", + args: []string{"--dry-run=true", "--name=Rule", `--description="New rules that will be added to the file"`, "--action=fail", "--plan=Select"}, + expectedOutput: `[ + { + "Description": "Some value", + "Name": "Name", + "Action": "FAIL" + }, + { + "Description": "\"New rules that will be added to the file\"", + "Name": "Rule", + "Plans": [ + "Select" + ], + "Action": "FAIL" + } +] +`, + }, + { + name: "Action fail_retry", + args: []string{"--dry-run=true", "--name=Rule", `--description="New rules that will be added to the file"`, "--action=fail_retry", "--plan=Select"}, + expectedOutput: `[ + { + "Description": "Some value", + "Name": "Name", + "Action": "FAIL" + }, + { + "Description": "\"New rules that will be added to the file\"", + "Name": "Rule", + "Plans": [ + "Select", + "Select" + ], + "Action": "FAIL_RETRY" + } +] +`, + }, + { + name: "Action continue with query", + args: []string{"--dry-run=true", "--name=Rule", `--description="New rules that will be added to the file"`, "--action=continue", "--plan=Select", "--query=secret", "--leading-comment=None", "--trailing-comment=Yoho", "--table=Temp"}, + expectedOutput: `[ + { + "Description": "Some value", + "Name": "Name", + "Action": "FAIL" + }, + { + "Description": "\"New rules that will be added to the file\"", + "Name": "Rule", + "Query": "secret", + "LeadingComment": "None", + "TrailingComment": "Yoho", + "Plans": [ + "Select", + "Select", + "Select" + ], + "TableNames": [ + "Temp" + ] + } +] +`, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.args != nil { + cmd.SetArgs(tt.args) + err := cmd.Execute() + require.NoError(t, err) + } + + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + + cmd.Run(&cobra.Command{}, []string{}) + + err := w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + require.EqualValues(t, tt.expectedOutput, string(got)) + }) + } +} diff --git a/go/cmd/rulesctl/cmd/explain_test.go b/go/cmd/rulesctl/cmd/explain_test.go new file mode 100644 index 00000000000..cc515a1eb3d --- /dev/null +++ b/go/cmd/rulesctl/cmd/explain_test.go @@ -0,0 +1,77 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "io" + "os" + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/require" +) + +func TestExplainWithQueryPlanArguement(t *testing.T) { + explainCmd := Explain() + + require.NotNil(t, explainCmd) + require.Equal(t, "explain", explainCmd.Name()) + + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + + explainCmd.Run(&cobra.Command{}, []string{"query-plans"}) + + err := w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + + expected := "Query Plans!" + require.Contains(t, string(got), expected) +} + +func TestExplainWithRandomArguement(t *testing.T) { + explainCmd := Explain() + + require.NotNil(t, explainCmd) + require.Equal(t, "explain", explainCmd.Name()) + + // Redirect stdout to a buffer + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + + explainCmd.Run(&cobra.Command{}, []string{"random"}) + + err := w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + + expected := "I don't know anything about" + require.Contains(t, string(got), expected) +} diff --git a/go/cmd/rulesctl/cmd/list_test.go b/go/cmd/rulesctl/cmd/list_test.go new file mode 100644 index 00000000000..d787481165e --- /dev/null +++ b/go/cmd/rulesctl/cmd/list_test.go @@ -0,0 +1,103 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "io" + "os" + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/require" +) + +func TestList(t *testing.T) { + cmd := List() + require.NotNil(t, cmd) + require.Equal(t, "list", cmd.Name()) + configFile = "./testdata/rules.json" + + tests := []struct { + name string + args []string + expectedOutput string + }{ + { + name: "No args", + expectedOutput: `[ + { + "Description": "Some value", + "Name": "Name", + "Action": "FAIL" + } +] +`, + }, + { + name: "Name only", + args: []string{"--names-only=true"}, + expectedOutput: `[ + "Name" +] +`, + }, + { + name: "Name flag set", + args: []string{"--name=Name"}, + expectedOutput: `"Name" +`, + }, + { + name: "Random name in name flag", + args: []string{"--name=Random"}, + expectedOutput: `"" +`, + }, + { + name: "Random name in name flag and names-only false", + args: []string{"--name=Random", "--names-only=false"}, + expectedOutput: `null +`, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.args != nil { + cmd.SetArgs(tt.args) + err := cmd.Execute() + require.NoError(t, err) + } + + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + + cmd.Run(&cobra.Command{}, []string{}) + + err := w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + + require.EqualValues(t, tt.expectedOutput, string(got)) + }) + } +} diff --git a/go/cmd/rulesctl/cmd/main_test.go b/go/cmd/rulesctl/cmd/main_test.go new file mode 100644 index 00000000000..cbdba6c00e6 --- /dev/null +++ b/go/cmd/rulesctl/cmd/main_test.go @@ -0,0 +1,60 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestMainFunction(t *testing.T) { + rootCmd := Main() + require.NotNil(t, rootCmd) + require.Equal(t, "rulesctl", rootCmd.Name()) + + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + + args := os.Args + t.Cleanup(func() { os.Args = args }) + os.Args = []string{"rulesctl", "-f=testdata/rules.json", "list"} + err := rootCmd.Execute() + require.NoError(t, err) + + err = w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + + expected := `[ + { + "Description": "Some value", + "Name": "Name", + "Action": "FAIL" + } +] +` + require.EqualValues(t, expected, string(got)) +} diff --git a/go/cmd/rulesctl/cmd/remove_test.go b/go/cmd/rulesctl/cmd/remove_test.go new file mode 100644 index 00000000000..d0ee9f9880e --- /dev/null +++ b/go/cmd/rulesctl/cmd/remove_test.go @@ -0,0 +1,114 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cmd + +import ( + "io" + "os" + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/require" +) + +func TestRemoveOld(t *testing.T) { + removeCmd := Remove() + + require.NotNil(t, removeCmd) + require.Equal(t, "remove-rule", removeCmd.Name()) + + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + + configFile = "../common/testdata/rules.json" + removeCmd.Run(&cobra.Command{}, []string{""}) + + err := w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + + expected := "No rule found:" + require.Contains(t, string(got), expected) +} + +func TestRemove(t *testing.T) { + cmd := Remove() + require.NotNil(t, cmd) + require.Equal(t, "remove-rule", cmd.Name()) + configFile = "./testdata/rules.json" + defer func() { + _ = os.WriteFile(configFile, []byte(`[ + { + "Description": "Some value", + "Name": "Name" + } +] +`), 0777) + }() + + tests := []struct { + name string + args []string + expectedOutput string + }{ + { + name: "No args", + expectedOutput: "No rule found: ''", + }, + { + name: "Dry run and name both set", + args: []string{"--dry-run=true", "--name=Name"}, + expectedOutput: "[]\n", + }, + { + name: "Dry run not set name set", + args: []string{"--dry-run=false", "--name=Name"}, + expectedOutput: "No rule found: 'Name'", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + + if tt.args != nil { + cmd.SetArgs(tt.args) + err := cmd.Execute() + require.NoError(t, err) + } + cmd.Run(&cobra.Command{}, []string{}) + + err := w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + + require.Contains(t, string(got), tt.expectedOutput) + }) + } +} diff --git a/go/cmd/rulesctl/cmd/testdata/rules.json b/go/cmd/rulesctl/cmd/testdata/rules.json new file mode 100644 index 00000000000..12f0bfa0b5a --- /dev/null +++ b/go/cmd/rulesctl/cmd/testdata/rules.json @@ -0,0 +1,6 @@ +[ + { + "Description": "Some value", + "Name": "Name" + } +] diff --git a/go/cmd/rulesctl/common/common_test.go b/go/cmd/rulesctl/common/common_test.go new file mode 100644 index 00000000000..aff7f012c20 --- /dev/null +++ b/go/cmd/rulesctl/common/common_test.go @@ -0,0 +1,84 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package common + +import ( + "io" + "os" + "path" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestGetRules(t *testing.T) { + rules := GetRules("testdata/rules.json") + require.NotEmpty(t, rules) +} + +type testStruct struct { + StringField string `yaml:"stringfield"` + IntField int `yaml:"intfield"` + BoolField bool `yaml:"boolfield"` + Float64Field float64 `yaml:"float64field"` +} + +var testData = testStruct{ + "tricky text to test text", + 32, + true, + 3.141, +} + +func TestMustPrintJSON(t *testing.T) { + originalStdOut := os.Stdout + defer func() { + os.Stdout = originalStdOut + }() + + // Redirect stdout to a buffer + r, w, _ := os.Pipe() + os.Stdout = w + MustPrintJSON(testData) + + err := w.Close() + require.NoError(t, err) + got, err := io.ReadAll(r) + require.NoError(t, err) + require.Equal(t, `{ + "StringField": "tricky text to test text", + "IntField": 32, + "BoolField": true, + "Float64Field": 3.141 +} +`, string(got)) +} + +func TestMustWriteJSON(t *testing.T) { + tmpFile := path.Join(t.TempDir(), "temp.json") + MustWriteJSON(testData, tmpFile) + + res, err := os.ReadFile(tmpFile) + require.NoError(t, err) + + require.EqualValues(t, `{ + "StringField": "tricky text to test text", + "IntField": 32, + "BoolField": true, + "Float64Field": 3.141 +}`, string(res)) +} diff --git a/go/cmd/rulesctl/common/testdata/rules.json b/go/cmd/rulesctl/common/testdata/rules.json new file mode 100644 index 00000000000..12f0bfa0b5a --- /dev/null +++ b/go/cmd/rulesctl/common/testdata/rules.json @@ -0,0 +1,6 @@ +[ + { + "Description": "Some value", + "Name": "Name" + } +]