From 9501e4bfb8c966a849b88f45e8df8b8ea7821dd5 Mon Sep 17 00:00:00 2001 From: Lynn Date: Tue, 30 Apr 2019 13:04:08 +0800 Subject: [PATCH 1/2] domain: fix updating the self schema version and update log --- domain/domain.go | 45 ++++++++++++++++++++++++++----------------- domain/domain_test.go | 16 +++++++++++++++ 2 files changed, 43 insertions(+), 18 deletions(-) diff --git a/domain/domain.go b/domain/domain.go index 814452ea9870a..592ceeca8cc9d 100644 --- a/domain/domain.go +++ b/domain/domain.go @@ -84,29 +84,36 @@ func (do *Domain) loadInfoSchema(handle *infoschema.Handle, usedSchemaVersion in return 0, nil, fullLoad, err } m := meta.NewSnapshotMeta(snapshot) - latestSchemaVersion, err := m.GetSchemaVersion() + neededSchemaVersion, err := m.GetSchemaVersion() if err != nil { return 0, nil, fullLoad, err } - if usedSchemaVersion != 0 && usedSchemaVersion == latestSchemaVersion { - return latestSchemaVersion, nil, fullLoad, nil + if usedSchemaVersion != 0 && usedSchemaVersion == neededSchemaVersion { + return neededSchemaVersion, nil, fullLoad, nil } // Update self schema version to etcd. defer func() { - if err != nil { - logutil.Logger(context.Background()).Info("cannot update self schema version to etcd") + // There are two possibilities for not updating the self schema version to etcd. + // 1. Failed to loading schema information. + // 2. When users use history read feature, the neededSchemaVersion isn't the latest schema version. + if err != nil || neededSchemaVersion < do.InfoSchema().SchemaMetaVersion() { + logutil.Logger(context.Background()).Info("do not update self schema version to etcd", + zap.Int64("usedSchemaVersion", usedSchemaVersion), + zap.Int64("neededSchemaVersion", neededSchemaVersion), zap.Error(err)) return } - err = do.ddl.SchemaSyncer().UpdateSelfVersion(context.Background(), latestSchemaVersion) + + err = do.ddl.SchemaSyncer().UpdateSelfVersion(context.Background(), neededSchemaVersion) if err != nil { - logutil.Logger(context.Background()).Info("update self version failed", zap.Int64("usedSchemaVersion", usedSchemaVersion), - zap.Int64("latestSchemaVersion", latestSchemaVersion), zap.Error(err)) + logutil.Logger(context.Background()).Info("update self version failed", + zap.Int64("usedSchemaVersion", usedSchemaVersion), + zap.Int64("neededSchemaVersion", neededSchemaVersion), zap.Error(err)) } }() startTime := time.Now() - ok, tblIDs, err := do.tryLoadSchemaDiffs(m, usedSchemaVersion, latestSchemaVersion) + ok, tblIDs, err := do.tryLoadSchemaDiffs(m, usedSchemaVersion, neededSchemaVersion) if err != nil { // We can fall back to full load, don't need to return the error. logutil.Logger(context.Background()).Error("failed to load schema diff", zap.Error(err)) @@ -114,10 +121,10 @@ func (do *Domain) loadInfoSchema(handle *infoschema.Handle, usedSchemaVersion in if ok { logutil.Logger(context.Background()).Info("diff load InfoSchema success", zap.Int64("usedSchemaVersion", usedSchemaVersion), - zap.Int64("latestSchemaVersion", latestSchemaVersion), + zap.Int64("neededSchemaVersion", neededSchemaVersion), zap.Duration("start time", time.Since(startTime)), zap.Int64s("tblIDs", tblIDs)) - return latestSchemaVersion, tblIDs, fullLoad, nil + return neededSchemaVersion, tblIDs, fullLoad, nil } fullLoad = true @@ -126,14 +133,16 @@ func (do *Domain) loadInfoSchema(handle *infoschema.Handle, usedSchemaVersion in return 0, nil, fullLoad, err } - newISBuilder, err := infoschema.NewBuilder(handle).InitWithDBInfos(schemas, latestSchemaVersion) + newISBuilder, err := infoschema.NewBuilder(handle).InitWithDBInfos(schemas, neededSchemaVersion) if err != nil { return 0, nil, fullLoad, err } - logutil.Logger(context.Background()).Info("full load InfoSchema success", zap.Int64("usedSchemaVersion", usedSchemaVersion), - zap.Int64("latestSchemaVersion", latestSchemaVersion), zap.Duration("start time", time.Since(startTime))) + logutil.Logger(context.Background()).Info("full load InfoSchema success", + zap.Int64("usedSchemaVersion", usedSchemaVersion), + zap.Int64("neededSchemaVersion", neededSchemaVersion), + zap.Duration("start time", time.Since(startTime))) newISBuilder.Build() - return latestSchemaVersion, nil, fullLoad, nil + return neededSchemaVersion, nil, fullLoad, nil } func (do *Domain) fetchAllSchemasWithTables(m *meta.Meta) ([]*model.DBInfo, error) { @@ -314,7 +323,7 @@ func (do *Domain) Reload() error { startTime := time.Now() var err error - var latestSchemaVersion int64 + var neededSchemaVersion int64 ver, err := do.store.CurrentVersion() if err != nil { @@ -331,7 +340,7 @@ func (do *Domain) Reload() error { fullLoad bool changedTableIDs []int64 ) - latestSchemaVersion, changedTableIDs, fullLoad, err = do.loadInfoSchema(do.infoHandle, schemaVersion, ver.Ver) + neededSchemaVersion, changedTableIDs, fullLoad, err = do.loadInfoSchema(do.infoHandle, schemaVersion, ver.Ver) metrics.LoadSchemaDuration.Observe(time.Since(startTime).Seconds()) if err != nil { metrics.LoadSchemaCounter.WithLabelValues("failed").Inc() @@ -343,7 +352,7 @@ func (do *Domain) Reload() error { logutil.Logger(context.Background()).Info("full load and reset schema validator") do.SchemaValidator.Reset() } - do.SchemaValidator.Update(ver.Ver, schemaVersion, latestSchemaVersion, changedTableIDs) + do.SchemaValidator.Update(ver.Ver, schemaVersion, neededSchemaVersion, changedTableIDs) lease := do.DDL().GetLease() sub := time.Since(startTime) diff --git a/domain/domain_test.go b/domain/domain_test.go index d01fa94ad65ff..5f0fb1b86c31c 100644 --- a/domain/domain_test.go +++ b/domain/domain_test.go @@ -14,6 +14,7 @@ package domain import ( + "context" "testing" "time" @@ -26,6 +27,7 @@ import ( "github.com/pingcap/parser/mysql" "github.com/pingcap/tidb/metrics" "github.com/pingcap/tidb/store/mockstore" + "github.com/pingcap/tidb/store/tikv/oracle" "github.com/pingcap/tidb/util/mock" "github.com/pingcap/tidb/util/testleak" dto "github.com/prometheus/client_model/go" @@ -63,6 +65,7 @@ func (*testSuite) TestT(c *C) { store = dom.Store() ctx := mock.NewContext() ctx.Store = store + snapTS := oracle.EncodeTSO(oracle.GetPhysical(time.Now())) dd := dom.DDL() c.Assert(dd, NotNil) c.Assert(dd.GetLease(), Equals, 80*time.Millisecond) @@ -78,6 +81,19 @@ func (*testSuite) TestT(c *C) { // for setting lease lease := 100 * time.Millisecond + // for updating the self schema version + goCtx, cancel := context.WithTimeout(context.Background(), 3*time.Millisecond) + err = dd.SchemaSyncer().OwnerCheckAllVersions(goCtx, is.SchemaMetaVersion()) + cancel() + c.Assert(err, IsNil) + _, err = dom.GetSnapshotInfoSchema(snapTS) + c.Assert(err, IsNil) + // Make sure that the self schema version doesn't be changed. + goCtx, cancel = context.WithTimeout(context.Background(), 3*time.Millisecond) + err = dd.SchemaSyncer().OwnerCheckAllVersions(goCtx, is.SchemaMetaVersion()) + cancel() + c.Assert(err, IsNil) + // for schemaValidator schemaVer := dom.SchemaValidator.(*schemaValidator).latestSchemaVer ver, err := store.CurrentVersion() From 5991db2a3ee56e49c03fa02a7c356990c04df47c Mon Sep 17 00:00:00 2001 From: Lynn Date: Tue, 30 Apr 2019 16:27:31 +0800 Subject: [PATCH 2/2] domain: tiny update --- domain/domain_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/domain/domain_test.go b/domain/domain_test.go index 5f0fb1b86c31c..51f607e4565e1 100644 --- a/domain/domain_test.go +++ b/domain/domain_test.go @@ -82,14 +82,14 @@ func (*testSuite) TestT(c *C) { lease := 100 * time.Millisecond // for updating the self schema version - goCtx, cancel := context.WithTimeout(context.Background(), 3*time.Millisecond) + goCtx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond) err = dd.SchemaSyncer().OwnerCheckAllVersions(goCtx, is.SchemaMetaVersion()) cancel() c.Assert(err, IsNil) _, err = dom.GetSnapshotInfoSchema(snapTS) c.Assert(err, IsNil) // Make sure that the self schema version doesn't be changed. - goCtx, cancel = context.WithTimeout(context.Background(), 3*time.Millisecond) + goCtx, cancel = context.WithTimeout(context.Background(), 10*time.Millisecond) err = dd.SchemaSyncer().OwnerCheckAllVersions(goCtx, is.SchemaMetaVersion()) cancel() c.Assert(err, IsNil)