Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat: add schema dump format versioning for reliable drift detection (#18331)
Vincent Huang984cab2f8ea2
diff --git a/CLAUDE.md b/CLAUDE.mdindex 0c16f7436d..93ad60f34f 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -188,3 +188,21 @@ Always follow these guidelines to avoid common linting errors:- The database JSONB columns store JSON marshalled by `protojson.Marshal` in Go code. `protojson.Marshal` produces camelCased keys rather than the snake_case keys defined in the proto files. e.g. `task_run` becomes `taskRun`- When modifying multiple files, run file modification tasks in parallel whenever possible, instead of processing them sequentially++## Schema Dump Format++When modifying schema dump output, increment the engine's `DumpFormatVersion` in `backend/plugin/schema/{engine}/dump_format_version.go`.++**Files that affect dump format:**+- `backend/plugin/schema/{engine}/get_database_definition.go`+- `backend/plugin/schema/{engine}/sdl_*.go`+- `backend/plugin/db/{engine}/dump.go`++**When to bump:**+- Adding/removing SQL statements in output+- Changing formatting or ordering+- Changing how objects are serialized++**Do not bump for:**+- Refactoring that doesn't change output+- Changes to parsing or validation codediff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.goindex 6f7d2abb88..dd963ac9b1 100644--- a/backend/api/v1/database_service.go+++ b/backend/api/v1/database_service.go@@ -330,6 +330,13 @@ func (s *DatabaseService) UpdateDatabase(ctx context.Context, req *connect.Requeif err != nil {return nil, errors.Wrapf(err, "failed to sync database metadata and schema")}+ instance, err := s.store.GetInstanceV2(ctx, &store.FindInstanceMessage{ResourceID: &databaseMessage.InstanceID})+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get instance for format version")+ }+ if instance == nil {+ return nil, errors.Errorf("instance %q not found", databaseMessage.InstanceID)+ }if _, err := s.store.CreateChangelog(ctx, &store.ChangelogMessage{InstanceID: databaseMessage.InstanceID,DatabaseName: databaseMessage.DatabaseName,@@ -338,8 +345,9 @@ func (s *DatabaseService) UpdateDatabase(ctx context.Context, req *connect.RequePrevSyncHistoryUID: &syncHistory,SyncHistoryUID: &syncHistory,Payload: &storepb.ChangelogPayload{- Type: storepb.ChangelogPayload_BASELINE,- GitCommit: s.profile.GitCommit,+ Type: storepb.ChangelogPayload_BASELINE,+ GitCommit: s.profile.GitCommit,+ DumpVersion: schema.GetDumpFormatVersion(instance.Metadata.GetEngine()),}}); err != nil {return nil, errors.Wrapf(err, "failed to create changelog")}diff --git a/backend/api/v1/database_service_changelog.go b/backend/api/v1/database_service_changelog.goindex dd0214966d..fa184fc214 100644--- a/backend/api/v1/database_service_changelog.go+++ b/backend/api/v1/database_service_changelog.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/store")@@ -24,6 +25,14 @@ func (s *DatabaseService) ListChangelogs(ctx context.Context, req *connect.Requereturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", req.Msg.Parent))}+ instance, err := s.store.GetInstanceV2(ctx, &store.FindInstanceMessage{ResourceID: &database.InstanceID})+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, err)+ }+ if instance == nil {+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("instance %q not found", database.InstanceID))+ }+offset, err := parseLimitAndOffset(&pageSize{token: req.Msg.PageToken,limit: int(req.Msg.PageSize),@@ -77,7 +86,7 @@ func (s *DatabaseService) ListChangelogs(ctx context.Context, req *connect.Reque}// no subsequent pages- converted := s.convertToChangelogs(database, changelogs)+ converted := s.convertToChangelogs(database, changelogs, instance.Metadata.GetEngine())return connect.NewResponse(&v1pb.ListChangelogsResponse{Changelogs: converted,NextPageToken: nextPageToken,@@ -127,38 +136,45 @@ func (s *DatabaseService) GetChangelog(ctx context.Context, req *connect.Requestreturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", databaseName))}- converted := s.convertToChangelog(database, changelog)+ converted := s.convertToChangelog(database, changelog, instance.Metadata.GetEngine())return connect.NewResponse(converted), nil}-func (s *DatabaseService) convertToChangelogs(d *store.DatabaseMessage, cs []*store.ChangelogMessage) []*v1pb.Changelog {+func (s *DatabaseService) convertToChangelogs(d *store.DatabaseMessage, cs []*store.ChangelogMessage, engine storepb.Engine) []*v1pb.Changelog {var changelogs []*v1pb.Changelogfor _, c := range cs {- changelog := s.convertToChangelog(d, c)+ changelog := s.convertToChangelog(d, c, engine)changelogs = append(changelogs, changelog)}return changelogs}-func (*DatabaseService) convertToChangelog(d *store.DatabaseMessage, c *store.ChangelogMessage) *v1pb.Changelog {+func (*DatabaseService) convertToChangelog(d *store.DatabaseMessage, c *store.ChangelogMessage, engine storepb.Engine) *v1pb.Changelog {changelogType := convertToChangelogType(c.Payload.GetType())++ // Compute dump version mismatch+ storedVersion := c.Payload.GetDumpVersion()+ currentVersion := schema.GetDumpFormatVersion(engine)+ dumpVersionMismatch := storedVersion != currentVersion+cl := &v1pb.Changelog{- Name: common.FormatChangelog(d.InstanceID, d.DatabaseName, c.UID),- CreateTime: timestamppb.New(c.CreatedAt),- Status: convertToChangelogStatus(c.Status),- Statement: "",- StatementSize: 0,- StatementSheet: "",- Schema: "",- SchemaSize: 0,- PrevSchema: "",- PrevSchemaSize: 0,- Issue: c.Payload.GetIssue(),- TaskRun: c.Payload.GetTaskRun(),- Version: c.Payload.GetVersion(),- Revision: "",- ChangedResources: convertToChangedResources(c.Payload.GetChangedResources()),- Type: changelogType,+ Name: common.FormatChangelog(d.InstanceID, d.DatabaseName, c.UID),+ CreateTime: timestamppb.New(c.CreatedAt),+ Status: convertToChangelogStatus(c.Status),+ Statement: "",+ StatementSize: 0,+ StatementSheet: "",+ Schema: "",+ SchemaSize: 0,+ PrevSchema: "",+ PrevSchemaSize: 0,+ Issue: c.Payload.GetIssue(),+ TaskRun: c.Payload.GetTaskRun(),+ Version: c.Payload.GetVersion(),+ Revision: "",+ ChangedResources: convertToChangedResources(c.Payload.GetChangedResources()),+ Type: changelogType,+ DumpVersionMismatch: dumpVersionMismatch,}if sheet := c.Payload.GetSheet(); sheet != "" {diff --git a/backend/component/sampleinstance/manager.go b/backend/component/sampleinstance/manager.goindex fe3ff7951b..52d64e6a6c 100644--- a/backend/component/sampleinstance/manager.go+++ b/backend/component/sampleinstance/manager.go@@ -13,6 +13,7 @@ import ("github.com/bytebase/bytebase/backend/common/log""github.com/bytebase/bytebase/backend/component/config"storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/resources/postgres""github.com/bytebase/bytebase/backend/runner/schemasync""github.com/bytebase/bytebase/backend/store"@@ -304,8 +305,9 @@ func (m *Manager) generateInstance(PrevSyncHistoryUID: &syncHistory,SyncHistoryUID: &syncHistory,Payload: &storepb.ChangelogPayload{- Type: storepb.ChangelogPayload_BASELINE,- GitCommit: m.profile.GitCommit,+ Type: storepb.ChangelogPayload_BASELINE,+ GitCommit: m.profile.GitCommit,+ DumpVersion: schema.GetDumpFormatVersion(instance.Metadata.GetEngine()),},}); err != nil {return errors.Wrapf(err, "failed to create baseline changelog for %v", dbName)diff --git a/backend/generated-go/store/changelog.pb.go b/backend/generated-go/store/changelog.pb.goindex 4278e6868f..4cf128cce5 100644--- a/backend/generated-go/store/changelog.pb.go+++ b/backend/generated-go/store/changelog.pb.go@@ -85,10 +85,14 @@ type ChangelogPayload struct {ChangedResources *ChangedResources `protobuf:"bytes,4,opt,name=changed_resources,json=changedResources,proto3" json:"changed_resources,omitempty"`// The sheet that holds the content.// Format: projects/{project}/sheets/{sheet}- Sheet string `protobuf:"bytes,5,opt,name=sheet,proto3" json:"sheet,omitempty"`- Version string `protobuf:"bytes,6,opt,name=version,proto3" json:"version,omitempty"`- Type ChangelogPayload_Type `protobuf:"varint,7,opt,name=type,proto3,enum=bytebase.store.ChangelogPayload_Type" json:"type,omitempty"`- GitCommit string `protobuf:"bytes,8,opt,name=git_commit,json=gitCommit,proto3" json:"git_commit,omitempty"`+ Sheet string `protobuf:"bytes,5,opt,name=sheet,proto3" json:"sheet,omitempty"`+ Version string `protobuf:"bytes,6,opt,name=version,proto3" json:"version,omitempty"`+ Type ChangelogPayload_Type `protobuf:"varint,7,opt,name=type,proto3,enum=bytebase.store.ChangelogPayload_Type" json:"type,omitempty"`+ GitCommit string `protobuf:"bytes,8,opt,name=git_commit,json=gitCommit,proto3" json:"git_commit,omitempty"`+ // Dump format version for drift detection reliability.+ // Engine-specific version stored when baseline/migration is created.+ // 0 = legacy changelog (pre-versioning).+ DumpVersion int32 `protobuf:"varint,9,opt,name=dump_version,json=dumpVersion,proto3" json:"dump_version,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -179,6 +183,13 @@ func (x *ChangelogPayload) GetGitCommit() string {return ""}+func (x *ChangelogPayload) GetDumpVersion() int32 {+ if x != nil {+ return x.DumpVersion+ }+ return 0+}+type ChangedResources struct {state protoimpl.MessageState `protogen:"open.v1"`Databases []*ChangedResourceDatabase `protobuf:"bytes,1,rep,name=databases,proto3" json:"databases,omitempty"`@@ -576,7 +587,7 @@ var File_store_changelog_proto protoreflect.FileDescriptorconst file_store_changelog_proto_rawDesc = "" +"\n" +- "\x15store/changelog.proto\x12\x0ebytebase.store\x1a\x12store/common.proto\"\xfa\x02\n" ++ "\x15store/changelog.proto\x12\x0ebytebase.store\x1a\x12store/common.proto\"\x9d\x03\n" +"\x10ChangelogPayload\x12\x19\n" +"\btask_run\x18\x01 \x01(\tR\ataskRun\x12\x14\n" +"\x05issue\x18\x02 \x01(\tR\x05issue\x12\x1a\n" +@@ -586,7 +597,8 @@ const file_store_changelog_proto_rawDesc = "" +"\aversion\x18\x06 \x01(\tR\aversion\x129\n" +"\x04type\x18\a \x01(\x0e2%.bytebase.store.ChangelogPayload.TypeR\x04type\x12\x1d\n" +"\n" +- "git_commit\x18\b \x01(\tR\tgitCommit\"@\n" ++ "git_commit\x18\b \x01(\tR\tgitCommit\x12!\n" ++ "\fdump_version\x18\t \x01(\x05R\vdumpVersion\"@\n" +"\x04Type\x12\x14\n" +"\x10TYPE_UNSPECIFIED\x10\x00\x12\f\n" +"\bBASELINE\x10\x01\x12\v\n" +diff --git a/backend/generated-go/store/changelog_equal.pb.go b/backend/generated-go/store/changelog_equal.pb.goindex d0998d1bcc..ec2b542f5a 100644--- a/backend/generated-go/store/changelog_equal.pb.go+++ b/backend/generated-go/store/changelog_equal.pb.go@@ -34,6 +34,9 @@ func (x *ChangelogPayload) Equal(y *ChangelogPayload) bool {if x.GitCommit != y.GitCommit {return false}+ if x.DumpVersion != y.DumpVersion {+ return false+ }return true}diff --git a/backend/generated-go/v1/database_service.pb.go b/backend/generated-go/v1/database_service.pb.goindex ba5d219d6e..1291da2a13 100644--- a/backend/generated-go/v1/database_service.pb.go+++ b/backend/generated-go/v1/database_service.pb.go@@ -5776,8 +5776,11 @@ type Changelog struct {Revision string `protobuf:"bytes,15,opt,name=revision,proto3" json:"revision,omitempty"`ChangedResources *ChangedResources `protobuf:"bytes,16,opt,name=changed_resources,json=changedResources,proto3" json:"changed_resources,omitempty"`Type Changelog_Type `protobuf:"varint,17,opt,name=type,proto3,enum=bytebase.v1.Changelog_Type" json:"type,omitempty"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache+ // True if this changelog's dump version differs from current engine dump version.+ // When true and drift is detected, the drift may be a false positive from Bytebase upgrade.+ DumpVersionMismatch bool `protobuf:"varint,18,opt,name=dump_version_mismatch,json=dumpVersionMismatch,proto3" json:"dump_version_mismatch,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache}func (x *Changelog) Reset() {@@ -5922,6 +5925,13 @@ func (x *Changelog) GetType() Changelog_Type {return Changelog_TYPE_UNSPECIFIED}+func (x *Changelog) GetDumpVersionMismatch() bool {+ if x != nil {+ return x.DumpVersionMismatch+ }+ return false+}+type GetSchemaStringRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The name of the database.@@ -6542,7 +6552,7 @@ const file_v1_database_service_proto_rawDesc = "" +"\x13GetChangelogRequest\x12:\n" +"\x04name\x18\x01 \x01(\tB&\xe0A\x02\xfaA \n" +"\x1ebytebase.com/DatabaseChangelogR\x04name\x12.\n" +- "\x04view\x18\x02 \x01(\x0e2\x1a.bytebase.v1.ChangelogViewR\x04view\"\xd7\x06\n" ++ "\x04view\x18\x02 \x01(\x0e2\x1a.bytebase.v1.ChangelogViewR\x04view\"\x8b\a\n" +"\tChangelog\x12\x12\n" +"\x04name\x18\x01 \x01(\tR\x04name\x12;\n" +"\vcreate_time\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\n" +@@ -6563,7 +6573,8 @@ const file_v1_database_service_proto_rawDesc = "" +"\aversion\x18\x0e \x01(\tR\aversion\x12\x1a\n" +"\brevision\x18\x0f \x01(\tR\brevision\x12J\n" +"\x11changed_resources\x18\x10 \x01(\v2\x1d.bytebase.v1.ChangedResourcesR\x10changedResources\x12/\n" +- "\x04type\x18\x11 \x01(\x0e2\x1b.bytebase.v1.Changelog.TypeR\x04type\"C\n" ++ "\x04type\x18\x11 \x01(\x0e2\x1b.bytebase.v1.Changelog.TypeR\x04type\x122\n" ++ "\x15dump_version_mismatch\x18\x12 \x01(\bR\x13dumpVersionMismatch\"C\n" +"\x06Status\x12\x16\n" +"\x12STATUS_UNSPECIFIED\x10\x00\x12\v\n" +"\aPENDING\x10\x01\x12\b\n" +diff --git a/backend/generated-go/v1/database_service_equal.pb.go b/backend/generated-go/v1/database_service_equal.pb.goindex cd2d122d22..c5f77876d9 100644--- a/backend/generated-go/v1/database_service_equal.pb.go+++ b/backend/generated-go/v1/database_service_equal.pb.go@@ -1893,6 +1893,9 @@ func (x *Changelog) Equal(y *Changelog) bool {if x.Type != y.Type {return false}+ if x.DumpVersionMismatch != y.DumpVersionMismatch {+ return false+ }return true}diff --git a/backend/plugin/schema/clickhouse/dump_format_version.go b/backend/plugin/schema/clickhouse/dump_format_version.gonew file mode 100644index 0000000000..5db2dee398--- /dev/null+++ b/backend/plugin/schema/clickhouse/dump_format_version.go@@ -0,0 +1,16 @@+package clickhouse++import (+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// DumpFormatVersion tracks the schema dump output format for ClickHouse.+// INCREMENT THIS when modifying any code that changes Dump() or+// GetDatabaseDefinition() output for this engine.+// See bytebase/CLAUDE.md "Schema Dump Format" section for details.+const DumpFormatVersion int32 = 1++func init() {+ schema.RegisterDumpFormatVersion(storepb.Engine_CLICKHOUSE, DumpFormatVersion)+}diff --git a/backend/plugin/schema/dump_format_version.go b/backend/plugin/schema/dump_format_version.gonew file mode 100644index 0000000000..c6a7eb16ea--- /dev/null+++ b/backend/plugin/schema/dump_format_version.go@@ -0,0 +1,28 @@+package schema++import (+ "fmt"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++var dumpFormatVersions = make(map[storepb.Engine]int32)++// RegisterDumpFormatVersion registers the dump format version for an engine.+// This should be called during init() in each engine's dump_format_version.go.+func RegisterDumpFormatVersion(engine storepb.Engine, version int32) {+ mux.Lock()+ defer mux.Unlock()+ if _, dup := dumpFormatVersions[engine]; dup {+ panic(fmt.Sprintf("RegisterDumpFormatVersion called twice for %s", engine))+ }+ dumpFormatVersions[engine] = version+}++// GetDumpFormatVersion returns the current dump format version for the given engine.+// Returns 0 for unsupported engines (drift detection will be skipped).+func GetDumpFormatVersion(engine storepb.Engine) int32 {+ mux.Lock()+ defer mux.Unlock()+ return dumpFormatVersions[engine]+}diff --git a/backend/plugin/schema/mssql/dump_format_version.go b/backend/plugin/schema/mssql/dump_format_version.gonew file mode 100644index 0000000000..03bf114ef1--- /dev/null+++ b/backend/plugin/schema/mssql/dump_format_version.go@@ -0,0 +1,16 @@+package mssql++import (+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// DumpFormatVersion tracks the schema dump output format for MSSQL.+// INCREMENT THIS when modifying any code that changes Dump() or+// GetDatabaseDefinition() output for this engine.+// See bytebase/CLAUDE.md "Schema Dump Format" section for details.+const DumpFormatVersion int32 = 1++func init() {+ schema.RegisterDumpFormatVersion(storepb.Engine_MSSQL, DumpFormatVersion)+}diff --git a/backend/plugin/schema/mysql/dump_format_version.go b/backend/plugin/schema/mysql/dump_format_version.gonew file mode 100644index 0000000000..0a0467ea5e--- /dev/null+++ b/backend/plugin/schema/mysql/dump_format_version.go@@ -0,0 +1,16 @@+package mysql++import (+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// DumpFormatVersion tracks the schema dump output format for MySQL.+// INCREMENT THIS when modifying any code that changes Dump() or+// GetDatabaseDefinition() output for this engine.+// See bytebase/CLAUDE.md "Schema Dump Format" section for details.+const DumpFormatVersion int32 = 1++func init() {+ schema.RegisterDumpFormatVersion(storepb.Engine_MYSQL, DumpFormatVersion)+}diff --git a/backend/plugin/schema/oracle/dump_format_version.go b/backend/plugin/schema/oracle/dump_format_version.gonew file mode 100644index 0000000000..9fa3957e00--- /dev/null+++ b/backend/plugin/schema/oracle/dump_format_version.go@@ -0,0 +1,16 @@+package oracle++import (+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// DumpFormatVersion tracks the schema dump output format for Oracle.+// INCREMENT THIS when modifying any code that changes Dump() or+// GetDatabaseDefinition() output for this engine.+// See bytebase/CLAUDE.md "Schema Dump Format" section for details.+const DumpFormatVersion int32 = 1++func init() {+ schema.RegisterDumpFormatVersion(storepb.Engine_ORACLE, DumpFormatVersion)+}diff --git a/backend/plugin/schema/pg/dump_format_version.go b/backend/plugin/schema/pg/dump_format_version.gonew file mode 100644index 0000000000..3a83629fd5--- /dev/null+++ b/backend/plugin/schema/pg/dump_format_version.go@@ -0,0 +1,16 @@+package pg++import (+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// DumpFormatVersion tracks the schema dump output format for PostgreSQL.+// INCREMENT THIS when modifying any code that changes Dump() or+// GetDatabaseDefinition() output for this engine.+// See bytebase/CLAUDE.md "Schema Dump Format" section for details.+const DumpFormatVersion int32 = 1++func init() {+ schema.RegisterDumpFormatVersion(storepb.Engine_POSTGRES, DumpFormatVersion)+}diff --git a/backend/plugin/schema/tidb/dump_format_version.go b/backend/plugin/schema/tidb/dump_format_version.gonew file mode 100644index 0000000000..28fd9c6625--- /dev/null+++ b/backend/plugin/schema/tidb/dump_format_version.go@@ -0,0 +1,16 @@+package tidb++import (+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// DumpFormatVersion tracks the schema dump output format for TiDB.+// INCREMENT THIS when modifying any code that changes Dump() or+// GetDatabaseDefinition() output for this engine.+// See bytebase/CLAUDE.md "Schema Dump Format" section for details.+const DumpFormatVersion int32 = 1++func init() {+ schema.RegisterDumpFormatVersion(storepb.Engine_TIDB, DumpFormatVersion)+}diff --git a/backend/plugin/schema/trino/dump_format_version.go b/backend/plugin/schema/trino/dump_format_version.gonew file mode 100644index 0000000000..cdb8df566b--- /dev/null+++ b/backend/plugin/schema/trino/dump_format_version.go@@ -0,0 +1,16 @@+package trino++import (+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// DumpFormatVersion tracks the schema dump output format for Trino.+// INCREMENT THIS when modifying any code that changes Dump() or+// GetDatabaseDefinition() output for this engine.+// See bytebase/CLAUDE.md "Schema Dump Format" section for details.+const DumpFormatVersion int32 = 1++func init() {+ schema.RegisterDumpFormatVersion(storepb.Engine_TRINO, DumpFormatVersion)+}diff --git a/backend/runner/schemasync/syncer.go b/backend/runner/schemasync/syncer.goindex 5e91d85063..af819d43a2 100644--- a/backend/runner/schemasync/syncer.go+++ b/backend/runner/schemasync/syncer.go@@ -25,6 +25,7 @@ import ("github.com/bytebase/bytebase/backend/enterprise"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/db"+ "github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/store""github.com/bytebase/bytebase/backend/store/model")@@ -394,9 +395,9 @@ func (s *Syncer) doSyncDatabaseSchema(ctx context.Context, database *store.DatabdbConfig := dbMetadata.GetConfig()// Check for schema drift only when not creating sync history- var drifted, skipped bool+ var drifted boolif !createSyncHistory {- drifted, skipped, err = s.getSchemaDrifted(ctx, instance, database, string(rawDump))+ drifted, err = s.getSchemaDrifted(ctx, instance, database, string(rawDump))if err != nil {return 0, errors.Wrapf(err, "failed to get schema drifted for database %q", database.DatabaseName)}@@ -409,7 +410,7 @@ func (s *Syncer) doSyncDatabaseSchema(ctx context.Context, database *store.Databmd.BackupAvailable = s.databaseBackupAvailable(ctx, instance, syncedDatabaseMetadata)md.Datashare = syncedDatabaseMetadata.Datashareif !createSyncHistory {- md.Drifted = !skipped && drifted+ md.Drifted = drifted}},}@@ -463,10 +464,10 @@ func (s *Syncer) SyncDatabaseSchema(ctx context.Context, database *store.Databasreturn err}-func (s *Syncer) getSchemaDrifted(ctx context.Context, instance *store.InstanceMessage, database *store.DatabaseMessage, rawDump string) (drifted bool, skipped bool, err error) {+func (s *Syncer) getSchemaDrifted(ctx context.Context, instance *store.InstanceMessage, database *store.DatabaseMessage, rawDump string) (drifted bool, err error) {// Redis and MongoDB are schemaless.if disableSchemaDriftCheck(instance.Metadata.GetEngine()) {- return false, false, nil+ return false, nil}limit := 1list, err := s.store.ListChangelogs(ctx, &store.FindChangelogMessage{@@ -478,21 +479,46 @@ func (s *Syncer) getSchemaDrifted(ctx context.Context, instance *store.InstanceMShowFull: true,})if err != nil {- return false, false, errors.Wrapf(err, "failed to list changelogs")+ return false, errors.Wrapf(err, "failed to list changelogs")}if len(list) == 0 {- return false, false, nil+ return false, nil}changelog := list[0]- if changelog.Payload.GetGitCommit() != s.profile.GitCommit {- return false, true, nil- }if changelog.SyncHistoryUID == nil {- return false, false, errors.Errorf("expect sync history but get nil")+ return false, errors.Errorf("expect sync history but get nil")}++ // Get current dump version for this engine+ currentVersion := schema.GetDumpFormatVersion(instance.Metadata.GetEngine())+ baselineVersion := changelog.Payload.GetDumpVersion()+ versionMismatch := baselineVersion != currentVersion++ // Always compare schemaslatestSchema := string(rawDump)- return changelog.Schema != latestSchema, false, nil+ drifted = changelog.Schema != latestSchema++ // If versions mismatch but schemas match, update the baseline version (auto-heal).+ // This is safe because identical strings mean the format change didn't affect this database's output.+ if versionMismatch && !drifted {+ if err := s.store.UpdateChangelog(ctx, &store.UpdateChangelogMessage{+ UID: changelog.UID,+ DumpVersion: ¤tVersion,+ }); err != nil {+ slog.Warn("Failed to update changelog format version",+ slog.String("database", database.DatabaseName),+ log.BBError(err))+ // Non-fatal: continue with drift detection result+ } else {+ slog.Info("Updated changelog format version (schemas match)",+ slog.String("database", database.DatabaseName),+ slog.Int("old_version", int(baselineVersion)),+ slog.Int("new_version", int(currentVersion)))+ }+ }++ return drifted, nil}func (s *Syncer) databaseBackupAvailable(ctx context.Context, instance *store.InstanceMessage, dbMetadata *storepb.DatabaseSchemaMetadata) bool {diff --git a/backend/runner/taskrun/executor.go b/backend/runner/taskrun/executor.goindex b9ebbc8044..26e41393d6 100644--- a/backend/runner/taskrun/executor.go+++ b/backend/runner/taskrun/executor.go@@ -17,6 +17,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/db""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/runner/schemasync""github.com/bytebase/bytebase/backend/store""github.com/bytebase/bytebase/backend/store/model"@@ -521,6 +522,7 @@ func beginMigration(ctx context.Context, stores *store.Store, mc *migrateContextVersion: mc.version,Type: changelogType,GitCommit: mc.profile.GitCommit,+ DumpVersion: schema.GetDumpFormatVersion(mc.instance.Metadata.GetEngine()),}})if err != nil {return false, errors.Wrapf(err, "failed to create changelog")diff --git a/backend/store/changelog.go b/backend/store/changelog.goindex bf0e46eafa..1bdeef5294 100644--- a/backend/store/changelog.go+++ b/backend/store/changelog.go@@ -69,6 +69,7 @@ type UpdateChangelogMessage struct {SyncHistoryUID *int64RevisionUID *int64Status *ChangelogStatus+ DumpVersion *int32}func (s *Store) CreateChangelog(ctx context.Context, create *ChangelogMessage) (int64, error) {@@ -130,6 +131,9 @@ func (s *Store) UpdateChangelog(ctx context.Context, update *UpdateChangelogMessif v := update.Status; v != nil {set.Comma("status = ?", *v)}+ if v := update.DumpVersion; v != nil {+ set.Comma("payload = payload || jsonb_build_object('dumpVersion', ?::INT)", *v)+ }if set.Len() == 0 {return errors.Errorf("update nothing")diff --git a/frontend/src/components/DatabaseDetail/DriftedDatabaseAlert.vue b/frontend/src/components/DatabaseDetail/DriftedDatabaseAlert.vueindex 26ec045f07..9bf5d0b41b 100644--- a/frontend/src/components/DatabaseDetail/DriftedDatabaseAlert.vue+++ b/frontend/src/components/DatabaseDetail/DriftedDatabaseAlert.vue@@ -4,26 +4,31 @@type="warning":title="$t('database.drifted.schema-drift-detected.self')">- <div class="flex items-center justify-between gap-4">- <div class="flex-1">- {{ $t("database.drifted.schema-drift-detected.description") }}- <LearnMoreLink- class="ml-1"- url="https://docs.bytebase.com/change-database/drift-detection/?source=console"- />+ <div class="flex flex-col gap-2">+ <div class="flex items-center justify-between gap-4">+ <div class="flex-1">+ {{ $t("database.drifted.schema-drift-detected.description") }}+ <LearnMoreLink+ class="ml-1"+ url="https://docs.bytebase.com/change-database/drift-detection/?source=console"+ />+ </div>+ <div class="flex justify-end items-center gap-x-2">+ <NButton size="small" @click="state.showSchemaDiffModal = true">+ {{ $t("database.drifted.view-diff") }}+ </NButton>+ <NButton+ v-if="database.project !== DEFAULT_PROJECT_NAME"+ size="small"+ type="primary"+ @click="updateDatabaseDrift"+ >+ {{ $t("database.drifted.new-baseline.self") }}+ </NButton>+ </div></div>- <div class="flex justify-end items-center gap-2">- <NButton size="small" @click="state.showSchemaDiffModal = true">- {{ $t("database.drifted.view-diff") }}- </NButton>- <NButton- v-if="database.project !== DEFAULT_PROJECT_NAME"- size="small"- type="primary"- @click="updateDatabaseDrift"- >- {{ $t("database.drifted.new-baseline.self") }}- </NButton>+ <div v-if="formatVersionMismatch" class="text-sm text-gray-500">+ {{ $t("database.drifted.format-version-mismatch-caveat") }}</div></div></NAlert>@@ -91,6 +96,7 @@ const state = reactive<LocalState>({const latestChangelogSchema = ref("-- Loading latest changelog schema...");const currentDatabaseSchema = ref("-- Loading current database schema...");+const formatVersionMismatch = ref(false);const updateDatabaseDrift = async () => {await databaseStore.updateDatabase(@@ -120,12 +126,15 @@ const fetchLatestChangelogSchema = async () => {const latestChangelog = changelogs[0];latestChangelogSchema.value =latestChangelog.schema || "-- No schema found in latest changelog";+ formatVersionMismatch.value = latestChangelog.dumpVersionMismatch;} else {latestChangelogSchema.value = "-- No changelogs found for this database";+ formatVersionMismatch.value = false;}} catch (error) {console.error("Failed to fetch changelog:", error);latestChangelogSchema.value = "-- Failed to load changelog schema";+ formatVersionMismatch.value = false;}};diff --git a/frontend/src/locales/en-US.json b/frontend/src/locales/en-US.jsonindex f6ee03e41f..1701873883 100644--- a/frontend/src/locales/en-US.json+++ b/frontend/src/locales/en-US.json@@ -1776,6 +1776,7 @@"self": "Schema drift detected","description": "The schema is different from the last applied schema. This may cause application errors and should be resolved."},+ "format-version-mismatch-caveat": "Note: If you recently upgraded Bytebase, this may be a false positive due to schema dump format changes.","new-baseline": {"self": "New baseline","successfully-established": "Successfully established new baseline"diff --git a/frontend/src/locales/es-ES.json b/frontend/src/locales/es-ES.jsonindex 5080f9a3f2..0643a2e742 100644--- a/frontend/src/locales/es-ES.json+++ b/frontend/src/locales/es-ES.json@@ -1776,6 +1776,7 @@"self": "Se detectó una desviación del esquema","description": "El esquema es diferente del último aplicado. Esto puede causar errores de aplicación y debe solucionarse."},+ "format-version-mismatch-caveat": "Nota: Si actualizó Bytebase recientemente, esto puede ser un falso positivo debido a cambios en el formato de volcado del esquema.","new-baseline": {"self": "Nueva línea base","successfully-established": "Se estableció con éxito una nueva línea base"diff --git a/frontend/src/locales/ja-JP.json b/frontend/src/locales/ja-JP.jsonindex ec7f35a702..6e5335d62f 100644--- a/frontend/src/locales/ja-JP.json+++ b/frontend/src/locales/ja-JP.json@@ -1776,6 +1776,7 @@"self": "スキーマドリフトが検出されました","description": "スキーマが最後に適用されたスキーマと異なります。アプリケーションエラーが発生する可能性があるため、解決する必要があります。"},+ "format-version-mismatch-caveat": "注意:最近 Bytebase をアップグレードした場合、スキーマダンプ形式の変更により誤検知の可能性があります。","new-baseline": {"self": "新しいベースライン","successfully-established": "新しいベースラインを確立しました"diff --git a/frontend/src/locales/vi-VN.json b/frontend/src/locales/vi-VN.jsonindex 308a909fc8..30ff7d5b61 100644--- a/frontend/src/locales/vi-VN.json+++ b/frontend/src/locales/vi-VN.json@@ -1776,6 +1776,7 @@"self": "Đã phát hiện sự trôi dạt của sơ đồ","description": "Sơ đồ khác với sơ đồ được áp dụng lần cuối. Điều này có thể gây ra lỗi ứng dụng và cần được giải quyết."},+ "format-version-mismatch-caveat": "Lưu ý: Nếu bạn vừa nâng cấp Bytebase, đây có thể là cảnh báo sai do thay đổi định dạng kết xuất schema.","new-baseline": {"self": "Đường cơ sở mới","successfully-established": "Đã thiết lập thành công đường cơ sở mới"diff --git a/frontend/src/locales/zh-CN.json b/frontend/src/locales/zh-CN.jsonindex 100484e9e6..2b42925b86 100644--- a/frontend/src/locales/zh-CN.json+++ b/frontend/src/locales/zh-CN.json@@ -1776,6 +1776,7 @@"self": "检测到 Schema 偏差","description": "当前数据库 Schema 与 Bytebase 中记录的 Schema 不一致。请及时检查并修复以避免潜在问题。"},+ "format-version-mismatch-caveat": "注意:如果您最近升级了 Bytebase,这可能是由于 Schema 转储格式变更导致的误报。","new-baseline": {"self": "建立新基线","successfully-established": "成功建立新的基线"diff --git a/frontend/src/types/proto-es/v1/database_service_pb.d.ts b/frontend/src/types/proto-es/v1/database_service_pb.d.tsindex 8c4b276869..b9c89a95c9 100644--- a/frontend/src/types/proto-es/v1/database_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/database_service_pb.d.ts@@ -3290,6 +3290,14 @@ export declare type Changelog = Message<"bytebase.v1.Changelog"> & {* @generated from field: bytebase.v1.Changelog.Type type = 17;*/type: Changelog_Type;++ /**+ * True if this changelog's dump version differs from current engine dump version.+ * When true and drift is detected, the drift may be a false positive from Bytebase upgrade.+ *+ * @generated from field: bool dump_version_mismatch = 18;+ */+ dumpVersionMismatch: boolean;};/**diff --git a/frontend/src/types/proto-es/v1/database_service_pb.js b/frontend/src/types/proto-es/v1/database_service_pb.jsindex 90fe866442..65415d5746 100644--- a/frontend/src/types/proto-es/v1/database_service_pb.js+++ b/frontend/src/types/proto-es/v1/database_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_instance_service } from "./instance_service_pb";* Describes the file v1/database_service.proto.*/export const file_v1_database_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);/*** Describes the message bytebase.v1.GetDatabaseRequest.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex 919d9ede58..c97ccd60d0 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -8893,6 +8893,11 @@ components:- SDLtype: stringformat: enum+ dumpVersionMismatch:+ type: boolean+ description: |-+ True if this changelog's dump version differs from current engine dump version.+ When true and drift is detected, the drift may be a false positive from Bytebase upgrade.CheckReleaseRequest:required:- parentdiff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex 1572dd49c3..d803d77ac6 100644--- a/proto/gen/grpc-doc/store/README.md+++ b/proto/gen/grpc-doc/store/README.md@@ -879,6 +879,7 @@ Metadata about the request.| version | [string](#string) | | || type | [ChangelogPayload.Type](#bytebase-store-ChangelogPayload-Type) | | || git_commit | [string](#string) | | |+| dump_version | [int32](#int32) | | Dump format version for drift detection reliability. Engine-specific version stored when baseline/migration is created. 0 = legacy changelog (pre-versioning). |diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.htmlindex 7082ae4e03..dbfca0a605 100644--- a/proto/gen/grpc-doc/store/index.html+++ b/proto/gen/grpc-doc/store/index.html@@ -2789,6 +2789,15 @@ Format: projects/{project}/sheets/{sheet} </p></td><td><p> </p></td></tr>+ <tr>+ <td>dump_version</td>+ <td><a href="#int32">int32</a></td>+ <td></td>+ <td><p>Dump format version for drift detection reliability.+Engine-specific version stored when baseline/migration is created.+0 = legacy changelog (pre-versioning). </p></td>+ </tr>+</tbody></table>diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex a501a6729c..0f39f3a3dd 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -5180,6 +5180,7 @@ BoundingBox defines the spatial bounds for GEOMETRY spatial indexes.| revision | [string](#string) | | Could be empty Or present but not found if deleted || changed_resources | [ChangedResources](#bytebase-v1-ChangedResources) | | || type | [Changelog.Type](#bytebase-v1-Changelog-Type) | | |+| dump_version_mismatch | [bool](#bool) | | True if this changelog's dump version differs from current engine dump version. When true and drift is detected, the drift may be a false positive from Bytebase upgrade. |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex 0fbfa039d5..a089fa58a4 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -14590,6 +14590,14 @@ Or present but not found if deleted </p></td><td><p> </p></td></tr>+ <tr>+ <td>dump_version_mismatch</td>+ <td><a href="#bool">bool</a></td>+ <td></td>+ <td><p>True if this changelog's dump version differs from current engine dump version.+When true and drift is detected, the drift may be a false positive from Bytebase upgrade. </p></td>+ </tr>+</tbody></table>diff --git a/proto/store/store/changelog.proto b/proto/store/store/changelog.protoindex 20fdf94281..e1dbaa9c55 100644--- a/proto/store/store/changelog.proto+++ b/proto/store/store/changelog.proto@@ -33,6 +33,11 @@ message ChangelogPayload {Type type = 7;string git_commit = 8;++ // Dump format version for drift detection reliability.+ // Engine-specific version stored when baseline/migration is created.+ // 0 = legacy changelog (pre-versioning).+ int32 dump_version = 9;}message ChangedResources {diff --git a/proto/v1/v1/database_service.proto b/proto/v1/v1/database_service.protoindex 09cc2630b8..c7083531eb 100644--- a/proto/v1/v1/database_service.proto+++ b/proto/v1/v1/database_service.proto@@ -1526,6 +1526,10 @@ message Changelog {SDL = 3;}Type type = 17;++ // True if this changelog's dump version differs from current engine dump version.+ // When true and drift is detected, the drift may be a false positive from Bytebase upgrade.+ bool dump_version_mismatch = 18;}message GetSchemaStringRequest {