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(mysql): column SRID and INVISIBLE round-trip fidelity (#20761)
h3n4la1abe02db258
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex 5f258ef9b6..a5c806018d 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -9583,6 +9583,20 @@ components:This field is populated when syncing from the database. When empty (e.g., when parsingfrom SQL files), the system cannot automatically drop the constraint.+ srid:+ type:+ - integer+ - "null"+ title: srid+ description: |-+ The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ Unset means the column declares no SRID; presence carries the explicit SRID,+ including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ int32).+ isInvisible:+ type: boolean+ title: is_invisible+ description: Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.title: ColumnMetadataadditionalProperties: falsedescription: ColumnMetadata is the metadata for columns.diff --git a/backend/api/v1/database_converter.go b/backend/api/v1/database_converter.goindex 321293141e..79c815fc47 100644--- a/backend/api/v1/database_converter.go+++ b/backend/api/v1/database_converter.go@@ -473,6 +473,8 @@ func convertStoreColumnMetadata(column *storepb.ColumnMetadata) *v1pb.ColumnMetaIdentityIncrement: column.IdentityIncrement,DefaultConstraintName: column.DefaultConstraintName,Default: column.Default,+ Srid: column.Srid,+ IsInvisible: column.IsInvisible,}switch column.IdentityGeneration {case storepb.ColumnMetadata_ALWAYS:@@ -1063,6 +1065,8 @@ func convertV1ColumnMetadata(column *v1pb.ColumnMetadata) *storepb.ColumnMetadatIdentityIncrement: column.IdentityIncrement,DefaultConstraintName: column.DefaultConstraintName,Default: column.Default,+ Srid: column.Srid,+ IsInvisible: column.IsInvisible,}switch column.IdentityGeneration {diff --git a/backend/api/v1/database_converter_test.go b/backend/api/v1/database_converter_test.gonew file mode 100644index 0000000000..73de62eaa4--- /dev/null+++ b/backend/api/v1/database_converter_test.go@@ -0,0 +1,128 @@+package v1++import (+ "strings"+ "testing"++ "github.com/stretchr/testify/require"++ 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/model"+)++func srid(v uint32) *uint32 { return &v }++// TestConvertColumnMetadataSRIDInvisibleRoundTrip closes gap (a) at the unit level: the+// v1 converters (convertStoreColumnMetadata store->v1, convertV1ColumnMetadata v1->store)+// must carry the spatial SRID (presence + value, including the valid explicit SRID 0) and+// the INVISIBLE flag in BOTH directions. Before the fix these converters silently dropped+// the fields, so any metadata crossing the v1 API boundary (Schema Editor, DiffMetadata)+// lost them.+func TestConvertColumnMetadataSRIDInvisibleRoundTrip(t *testing.T) {+ testCases := []struct {+ name string+ in *storepb.ColumnMetadata+ }{+ {+ name: "spatial_srid_4326",+ in: &storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(4326)},+ },+ {+ // Explicit SRID 0 is a valid spatial reference system, distinct from "no SRID".+ // Presence (not a zero sentinel) must survive the round-trip.+ name: "explicit_srid_zero",+ in: &storepb.ColumnMetadata{Name: "g", Type: "geometry", Nullable: false, Srid: srid(0)},+ },+ {+ // Custom SRSs may exceed int32 range; the value must not be squeezed.+ name: "srid_above_int32",+ in: &storepb.ColumnMetadata{Name: "g", Type: "geometry", Nullable: false, Srid: srid(3000000000)},+ },+ {+ name: "invisible_column",+ in: &storepb.ColumnMetadata{Name: "secret", Type: "int", Nullable: false, IsInvisible: true},+ },+ {+ // No SRID declared: presence must stay unset (nil), not collapse to SRID 0.+ name: "no_srid_visible",+ in: &storepb.ColumnMetadata{Name: "c", Type: "int", Nullable: true},+ },+ }+ for _, tc := range testCases {+ t.Run(tc.name, func(t *testing.T) {+ v1Col := convertStoreColumnMetadata(tc.in)+ // store -> v1 preserves the fields.+ if tc.in.Srid == nil {+ require.Nil(t, v1Col.Srid, "no-SRID column must stay unset after store->v1")+ } else {+ require.NotNil(t, v1Col.Srid)+ require.Equal(t, *tc.in.Srid, *v1Col.Srid)+ }+ require.Equal(t, tc.in.IsInvisible, v1Col.IsInvisible)++ // v1 -> store round-trips back to the original.+ out := convertV1ColumnMetadata(v1Col)+ if tc.in.Srid == nil {+ require.Nil(t, out.Srid, "no-SRID column must stay unset after v1->store")+ } else {+ require.NotNil(t, out.Srid)+ require.Equal(t, *tc.in.Srid, *out.Srid)+ }+ require.Equal(t, tc.in.IsInvisible, out.IsInvisible)+ })+ }+}++// TestDiffMetadataPreservesSRIDInvisible exercises the exact conversion + diff pipeline the+// DiffMetadata gRPC handler runs (convertV1DatabaseMetadata -> DiffMigration). A geometry+// column carrying SRID 4326 and an INVISIBLE column are unchanged between source and+// target while an UNRELATED attribute (the table comment on another column) is edited: the+// SRID/INVISIBLE fields must not be stripped by the v1->store conversion, so the diff shows+// only the intended change and never a spurious spatial/visibility MODIFY.+func TestDiffMetadataPreservesSRIDInvisible(t *testing.T) {+ mkV1 := func(noteComment string) *v1pb.DatabaseMetadata {+ return &v1pb.DatabaseMetadata{+ Schemas: []*v1pb.SchemaMetadata{{+ Name: "",+ Tables: []*v1pb.TableMetadata{{+ Name: "geo",+ Columns: []*v1pb.ColumnMetadata{+ {Name: "id", Type: "int", Nullable: false},+ {Name: "pt", Type: "point", Nullable: false, Srid: srid(4326)},+ {Name: "secret", Type: "int", Nullable: false, IsInvisible: true},+ {Name: "note", Type: "int", Nullable: true, Comment: noteComment},+ },+ }},+ }},+ }+ }++ // The v1->store conversion the handler performs must retain SRID + INVISIBLE.+ storeSource := convertV1DatabaseMetadata(mkV1("old"))+ cols := storeSource.Schemas[0].Tables[0].Columns+ require.NotNil(t, cols[1].Srid)+ require.Equal(t, uint32(4326), *cols[1].Srid)+ require.True(t, cols[2].IsInvisible)++ storeTarget := convertV1DatabaseMetadata(mkV1("new"))++ source := model.NewDatabaseMetadata(storeSource, nil, nil, storepb.Engine_MYSQL, true)+ target := model.NewDatabaseMetadata(storeTarget, nil, nil, storepb.Engine_MYSQL, true)+ diff, err := schema.DiffMigration(storepb.Engine_MYSQL, source, target)+ require.NoError(t, err)++ // The only change is the unrelated comment edit; SRID/INVISIBLE stay put, so the diff+ // must not touch the spatial SRID or column visibility.+ require.NotContains(t, diff, "SRID", "unrelated edit must not produce a spatial SRID change")+ require.NotContains(t, diff, "INVISIBLE", "unrelated edit must not produce a visibility change")++ // Sanity: an identical source/target yields no diff at all — the SRID/INVISIBLE columns+ // are stable under the v1<->store conversion (no phantom churn).+ same := model.NewDatabaseMetadata(convertV1DatabaseMetadata(mkV1("same")), nil, nil, storepb.Engine_MYSQL, true)+ sameDiff, err := schema.DiffMigration(storepb.Engine_MYSQL, same,+ model.NewDatabaseMetadata(convertV1DatabaseMetadata(mkV1("same")), nil, nil, storepb.Engine_MYSQL, true))+ require.NoError(t, err)+ require.Empty(t, strings.TrimSpace(sameDiff), "identical metadata must self-diff empty")+}diff --git a/backend/generated-go/store/database.pb.go b/backend/generated-go/store/database.pb.goindex 62968f2677..6055ee55d6 100644--- a/backend/generated-go/store/database.pb.go+++ b/backend/generated-go/store/database.pb.go@@ -2299,8 +2299,18 @@ type ColumnMetadata struct {// This field is populated when syncing from the database. When empty (e.g., when parsing// from SQL files), the system cannot automatically drop the constraint.DefaultConstraintName string `protobuf:"bytes,20,opt,name=default_constraint_name,json=defaultConstraintName,proto3" json:"default_constraint_name,omitempty"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache+ // The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ // Unset means the column declares no SRID; presence carries the explicit SRID,+ // including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ // int32). Captured from information_schema.COLUMNS.SRS_ID and rendered as the+ // `/*!80003 SRID n */` column attribute.+ Srid *uint32 `protobuf:"varint,21,opt,name=srid,proto3,oneof" json:"srid,omitempty"`+ // Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.+ // Captured from information_schema.COLUMNS.EXTRA containing INVISIBLE and+ // rendered as the `/*!80023 INVISIBLE */` column attribute.+ IsInvisible bool `protobuf:"varint,22,opt,name=is_invisible,json=isInvisible,proto3" json:"is_invisible,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache}func (x *ColumnMetadata) Reset() {@@ -2445,6 +2455,20 @@ func (x *ColumnMetadata) GetDefaultConstraintName() string {return ""}+func (x *ColumnMetadata) GetSrid() uint32 {+ if x != nil && x.Srid != nil {+ return *x.Srid+ }+ return 0+}++func (x *ColumnMetadata) GetIsInvisible() bool {+ if x != nil {+ return x.IsInvisible+ }+ return false+}+type GenerationMetadata struct {state protoimpl.MessageState `protogen:"open.v1"`Type GenerationMetadata_Type `protobuf:"varint,1,opt,name=type,proto3,enum=bytebase.store.GenerationMetadata_Type" json:"type,omitempty"`@@ -4857,7 +4881,7 @@ const file_store_database_proto_rawDesc = "" +"\vLINEAR_HASH\x10\x06\x12\a\n" +"\x03KEY\x10\a\x12\x0e\n" +"\n" +- "LINEAR_KEY\x10\b\"\xd8\x05\n" ++ "LINEAR_KEY\x10\b\"\x9d\x06\n" +"\x0eColumnMetadata\x12\x12\n" +"\x04name\x18\x01 \x01(\tR\x04name\x12\x1a\n" +"\bposition\x18\x02 \x01(\x05R\bposition\x12\x18\n" +@@ -4878,13 +4902,16 @@ const file_store_database_proto_rawDesc = "" +"\x13identity_generation\x18\x0f \x01(\x0e21.bytebase.store.ColumnMetadata.IdentityGenerationR\x12identityGeneration\x12#\n" +"\ridentity_seed\x18\x12 \x01(\x03R\fidentitySeed\x12-\n" +"\x12identity_increment\x18\x13 \x01(\x03R\x11identityIncrement\x126\n" +- "\x17default_constraint_name\x18\x14 \x01(\tR\x15defaultConstraintName\"U\n" ++ "\x17default_constraint_name\x18\x14 \x01(\tR\x15defaultConstraintName\x12\x17\n" ++ "\x04srid\x18\x15 \x01(\rH\x00R\x04srid\x88\x01\x01\x12!\n" ++ "\fis_invisible\x18\x16 \x01(\bR\visInvisible\"U\n" +"\x12IdentityGeneration\x12#\n" +"\x1fIDENTITY_GENERATION_UNSPECIFIED\x10\x00\x12\n" +"\n" +"\x06ALWAYS\x10\x01\x12\x0e\n" +"\n" +- "BY_DEFAULT\x10\x02\"\xb2\x01\n" ++ "BY_DEFAULT\x10\x02B\a\n" ++ "\x05_srid\"\xb2\x01\n" +"\x12GenerationMetadata\x12;\n" +"\x04type\x18\x01 \x01(\x0e2'.bytebase.store.GenerationMetadata.TypeR\x04type\x12\x1e\n" +"\n" +@@ -5267,6 +5294,7 @@ func file_store_database_proto_init() {if File_store_database_proto != nil {return}+ file_store_database_proto_msgTypes[16].OneofWrappers = []any{}file_store_database_proto_msgTypes[38].OneofWrappers = []any{}file_store_database_proto_msgTypes[39].OneofWrappers = []any{}file_store_database_proto_msgTypes[40].OneofWrappers = []any{diff --git a/backend/generated-go/store/database_equal.pb.go b/backend/generated-go/store/database_equal.pb.goindex 199e38d576..2247586fdf 100644--- a/backend/generated-go/store/database_equal.pb.go+++ b/backend/generated-go/store/database_equal.pb.go@@ -796,6 +796,12 @@ func (x *ColumnMetadata) Equal(y *ColumnMetadata) bool {if x.DefaultConstraintName != y.DefaultConstraintName {return false}+ if p, q := x.Srid, y.Srid; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {+ return false+ }+ if x.IsInvisible != y.IsInvisible {+ return false+ }return true}diff --git a/backend/generated-go/v1/database_service.pb.go b/backend/generated-go/v1/database_service.pb.goindex c6311d9755..e7369c27b6 100644--- a/backend/generated-go/v1/database_service.pb.go+++ b/backend/generated-go/v1/database_service.pb.go@@ -3046,8 +3046,15 @@ type ColumnMetadata struct {// This field is populated when syncing from the database. When empty (e.g., when parsing// from SQL files), the system cannot automatically drop the constraint.DefaultConstraintName string `protobuf:"bytes,17,opt,name=default_constraint_name,json=defaultConstraintName,proto3" json:"default_constraint_name,omitempty"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache+ // The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ // Unset means the column declares no SRID; presence carries the explicit SRID,+ // including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ // int32).+ Srid *uint32 `protobuf:"varint,18,opt,name=srid,proto3,oneof" json:"srid,omitempty"`+ // Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.+ IsInvisible bool `protobuf:"varint,19,opt,name=is_invisible,json=isInvisible,proto3" json:"is_invisible,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache}func (x *ColumnMetadata) Reset() {@@ -3199,6 +3206,20 @@ func (x *ColumnMetadata) GetDefaultConstraintName() string {return ""}+func (x *ColumnMetadata) GetSrid() uint32 {+ if x != nil && x.Srid != nil {+ return *x.Srid+ }+ return 0+}++func (x *ColumnMetadata) GetIsInvisible() bool {+ if x != nil {+ return x.IsInvisible+ }+ return false+}+type GenerationMetadata struct {state protoimpl.MessageState `protogen:"open.v1"`Type GenerationMetadata_Type `protobuf:"varint,1,opt,name=type,proto3,enum=bytebase.v1.GenerationMetadata_Type" json:"type,omitempty"`@@ -5810,7 +5831,7 @@ const file_v1_database_service_proto_rawDesc = "" +"\vLINEAR_HASH\x10\x06\x12\a\n" +"\x03KEY\x10\a\x12\x0e\n" +"\n" +- "LINEAR_KEY\x10\b\"\xf3\x05\n" ++ "LINEAR_KEY\x10\b\"\xb8\x06\n" +"\x0eColumnMetadata\x12\x12\n" +"\x04name\x18\x01 \x01(\tR\x04name\x12\x1a\n" +"\bposition\x18\x02 \x01(\x05R\bposition\x12\x1f\n" +@@ -5833,13 +5854,16 @@ const file_v1_database_service_proto_rawDesc = "" +"\x13identity_generation\x18\x0e \x01(\x0e2..bytebase.v1.ColumnMetadata.IdentityGenerationR\x12identityGeneration\x12#\n" +"\ridentity_seed\x18\x0f \x01(\x03R\fidentitySeed\x12-\n" +"\x12identity_increment\x18\x10 \x01(\x03R\x11identityIncrement\x126\n" +- "\x17default_constraint_name\x18\x11 \x01(\tR\x15defaultConstraintName\"U\n" ++ "\x17default_constraint_name\x18\x11 \x01(\tR\x15defaultConstraintName\x12\x17\n" ++ "\x04srid\x18\x12 \x01(\rH\x00R\x04srid\x88\x01\x01\x12!\n" ++ "\fis_invisible\x18\x13 \x01(\bR\visInvisible\"U\n" +"\x12IdentityGeneration\x12#\n" +"\x1fIDENTITY_GENERATION_UNSPECIFIED\x10\x00\x12\n" +"\n" +"\x06ALWAYS\x10\x01\x12\x0e\n" +"\n" +- "BY_DEFAULT\x10\x02\"\xa5\x01\n" ++ "BY_DEFAULT\x10\x02B\a\n" ++ "\x05_srid\"\xa5\x01\n" +"\x12GenerationMetadata\x128\n" +"\x04type\x18\x01 \x01(\x0e2$.bytebase.v1.GenerationMetadata.TypeR\x04type\x12\x1e\n" +"\n" +@@ -6327,6 +6351,7 @@ func file_v1_database_service_proto_init() {(*DiffSchemaRequest_Changelog)(nil),}file_v1_database_service_proto_msgTypes[17].OneofWrappers = []any{}+ file_v1_database_service_proto_msgTypes[28].OneofWrappers = []any{}type x struct{}out := protoimpl.TypeBuilder{File: protoimpl.DescBuilder{diff --git a/backend/generated-go/v1/database_service_equal.pb.go b/backend/generated-go/v1/database_service_equal.pb.goindex 4f5bc380ca..93cb083c74 100644--- a/backend/generated-go/v1/database_service_equal.pb.go+++ b/backend/generated-go/v1/database_service_equal.pb.go@@ -922,6 +922,12 @@ func (x *ColumnMetadata) Equal(y *ColumnMetadata) bool {if x.DefaultConstraintName != y.DefaultConstraintName {return false}+ if p, q := x.Srid, y.Srid; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {+ return false+ }+ if x.IsInvisible != y.IsInvisible {+ return false+ }return true}diff --git a/backend/plugin/db/mysql/sync.go b/backend/plugin/db/mysql/sync.goindex 6f8ba0ae1b..f50b1d57b8 100644--- a/backend/plugin/db/mysql/sync.go+++ b/backend/plugin/db/mysql/sync.go@@ -68,8 +68,8 @@ var (// after the numeric version, e.g. "-MariaDB", "-OceanBase-v4.2", "-TiDB-v7.5") denotes// a stock MySQL server. MySQL-compatible engines registered as MYSQL report MySQL-like// version numbers but do not implement every stock information_schema feature, so any-// stock-only query or decode (binary default encodings) must be gated on this single-// predicate.+// stock-only query or decode (SRS_ID column select, binary default encodings, column+// INVISIBLE capture) must be gated on this single predicate.func isStockMySQL(versionSuffix string) bool {return !strings.Contains(versionSuffix, "MariaDB") &&!strings.Contains(versionSuffix, "OceanBase") &&@@ -202,6 +202,7 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetadreturn nil, errors.Wrapf(err, "failed to parse MySQL version %s to semantic version", version)}atLeast800 := semVersion.GE(semver.MustParse("8.0.0"))+ atLeast803 := semVersion.GE(semver.MustParse("8.0.3"))atLeast8_0_13 := semVersion.GE(semver.MustParse("8.0.13"))atLeast8_0_16 := semVersion.GE(semver.MustParse("8.0.16"))atLeast5_7_0 := semVersion.GE(semver.MustParse("5.7.0"))@@ -327,8 +328,17 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetad}// Query column info.+ // SRS_ID (spatial reference id) was added to information_schema.COLUMNS in stock+ // MySQL 8.0.3 (the same version encoded by the /*!80003 SRID */ renderer). Stock+ // 8.0.0–8.0.2 lack it, as do 5.7/5.6, MariaDB, OceanBase, and TiDB (which may report+ // an 8.x MySQL-compat version), so selecting it there would fail the whole sync —+ // they select NULL instead.columnMap := make(map[db.TableKey][]*storepb.ColumnMetadata)- columnQuery := `+ sridSelect := "NULL"+ if atLeast803 && stockMySQL {+ sridSelect = "SRS_ID"+ }+ columnQuery := fmt.Sprintf(`SELECTTABLE_NAME,IFNULL(COLUMN_NAME, ''),@@ -340,13 +350,14 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetadIFNULL(COLLATION_NAME, ''),QUOTE(COLUMN_COMMENT),convert(GENERATION_EXPRESSION using BINARY),- EXTRA+ EXTRA,+ %sFROM information_schema.COLUMNSWHERE TABLE_SCHEMA = ?- ORDER BY TABLE_NAME, ORDINAL_POSITION`+ ORDER BY TABLE_NAME, ORDINAL_POSITION`, sridSelect)if !atLeast5_7_0 {// GENERATION_EXPRESSION does not exist in MySQL 5.6.- columnQuery = `+ columnQuery = fmt.Sprintf(`SELECTTABLE_NAME,IFNULL(COLUMN_NAME, ''),@@ -358,10 +369,11 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetadIFNULL(COLLATION_NAME, ''),QUOTE(COLUMN_COMMENT),NULL,- EXTRA+ EXTRA,+ %sFROM information_schema.COLUMNSWHERE TABLE_SCHEMA = ?- ORDER BY TABLE_NAME, ORDINAL_POSITION`+ ORDER BY TABLE_NAME, ORDINAL_POSITION`, sridSelect)}columnRows, err := d.db.QueryContext(ctx, columnQuery, d.databaseName)if err != nil {@@ -373,6 +385,7 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetadvar tableName, nullable, extra, tp stringvar defaultStr sql.NullStringvar generationExpr []byte+ var srid sql.NullInt64if err := columnRows.Scan(&tableName,&column.Name,@@ -385,6 +398,7 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetad&column.Comment,&generationExpr,&extra,+ &srid,); err != nil {return nil, err}@@ -397,6 +411,22 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetadcolumn.Type = GetColumnTypeCanonicalSynonym(tp)column.Nullable = nullableBoolsetColumnMetadataDefault(column, defaultStr, nullableBool, extra, binaryDefaultFmt)+ // SRID presence tracks SRS_ID being non-NULL: spatial columns with an explicit+ // SRID (MySQL 8.0), INCLUDING the valid SRID 0. SRS_IDs are unsigned 32-bit, so+ // the value must not be squeezed through int32 (custom SRSs may be >= 2^31).+ if srid.Valid {+ v := uint32(srid.Int64)+ column.Srid = &v+ }+ // A user-declared INVISIBLE column surfaces as the INVISIBLE token in EXTRA+ // (MySQL 8.0.23+). Captured on stock MySQL only: MariaDB 10.3+ also reports+ // INVISIBLE in EXTRA, but the writers emit the MySQL-versioned+ // /*!80023 INVISIBLE */ form, which MariaDB ignores — capturing there would+ // yield a permanently non-converging diff. On stock MySQL the dumper re-emits+ // the attribute and the declarative diff stays a no-op.+ if stockMySQL && isInvisibleColumnExtra(extra) {+ column.IsInvisible = true+ }key := db.TableKey{Schema: "", Table: tableName}columnMap[key] = append(columnMap[key], column)invisible := containsInvisibleChars(generationExpr)@@ -1231,6 +1261,21 @@ func isCleanDefaultText(value []byte) bool {return true}+// isInvisibleColumnExtra reports whether the information_schema.COLUMNS.EXTRA value+// carries the standalone INVISIBLE token (MySQL 8.0.23+; MariaDB 10.3+ reports the+// same token, but the capture site gates on isStockMySQL — see SyncDBSchema). EXTRA+// can hold several space-separated tokens (e.g. "VIRTUAL GENERATED INVISIBLE" or+// "DEFAULT_GENERATED on update CURRENT_TIMESTAMP INVISIBLE"), so the token is matched+// as a whole field rather than a substring.+func isInvisibleColumnExtra(extra string) bool {+ for _, tok := range strings.Fields(extra) {+ if strings.EqualFold(tok, "INVISIBLE") {+ return true+ }+ }+ return false+}+// UnescapeExpressionDefault unescapes the default expression for MySQL.// This handles the second layer of escaping that MySQL applies when storing// expression defaults (like DEFAULT (UUID())) in system catalogs.diff --git a/backend/plugin/db/mysql/sync_test.go b/backend/plugin/db/mysql/sync_test.goindex 3447178908..afc9ab0cc2 100644--- a/backend/plugin/db/mysql/sync_test.go+++ b/backend/plugin/db/mysql/sync_test.go@@ -737,9 +737,10 @@ func TestGetViewDefFromCreateView(t *testing.T) {}// TestIsStockMySQL pins the single stock-MySQL predicate gating stock-only-// information_schema surfaces (the binary-default decode): MariaDB, OceanBase, and TiDB-// report MySQL-like versions but lack them, so a compatible engine registered as MYSQL-// must not trip the stock-only queries.+// information_schema surfaces (the SRS_ID column select, the binary-default decode,+// and the column INVISIBLE capture): MariaDB, OceanBase, and TiDB report MySQL-like+// versions but lack them, so a compatible engine registered as MYSQL must not trip+// the stock-only queries.func TestIsStockMySQL(t *testing.T) {testCases := []struct {rest string@@ -757,6 +758,36 @@ func TestIsStockMySQL(t *testing.T) {}}+// TestInvisibleColumnCaptureGate pins the SyncDBSchema column-scan condition+// (stockMySQL && isInvisibleColumnExtra): MariaDB 10.3+ reports the same INVISIBLE+// token in information_schema.COLUMNS.EXTRA, but the writers emit only the+// MySQL-versioned /*!80023 INVISIBLE */ form, which MariaDB ignores — capturing the+// attribute there would produce a permanently non-converging declarative diff, so it+// is captured on stock MySQL only.+func TestInvisibleColumnCaptureGate(t *testing.T) {+ testCases := []struct {+ rest string+ extra string+ want bool+ }{+ // Stock MySQL 8.0.23+ captures the attribute.+ {rest: "", extra: "INVISIBLE", want: true},+ {rest: "-log", extra: "DEFAULT_GENERATED on update CURRENT_TIMESTAMP INVISIBLE", want: true},+ {rest: "", extra: "VIRTUAL GENERATED INVISIBLE", want: true},+ {rest: "", extra: "", want: false},+ {rest: "", extra: "auto_increment", want: false},+ // MariaDB reports INVISIBLE in EXTRA too, but must not capture it.+ {rest: "-MariaDB-1:10.6.12+maria~ubu2004", extra: "INVISIBLE", want: false},+ // OceanBase/TiDB report MySQL-like versions; never capture there either.+ {rest: "-OceanBase-v4.2.1", extra: "INVISIBLE", want: false},+ {rest: "-TiDB-v7.5.0", extra: "INVISIBLE", want: false},+ }+ for _, tc := range testCases {+ got := isStockMySQL(tc.rest) && isInvisibleColumnExtra(tc.extra)+ require.Equal(t, tc.want, got, "rest=%q extra=%q", tc.rest, tc.extra)+ }+}+func TestUnescapeCheckClause(t *testing.T) {testCases := []struct {clause stringdiff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.goindex c9e7447f7a..52d1f2aa4e 100644--- a/backend/plugin/schema/differ.go+++ b/backend/plugin/schema/differ.go@@ -680,6 +680,15 @@ func columnsEqual(engine storepb.Engine, col1, col2 *storepb.ColumnMetadata) booif col1.IdentitySeed != col2.IdentitySeed {return false}+ // Compare spatial SRID (MySQL 8.0): presence + value — SRID 0 is a valid explicit+ // SRID, distinct from "no SRID declared".+ if (col1.Srid == nil) != (col2.Srid == nil) || col1.GetSrid() != col2.GetSrid() {+ return false+ }+ // Compare column invisibility (MySQL 8.0.23+).+ if col1.IsInvisible != col2.IsInvisible {+ return false+ }return true}diff --git a/backend/plugin/schema/mysql/generate_migration.go b/backend/plugin/schema/mysql/generate_migration.goindex c78ec9a5c6..2531e410b8 100644--- a/backend/plugin/schema/mysql/generate_migration.go+++ b/backend/plugin/schema/mysql/generate_migration.go@@ -530,59 +530,10 @@ func writeCreateTableWithoutForeignKeys(buf *strings.Builder, tableName string,_, _ = buf.WriteString(" `")_, _ = buf.WriteString(col.Name)_, _ = buf.WriteString("` ")- _, _ = buf.WriteString(col.Type)-- if col.CharacterSet != "" {- _, _ = buf.WriteString(" CHARACTER SET ")- _, _ = buf.WriteString(col.CharacterSet)- }- if col.Collation != "" {- _, _ = buf.WriteString(" COLLATE ")- _, _ = buf.WriteString(col.Collation)- }-- if !col.Nullable {- _, _ = buf.WriteString(" NOT NULL")- }-- // Handle AUTO_INCREMENT before default value- if hasAutoIncrement(col) {- _, _ = buf.WriteString(" AUTO_INCREMENT")- } else if hasDefaultValue(col) && !hasAutoIncrement(col) && col.Generation == nil {- // Don't add DEFAULT if this is a generated column- if e := getDefaultExpression(col); e != "" {- _, _ = buf.WriteString(" DEFAULT ")- _, _ = buf.WriteString(e)- }- }-- // Handle ON UPDATE- if col.OnUpdate != "" {- _, _ = buf.WriteString(" ON UPDATE ")- _, _ = buf.WriteString(col.OnUpdate)- }-- // Handle generated columns- if col.Generation != nil && col.Generation.Expression != "" {- _, _ = buf.WriteString(" GENERATED ALWAYS AS (")- _, _ = buf.WriteString(col.Generation.Expression)- _, _ = buf.WriteString(") ")- switch col.Generation.Type {- case storepb.GenerationMetadata_TYPE_STORED:- _, _ = buf.WriteString("STORED")- case storepb.GenerationMetadata_TYPE_VIRTUAL:- _, _ = buf.WriteString("VIRTUAL")- default:- // Default to VIRTUAL for unknown types- _, _ = buf.WriteString("VIRTUAL")- }- }-- if col.Comment != "" {- _, _ = buf.WriteString(" COMMENT '")- _, _ = buf.WriteString(col.Comment)- _, _ = buf.WriteString("'")- }+ // Reuse the shared column-definition body so the inline CREATE TABLE and the+ // ADD/MODIFY COLUMN paths emit the same canonical attribute order (notably the+ // generated-column ordering: GENERATED ALWAYS AS (...) precedes NOT NULL/SRID).+ writeColumnDefinitionBody(buf, col)}// Write primary key constraint inline if exists@@ -669,12 +620,14 @@ func writeCreateTableWithoutForeignKeys(buf *strings.Builder, tableName string,return nil}-func writeAddColumn(buf *strings.Builder, table string, column *storepb.ColumnMetadata) error {- _, _ = buf.WriteString("ALTER TABLE `")- _, _ = buf.WriteString(table)- _, _ = buf.WriteString("` ADD COLUMN `")- _, _ = buf.WriteString(column.Name)- _, _ = buf.WriteString("` ")+// writeColumnDefinitionBody emits the column definition following the leading+// “ `name` “ — the type and every attribute in canonical order. MySQL's grammar puts+// the attributes in a different order for a generated column (the GENERATED ALWAYS AS+// clause precedes NOT NULL and SRID) than for a regular column, so the body branches on+// column.Generation. Both branches emit INVISIBLE before COMMENT, matching MySQL's+// canonical SHOW CREATE order. Shared by writeAddColumn (ADD COLUMN) and writeModifyColumn+// (MODIFY COLUMN), which differ only in the leading clause.+func writeColumnDefinitionBody(buf *strings.Builder, column *storepb.ColumnMetadata) {_, _ = buf.WriteString(column.Type)if column.CharacterSet != "" {@@ -686,15 +639,23 @@ func writeAddColumn(buf *strings.Builder, table string, column *storepb.ColumnMe_, _ = buf.WriteString(column.Collation)}+ if column.Generation != nil && column.Generation.Expression != "" {+ writeGeneratedColumnAttributes(buf, column)+ return+ }+if !column.Nullable {_, _ = buf.WriteString(" NOT NULL")}+ // Spatial SRID (MySQL 8.0): after NOT NULL, before DEFAULT — the SDL dumper's+ // canonical position (see printColumnClause).+ writeColumnSRIDAttribute(buf, column)+// Handle AUTO_INCREMENT before default valueif hasAutoIncrement(column) {_, _ = buf.WriteString(" AUTO_INCREMENT")- } else if hasDefaultValue(column) && !hasAutoIncrement(column) && column.Generation == nil {- // Don't add DEFAULT if this is a generated column+ } else if hasDefaultValue(column) && !hasAutoIncrement(column) {_, _ = buf.WriteString(" DEFAULT ")_, _ = buf.WriteString(getDefaultExpression(column))}@@ -705,91 +666,81 @@ func writeAddColumn(buf *strings.Builder, table string, column *storepb.ColumnMe_, _ = buf.WriteString(column.OnUpdate)}- // Handle generated columns- if column.Generation != nil && column.Generation.Expression != "" {- _, _ = buf.WriteString(" GENERATED ALWAYS AS (")- _, _ = buf.WriteString(column.Generation.Expression)- _, _ = buf.WriteString(") ")- switch column.Generation.Type {- case storepb.GenerationMetadata_TYPE_STORED:- _, _ = buf.WriteString("STORED")- case storepb.GenerationMetadata_TYPE_VIRTUAL:- _, _ = buf.WriteString("VIRTUAL")- default:- // Default to VIRTUAL for unknown types- _, _ = buf.WriteString("VIRTUAL")- }- }+ // INVISIBLE column (MySQL 8.0.23+): before COMMENT, matching the SHOW CREATE canonical+ // order and the SDL dumper (printColumnClause).+ writeColumnInvisibleAttribute(buf, column)if column.Comment != "" {_, _ = buf.WriteString(" COMMENT '")_, _ = buf.WriteString(column.Comment)_, _ = buf.WriteString("'")}-- // TODO: Add column position support (FIRST, AFTER column_name)-- _, _ = buf.WriteString(";\n\n")- return nil}-func writeModifyColumn(buf *strings.Builder, table string, column *storepb.ColumnMetadata) error {- _, _ = buf.WriteString("ALTER TABLE `")- _, _ = buf.WriteString(table)- _, _ = buf.WriteString("` MODIFY COLUMN `")- _, _ = buf.WriteString(column.Name)- _, _ = buf.WriteString("` ")- _, _ = buf.WriteString(column.Type)-- if column.CharacterSet != "" {- _, _ = buf.WriteString(" CHARACTER SET ")- _, _ = buf.WriteString(column.CharacterSet)- }- if column.Collation != "" {- _, _ = buf.WriteString(" COLLATE ")- _, _ = buf.WriteString(column.Collation)+// writeGeneratedColumnAttributes emits the attributes of a generated column (type and+// charset/collation already written) in MySQL's canonical order:+//+// GENERATED ALWAYS AS (expr) STORED|VIRTUAL [NOT NULL] [SRID] [INVISIBLE] [COMMENT]+//+// The GENERATED ALWAYS AS clause must precede NOT NULL and the SRID attribute — the+// order the current MySQL grammar accepts and that SHOW CREATE emits (verified against+// 8.0.32). INVISIBLE precedes COMMENT, matching MySQL's canonical order for both regular+// and generated columns. Generated columns never carry DEFAULT / AUTO_INCREMENT / ON+// UPDATE, so those clauses are intentionally omitted.+func writeGeneratedColumnAttributes(buf *strings.Builder, column *storepb.ColumnMetadata) {+ _, _ = buf.WriteString(" GENERATED ALWAYS AS (")+ _, _ = buf.WriteString(column.Generation.Expression)+ _, _ = buf.WriteString(") ")+ switch column.Generation.Type {+ case storepb.GenerationMetadata_TYPE_STORED:+ _, _ = buf.WriteString("STORED")+ case storepb.GenerationMetadata_TYPE_VIRTUAL:+ _, _ = buf.WriteString("VIRTUAL")+ default:+ // Default to VIRTUAL for unknown types+ _, _ = buf.WriteString("VIRTUAL")}if !column.Nullable {_, _ = buf.WriteString(" NOT NULL")}- // Handle AUTO_INCREMENT before default value- if hasAutoIncrement(column) {- _, _ = buf.WriteString(" AUTO_INCREMENT")- } else if hasDefaultValue(column) && !hasAutoIncrement(column) && column.Generation == nil {- // Don't add DEFAULT if this is a generated column- _, _ = buf.WriteString(" DEFAULT ")- _, _ = buf.WriteString(getDefaultExpression(column))- }-- // Handle ON UPDATE- if column.OnUpdate != "" {- _, _ = buf.WriteString(" ON UPDATE ")- _, _ = buf.WriteString(column.OnUpdate)- }+ // Spatial SRID (MySQL 8.0): after NOT NULL for a generated column, matching the+ // SHOW CREATE canonical position.+ writeColumnSRIDAttribute(buf, column)- // Handle generated columns- if column.Generation != nil && column.Generation.Expression != "" {- _, _ = buf.WriteString(" GENERATED ALWAYS AS (")- _, _ = buf.WriteString(column.Generation.Expression)- _, _ = buf.WriteString(") ")- switch column.Generation.Type {- case storepb.GenerationMetadata_TYPE_STORED:- _, _ = buf.WriteString("STORED")- case storepb.GenerationMetadata_TYPE_VIRTUAL:- _, _ = buf.WriteString("VIRTUAL")- default:- // Default to VIRTUAL for unknown types- _, _ = buf.WriteString("VIRTUAL")- }- }+ // INVISIBLE column (MySQL 8.0.23+): for a generated column this precedes COMMENT,+ // matching the SHOW CREATE canonical order.+ writeColumnInvisibleAttribute(buf, column)if column.Comment != "" {_, _ = buf.WriteString(" COMMENT '")_, _ = buf.WriteString(column.Comment)_, _ = buf.WriteString("'")}+}++func writeAddColumn(buf *strings.Builder, table string, column *storepb.ColumnMetadata) error {+ _, _ = buf.WriteString("ALTER TABLE `")+ _, _ = buf.WriteString(table)+ _, _ = buf.WriteString("` ADD COLUMN `")+ _, _ = buf.WriteString(column.Name)+ _, _ = buf.WriteString("` ")+ writeColumnDefinitionBody(buf, column)++ // TODO: Add column position support (FIRST, AFTER column_name)++ _, _ = buf.WriteString(";\n\n")+ return nil+}++func writeModifyColumn(buf *strings.Builder, table string, column *storepb.ColumnMetadata) error {+ _, _ = buf.WriteString("ALTER TABLE `")+ _, _ = buf.WriteString(table)+ _, _ = buf.WriteString("` MODIFY COLUMN `")+ _, _ = buf.WriteString(column.Name)+ _, _ = buf.WriteString("` ")+ writeColumnDefinitionBody(buf, column)_, _ = buf.WriteString(";\n\n")return nildiff --git a/backend/plugin/schema/mysql/get_database_definition.go b/backend/plugin/schema/mysql/get_database_definition.goindex dc314e9253..bbf9b9ac02 100644--- a/backend/plugin/schema/mysql/get_database_definition.go+++ b/backend/plugin/schema/mysql/get_database_definition.go@@ -1230,6 +1230,12 @@ func printColumnClause(buf *strings.Builder, column *storepb.ColumnMetadata, tab}}+ // SRID for spatial columns (MySQL 8.0). Emitted after NOT NULL and before DEFAULT to+ // match the SHOW CREATE / omni-canonical position; the version-gated executable comment+ // is spliced back as live SQL by omni's loader so the dumped `from` carries the SRID and+ // the diff against a user `to` with the same SRID is a no-op.+ writeColumnSRIDAttribute(buf, column)+if err := printDefaultClause(buf, column); err != nil {return err}@@ -1246,15 +1252,42 @@ func printColumnClause(buf *strings.Builder, column *storepb.ColumnMetadata, tabreturn err}}++ // INVISIBLE column (MySQL 8.0.23+). Emitted before COMMENT to match the SHOW CREATE /+ // omni-canonical order (verified against 8.0.32 for both regular and generated columns);+ // like SRID the version-gated comment is parsed back by omni's loader so the dumped `from`+ // carries invisibility and the diff against an INVISIBLE user `to` is a no-op.+ writeColumnInvisibleAttribute(buf, column)+if column.Comment != "" {if _, err := fmt.Fprintf(buf, " COMMENT '%s'", column.Comment); err != nil {return err}}-return nil}+// writeColumnSRIDAttribute emits the ` /*!80003 SRID n */` column attribute when the+// column carries an explicit SRID — including the valid SRID 0, which presence (not a+// zero sentinel) distinguishes from "no SRID". Shared by the SDL dumper+// (printColumnClause) and the legacy migration generator (writeAddColumn /+// writeModifyColumn) so both render the same canonical form.+func writeColumnSRIDAttribute(buf *strings.Builder, column *storepb.ColumnMetadata) {+ if column.Srid != nil {+ _, _ = fmt.Fprintf(buf, " /*!80003 SRID %d */", column.GetSrid())+ }+}++// writeColumnInvisibleAttribute emits the ` /*!80023 INVISIBLE */` column attribute for+// invisible columns (MySQL 8.0.23+). MySQL's canonical SHOW CREATE order places INVISIBLE+// before COMMENT for both regular and generated columns (verified against 8.0.32), so callers+// emit it before COMMENT. Shared by the SDL dumper and the legacy migration generator.+func writeColumnInvisibleAttribute(buf *strings.Builder, column *storepb.ColumnMetadata) {+ if column.IsInvisible {+ _, _ = buf.WriteString(" /*!80023 INVISIBLE */")+ }+}+// normalizeColumnType rewrites engine-specific column-type spellings the omni SDL parser// does not accept into the canonical spelling it does. MySQL 8.0's SHOW CREATE /// information_schema render GEOMETRYCOLLECTION as the synonym `geomcollection`, which thediff --git a/backend/plugin/schema/mysql/get_database_definition_test.go b/backend/plugin/schema/mysql/get_database_definition_test.goindex ea82bb6800..22d7b0c63a 100644--- a/backend/plugin/schema/mysql/get_database_definition_test.go+++ b/backend/plugin/schema/mysql/get_database_definition_test.go@@ -357,3 +357,114 @@ func TestStripLeadingDefiner(t *testing.T) {})}}++// TestPrintColumnClauseSRIDPresence pins the presence semantics of the SRID attribute+// (X5): explicit SRID 0 must be emitted (it is a valid spatial reference system,+// distinct from "no SRID"), and an unset SRID emits nothing.+func TestPrintColumnClauseSRIDPresence(t *testing.T) {+ srid := func(v uint32) *uint32 { return &v }+ table := &storepb.TableMetadata{Name: "t"}++ render := func(col *storepb.ColumnMetadata) string {+ var buf strings.Builder+ require.NoError(t, printColumnClause(&buf, col, table))+ return buf.String()+ }++ require.Equal(t, " `pt` point NOT NULL /*!80003 SRID 0 */",+ render(&storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(0)}))+ require.Equal(t, " `pt` point NOT NULL /*!80003 SRID 4326 */",+ render(&storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(4326)}))+ // Custom SRSs above int32 range must render unmangled.+ require.Equal(t, " `pt` point NOT NULL /*!80003 SRID 3000000000 */",+ render(&storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(3000000000)}))+ require.Equal(t, " `pt` point NOT NULL",+ render(&storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false}))+}++// TestPrintColumnClauseInvisibleCommentOrder pins the SDL dumper's INVISIBLE/COMMENT order+// (BYT-9830). MySQL's canonical SHOW CREATE emits INVISIBLE before COMMENT for both regular+// and generated columns (verified against 8.0.32), so the dumped form must match — otherwise+// the dump diverges from SHOW CREATE and from the migration generator's generated-column path.+func TestPrintColumnClauseInvisibleCommentOrder(t *testing.T) {+ srid := func(v uint32) *uint32 { return &v }+ table := &storepb.TableMetadata{Name: "t"}++ render := func(col *storepb.ColumnMetadata) string {+ var buf strings.Builder+ require.NoError(t, printColumnClause(&buf, col, table))+ return buf.String()+ }++ // Regular INVISIBLE + COMMENT column: INVISIBLE precedes COMMENT.+ require.Equal(t, " `a` int DEFAULT NULL /*!80023 INVISIBLE */ COMMENT 'c'",+ render(&storepb.ColumnMetadata{Name: "a", Type: "int", Nullable: true, Default: "NULL", IsInvisible: true, Comment: "c"}))++ // Generated spatial INVISIBLE + COMMENT column: same canonical INVISIBLE-before-COMMENT order.+ require.Equal(t,+ " `loc` point GENERATED ALWAYS AS (st_srid(point(`lng`,`lat`),4326)) STORED NOT NULL /*!80003 SRID 4326 */ /*!80023 INVISIBLE */ COMMENT 'geo'",+ render(&storepb.ColumnMetadata{Name: "loc", Type: "point", Nullable: false, Srid: srid(4326), IsInvisible: true, Comment: "geo", Generation: &storepb.GenerationMetadata{+ Type: storepb.GenerationMetadata_TYPE_STORED,+ Expression: "st_srid(point(`lng`,`lat`),4326)",+ }}))+}++// TestWriteColumnDefinitionBodyGeneratedOrder pins the migration generator's attribute+// order for a generated column (BYT-9830). MySQL's grammar requires the+// `GENERATED ALWAYS AS (...) STORED|VIRTUAL` clause to precede NOT NULL and the SRID+// attribute; emitting SRID/NOT NULL first (the prior order) is rejected with ERROR 1064+// for a generated spatial column. The canonical order — verified against MySQL 8.0.32+// via SHOW CREATE — is:+//+// type GENERATED ALWAYS AS (expr) STORED|VIRTUAL [NOT NULL] [SRID] [INVISIBLE] [COMMENT]+func TestWriteColumnDefinitionBodyGeneratedOrder(t *testing.T) {+ srid := func(v uint32) *uint32 { return &v }+ stored := &storepb.GenerationMetadata{+ Type: storepb.GenerationMetadata_TYPE_STORED,+ Expression: "st_srid(point(`lng`,`lat`),4326)",+ }++ render := func(col *storepb.ColumnMetadata) string {+ var buf strings.Builder+ writeColumnDefinitionBody(&buf, col)+ return buf.String()+ }++ // Generated spatial column, NOT NULL + SRID — the failing case. The generation clause+ // must come first, then NOT NULL, then SRID.+ require.Equal(t,+ "point GENERATED ALWAYS AS (st_srid(point(`lng`,`lat`),4326)) STORED NOT NULL /*!80003 SRID 4326 */",+ render(&storepb.ColumnMetadata{Name: "loc", Type: "point", Nullable: false, Srid: srid(4326), Generation: stored}))++ // Nullable generated spatial column: no NOT NULL, SRID still after the generation clause.+ require.Equal(t,+ "point GENERATED ALWAYS AS (st_srid(point(`lng`,`lat`),4326)) STORED /*!80003 SRID 0 */",+ render(&storepb.ColumnMetadata{Name: "loc", Type: "point", Nullable: true, Srid: srid(0), Generation: stored}))++ // Generated spatial column that is also INVISIBLE and has a COMMENT: INVISIBLE precedes+ // COMMENT, matching SHOW CREATE's canonical order for both regular and generated columns.+ require.Equal(t,+ "point GENERATED ALWAYS AS (st_srid(point(`lng`,`lat`),4326)) STORED NOT NULL /*!80003 SRID 4326 */ /*!80023 INVISIBLE */ COMMENT 'geo'",+ render(&storepb.ColumnMetadata{Name: "loc", Type: "point", Nullable: false, Srid: srid(4326), IsInvisible: true, Comment: "geo", Generation: stored}))++ // Regular (non-generated) INVISIBLE column with a COMMENT: INVISIBLE precedes COMMENT,+ // the same canonical order as the generated column above (verified against 8.0.32).+ require.Equal(t,+ "int DEFAULT NULL /*!80023 INVISIBLE */ COMMENT 'c'",+ render(&storepb.ColumnMetadata{Name: "a", Type: "int", Nullable: true, Default: "NULL", IsInvisible: true, Comment: "c"}))++ // Plain (non-spatial) VIRTUAL generated column still emits the generation clause and+ // nothing spurious.+ require.Equal(t,+ "int GENERATED ALWAYS AS (`a` + 1) VIRTUAL",+ render(&storepb.ColumnMetadata{Name: "b", Type: "int", Nullable: true, Generation: &storepb.GenerationMetadata{+ Type: storepb.GenerationMetadata_TYPE_VIRTUAL,+ Expression: "`a` + 1",+ }}))++ // Regression: a non-generated NOT NULL spatial column keeps the regular order+ // (NOT NULL then SRID, no generation clause).+ require.Equal(t,+ "point NOT NULL /*!80003 SRID 4326 */",+ render(&storepb.ColumnMetadata{Name: "loc", Type: "point", Nullable: false, Srid: srid(4326)}))+}diff --git a/backend/plugin/schema/mysql/sdl_deep_stress_test.go b/backend/plugin/schema/mysql/sdl_deep_stress_test.goindex 26ae4e38c1..a795891c64 100644--- a/backend/plugin/schema/mysql/sdl_deep_stress_test.go+++ b/backend/plugin/schema/mysql/sdl_deep_stress_test.go@@ -403,6 +403,20 @@ func exoticCases() []exoticCase {SPATIAL KEY idx_pt (pt)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`,},+ {+ name: "spatial_srid_80",+ only80: true, // SRID column attribute is 8.0+ // FIXED (bug 6 + bug 7): sync now captures the column SRID (information_schema.COLUMNS.SRS_ID+ // into ColumnMetadata.srid) and the dumper emits `/*!80003 SRID 4326 */` after NOT NULL,+ // while the spatial-key prefix is suppressed (bug 7). Both halves of the former no-op are+ // gone, so the dump round-trips empty.+ ddl: `CREATE TABLE t (+ id INT NOT NULL AUTO_INCREMENT,+ pt POINT NOT NULL SRID 4326,+ PRIMARY KEY (id),+ SPATIAL KEY idx_pt (pt)+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`,+ },// ---- Fractional seconds ----{@@ -584,7 +598,19 @@ func exoticCases() []exoticCase {) ENGINE=InnoDB AUTO_INCREMENT=500 DEFAULT CHARSET=utf8mb4;`,},- // ---- Invisible indexes (8.0) ----+ // ---- Invisible columns / indexes (8.0) ----+ {+ name: "invisible_column_80",+ only80: true,+ // FIXED (bug 4): sync now captures column invisibility (information_schema.COLUMNS.EXTRA+ // INVISIBLE token into ColumnMetadata.is_invisible) and the dumper emits+ // `/*!80023 INVISIBLE */`, so the no-op is empty.+ ddl: `CREATE TABLE t (+ id INT PRIMARY KEY,+ a INT NOT NULL DEFAULT 0,+ secret INT INVISIBLE NOT NULL DEFAULT 0+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;`,+ },{name: "invisible_index_80",only80: true,@@ -667,8 +693,9 @@ func TestSDLDeepExoticIdempotence(t *testing.T) {// to int64 max in the diff — would change the default on apply).// - Default-literal canonicalization phantoms (re-emit every no-op): bit_type (BIT b'..'),// year_and_set (YEAR numeric-vs-quoted).-// - Dumper drops a real attribute (re-emit every no-op): invisible_index_80,-// spatial_notnull_index (phantom spatial-key prefix length).+// - Dumper drops a real attribute (re-emit every no-op): invisible_column_80,+// invisible_index_80, spatial_srid_80 (SRID), spatial_notnull_index / spatial_srid_80+// (phantom spatial-key prefix length).// - Dumper emits a spelling the omni parser can't reload (HARD error): spatial_types// (`geomcollection`), json_multivalue_index_80 (charset introducer in the functional key).//diff --git a/backend/plugin/schema/mysql/sdl_enterprise_statefuzz_test.go b/backend/plugin/schema/mysql/sdl_enterprise_statefuzz_test.goindex a205b4f47d..259f7ec118 100644--- a/backend/plugin/schema/mysql/sdl_enterprise_statefuzz_test.go+++ b/backend/plugin/schema/mysql/sdl_enterprise_statefuzz_test.go@@ -24,9 +24,10 @@ package mysql// match the mutation ledger exactly.//// The menu is the A4 menu PLUS (8.0-only where marked): add/drop CHECK constraint (8.0),-// add/drop FULLTEXT index, add/modify/drop STORED and VIRTUAL generated columns, toggle-// index INVISIBLE (8.0), and ENUM member append. 5.7-illegal mutations are gated off the-// 5.7 menu.+// add/drop FULLTEXT index, add/drop SPATIAL column+index with SRID (8.0 — the SRID+// attribute is 8.0-only), add/modify/drop STORED and VIRTUAL generated columns, toggle+// column/index INVISIBLE (8.0), and ENUM member append. 5.7-illegal mutations are gated+// off the 5.7 menu.//// Determinism: the mutation stream is a pure function of the seed (the seed is in the// subtest name); the schema model is parsed from the previous round's dump in statement@@ -75,7 +76,7 @@ const (// ----------------------------------------------------------------------------// Stateful-fuzz aux schema: seeds the droppable/modifiable object pool for the NEW menu-// kinds. entSfAuxCommon is 5.7-legal; entSfAux80 seeds the 8.0-only kinds (index+// kinds. entSfAuxCommon is 5.7-legal; entSfAux80 seeds the 8.0-only kinds (SRID spatial,// INVISIBLE, CHECK) and is appended on 8.0 only.// ----------------------------------------------------------------------------@@ -105,9 +106,16 @@ CREATE TABLE ent_sf_gen (`const entSfAux80 = `+CREATE TABLE ent_sf_geo (+ id bigint unsigned NOT NULL,+ pt point NOT NULL SRID 4326,+ PRIMARY KEY (id),+ SPATIAL KEY ent_sf_sp_seed (pt)+) ENGINE=InnoDB;CREATE TABLE ent_sf_vis (id bigint unsigned NOT NULL,visa int NOT NULL DEFAULT '0',+ visb int INVISIBLE NOT NULL DEFAULT '0',visc int NOT NULL DEFAULT '0',PRIMARY KEY (id),KEY ent_sf_ki_a (visa) INVISIBLE,@@ -189,8 +197,8 @@ type entSfLedger struct {// ----------------------------------------------------------------------------// Extended schema model: everything the A4 model parses, plus the constructs the new-// menu mutates (FULLTEXT keys, CHECK constraints, generated columns, INVISIBLE indexes,-// ENUM columns) and the referential protections they imply.+// menu mutates (FULLTEXT/SPATIAL keys, CHECK constraints, generated columns, INVISIBLE+// columns/indexes, ENUM columns) and the referential protections they imply.// ----------------------------------------------------------------------------type entSfIdxRec struct {@@ -213,21 +221,26 @@ type entSfSchema struct {procedures []stringidx []entSfIdxRec // non-PK B-tree indexes, visible AND invisiblefulltext []entSfNamedRec+ spatial []entSfIdxRec // cols[0] is the single spatial columnchecks []entSfNamedRecgenCols []entSfGenRecenumCols []entSfColRec+ invisCols []entSfColRec+ // visibleCols counts non-INVISIBLE columns per table (a toggle must leave >= 1).+ visibleCols map[string]int// protected are "table.col" keys drop/modify must not touch beyond the base model's- // own exclusions: fulltext/invisible-index parts, generated-expression and+ // own exclusions: fulltext/spatial/invisible-index parts, generated-expression and// CHECK-expression references.protected map[string]bool- // noPartition marks tables that cannot gain a partition clause (FULLTEXT indexes are- // unsupported on partitioned tables).+ // noPartition marks tables that cannot gain a partition clause (FULLTEXT/SPATIAL+ // indexes are unsupported on partitioned tables).noPartition map[string]bool}var (entSfReIdxLine = regexp.MustCompile("^(UNIQUE )?KEY `(\\w+)` \\((.+?)\\)( /\\*!80000 INVISIBLE \\*/)?,?$")entSfReFtLine = regexp.MustCompile("^FULLTEXT KEY `(\\w+)` \\((.+?)\\),?$")+ entSfReSpLine = regexp.MustCompile("^SPATIAL KEY `(\\w+)` \\(`(\\w+)`\\),?$")entSfReChkLine = regexp.MustCompile("^CONSTRAINT `(\\w+)` CHECK \\((.+)\\),?$")entSfReColLine = regexp.MustCompile("^`(\\w+)` (.+?),?$")entSfReViewHdr = regexp.MustCompile("(?i)^CREATE .*?VIEW `(\\w+)`")@@ -237,13 +250,17 @@ var (entSfReEnumSpec = regexp.MustCompile(`enum\(([^)]*)\)`))-const entSfInvisibleIdxToken = " /*!80000 INVISIBLE */"+const (+ entSfInvisibleColToken = " /*!80023 INVISIBLE */"+ entSfInvisibleIdxToken = " /*!80000 INVISIBLE */"+)// entSfParse builds the extended model from a canonical dump.func entSfParse(t *testing.T, source string) *entSfSchema {t.Helper()m := &entSfSchema{base: entFuzzModel(t, source),+ visibleCols: map[string]int{},protected: map[string]bool{},noPartition: map[string]bool{},}@@ -294,6 +311,12 @@ func (m *entSfSchema) parseTableExtras(stmt string) {}continue}+ if mm := entSfReSpLine.FindStringSubmatch(line); mm != nil {+ m.spatial = append(m.spatial, entSfIdxRec{table: table, name: mm[1], cols: []string{mm[2]}})+ m.noPartition[table] = true+ m.protected[table+"."+mm[2]] = true+ continue+ }if mm := entSfReChkLine.FindStringSubmatch(line); mm != nil {m.checks = append(m.checks, entSfNamedRec{table: table, name: mm[1]})for _, c := range entFzReCol.FindAllStringSubmatch(mm[2], -1) {@@ -326,6 +349,11 @@ func (m *entSfSchema) parseTableExtras(stmt string) {if strings.HasPrefix(strings.TrimPrefix(def, "`"+col+"` "), "enum(") {m.enumCols = append(m.enumCols, entSfColRec{table: table, col: col})}+ if strings.HasSuffix(def, strings.TrimSpace(entSfInvisibleColToken)) {+ m.invisCols = append(m.invisCols, entSfColRec{table: table, col: col})+ } else {+ m.visibleCols[table]+++ }}}}@@ -357,10 +385,12 @@ func entSfMenu(version string) []string {}if version != "5.7" {// 5.7-illegal kinds: CHECK is parsed-and-ignored on 5.7 (nothing syncs back, so- // convergence is impossible); index INVISIBLE is 8.0-only syntax.+ // convergence is impossible); the SRID column attribute and column/index+ // INVISIBLE are 8.0-only syntax.menu = append(menu,"add_check", "drop_check",- "toggle_idx_invisible",+ "add_spatial", "drop_spatial",+ "toggle_col_invisible", "toggle_idx_invisible",)}return menu@@ -975,6 +1005,59 @@ func entSfGenerate(t *testing.T, kind string, m *entSfSchema, rng *rand.Rand, stdelta: entSfCounts{indexes: -1}, touched: tableKey(pick.table),}, true+ case "add_spatial":+ // A NOT NULL POINT column with an SRID plus its SPATIAL index, in one mutation.+ // SPATIAL indexes are unsupported on partitioned tables; the table is locked so+ // no same-round mutation interleaves with the two-clause add.+ var cands []*entFzTable+ for _, tbl := range entSfMutableTables(m, state) {+ if !tbl.partitioned {+ cands = append(cands, tbl)+ }+ }+ if len(cands) == 0 {+ return entSfMutation{}, false+ }+ pick := cands[rng.Intn(len(cands))]+ state.lockedTables[pick.name] = true+ table, col, idx := pick.name, name("sp"), name("spi")+ return entSfMutation{+ entFzMutation: entFzMutation{+ desc: fmt.Sprintf("add_spatial %s.%s (SRID 4326) + %s", table, col, idx),+ apply: func(t *testing.T, source string) string {+ s := addColumnToTable(t, source, table, "`"+col+"` point NOT NULL /*!80003 SRID 4326 */")+ return addIndexToTable(t, s, table, "SPATIAL KEY `"+idx+"` (`"+col+"`)")+ },+ },+ delta: entSfCounts{columns: 1, indexes: 1}, budget: 400, touched: tableKey(table),+ }, true++ case "drop_spatial":+ // Index and column leave together (a dangling SPATIAL KEY over a dropped column+ // would be an invalid target).+ var cands []entSfIdxRec+ for _, rec := range m.spatial {+ if !state.lockedTables[rec.table] {+ cands = append(cands, rec)+ }+ }+ if len(cands) == 0 {+ return entSfMutation{}, false+ }+ pick := cands[rng.Intn(len(cands))]+ state.lockedTables[pick.table] = true+ col := pick.cols[0]+ return entSfMutation{+ entFzMutation: entFzMutation{+ desc: fmt.Sprintf("drop_spatial %s.%s (+column %s)", pick.table, pick.name, col),+ apply: func(t *testing.T, source string) string {+ s := entDropLineInTable(t, source, pick.table, "SPATIAL KEY `"+pick.name+"`")+ return entDropLineInTable(t, s, pick.table, "`"+col+"` point")+ },+ },+ delta: entSfCounts{columns: -1, indexes: -1}, touched: tableKey(pick.table),+ }, true+case "add_check":cands := entSfColCandidates(m, state, entSfIsIntRest)if len(cands) == 0 {@@ -1101,6 +1184,54 @@ func entSfGenerate(t *testing.T, kind string, m *entSfSchema, rng *rand.Rand, stdelta: entSfCounts{columns: -1}, touched: tableKey(pick.table),}, true+ case "toggle_col_invisible":+ // Visible -> invisible needs >= 2 visible columns left; invisible -> visible is+ // always legal. Both directions render/strip the /*!80023 INVISIBLE */ token the+ // dumper and omni loader agree on.+ type cand struct {+ rec entSfColRec+ on bool+ }+ var cands []cand+ for _, rec := range m.invisCols {+ key := rec.table + "." + rec.col+ if !state.usedCols[key] && !state.lockedTables[rec.table] && !entFzProtectedTables[rec.table] {+ cands = append(cands, cand{rec: rec, on: false})+ }+ }+ for _, rec := range entSfColCandidates(m, state, func(rest string) bool {+ return entSfIsIntRest(rest) || strings.HasPrefix(rest, "varchar")+ }) {+ if m.visibleCols[rec.table] < 2 {+ continue+ }+ if strings.Contains(m.colDef(rec.table, rec.col), "INVISIBLE") {+ continue+ }+ cands = append(cands, cand{rec: rec, on: true})+ }+ if len(cands) == 0 {+ return entSfMutation{}, false+ }+ pick := cands[rng.Intn(len(cands))]+ state.usedCols[pick.rec.table+"."+pick.rec.col] = true+ line := m.colDef(pick.rec.table, pick.rec.col)+ newLine := line + entSfInvisibleColToken+ dir := "->invisible"+ if !pick.on {+ newLine = strings.TrimSuffix(line, entSfInvisibleColToken)+ dir = "->visible"+ }+ return entSfMutation{+ entFzMutation: entFzMutation{+ desc: fmt.Sprintf("toggle_col_invisible %s.%s %s", pick.rec.table, pick.rec.col, dir),+ apply: func(t *testing.T, source string) string {+ return entReplaceLineInTable(t, source, pick.rec.table, "`"+pick.rec.col+"`", newLine)+ },+ },+ budget: 60, touched: tableKey(pick.rec.table),+ }, true+case "toggle_idx_invisible":var cands []entSfIdxRecfor _, rec := range m.idx {diff --git a/backend/plugin/schema/mysql/sdl_migration_omni_live_test.go b/backend/plugin/schema/mysql/sdl_migration_omni_live_test.goindex bcbc362c10..c0fbd35994 100644--- a/backend/plugin/schema/mysql/sdl_migration_omni_live_test.go+++ b/backend/plugin/schema/mysql/sdl_migration_omni_live_test.go@@ -743,3 +743,53 @@ CREATE TABLE author (})}}++// TestSDLSpatialSRIDPresenceLive verifies the SRID presence semantics (X5) against the+// live 8.0 oracle: a geometry column with EXPLICIT SRID 0 (information_schema reports+// SRS_ID=0 — a valid SRS, distinct from "no SRID" which reports NULL) and one with SRID+// 4326 must both round-trip — dump -> SDL -> apply to a fresh database -> re-dump —+// with byte-identical dumps and an empty self-diff. Before the fix the 0-sentinel+// conflated SRID 0 with "no SRID" and dropped the attribute at dump time.+func TestSDLSpatialSRIDPresenceLive(t *testing.T) {+ skipUnlessLiveOracle(t)+ ctx := context.Background()+ srv := liveServers[0] // 8.0 — the SRID column attribute is an 8.0-only surface.++ const ddl = `+CREATE TABLE geo (+ id INT PRIMARY KEY,+ pt0 GEOMETRY NOT NULL /*!80003 SRID 0 */,+ pt4326 POINT NOT NULL /*!80003 SRID 4326 */,+ ptnone GEOMETRY NOT NULL+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;+`+ dbA := newLiveDatabase(ctx, t, srv, "sdl_srid_a")+ require.NoError(t, applyDDL(ctx, t, srv, dbA, ddl))+ dumpA := dumpSDL(ctx, t, srv, dbA)++ // The dump must carry the explicit SRID 0 (presence, not a zero sentinel), the+ // SRID 4326, and no SRID attribute on the undeclared column.+ require.Contains(t, dumpA, "`pt0` geometry NOT NULL /*!80003 SRID 0 */")+ require.Contains(t, dumpA, "`pt4326` point NOT NULL /*!80003 SRID 4326 */")+ require.Contains(t, dumpA, "`ptnone` geometry NOT NULL,")+ require.NotContains(t, dumpA, "`ptnone` geometry NOT NULL /*!80003")++ // Apply the dump to a fresh database and re-dump: the round-trip must be lossless.+ dbB := newLiveDatabase(ctx, t, srv, "sdl_srid_b")+ require.NoError(t, applyDDL(ctx, t, srv, dbB, dumpA))+ dumpB := dumpSDL(ctx, t, srv, dbB)+ require.Equal(t, dumpA, dumpB, "dump -> apply -> re-dump must be byte-stable")++ selfDiff, err := mysqlDiffSDLMigration(dumpB, dumpA, srv.version)+ require.NoError(t, err)+ require.Empty(t, selfDiff, "SRID round-trip self-diff must be empty")++ // Removing a real SRID restriction must diff (4326 -> unset is a column change).+ // Note the 0 <-> unset transition is folded to a no-op by omni's canonicalizer+ // (out of scope here); the dump above still preserves the explicit SRID 0+ // faithfully, so the declared schema round-trips byte-exact.+ noSridTarget := strings.Replace(dumpA, "`pt4326` point NOT NULL /*!80003 SRID 4326 */", "`pt4326` point NOT NULL", 1)+ change, err := mysqlDiffSDLMigration(dumpA, noSridTarget, srv.version)+ require.NoError(t, err)+ require.Contains(t, change, "MODIFY", "dropping an explicit SRID 4326 must produce a column modification")+}diff --git a/backend/plugin/schema/mysql/sdl_migration_omni_test.go b/backend/plugin/schema/mysql/sdl_migration_omni_test.goindex 69c11d6db1..915833a618 100644--- a/backend/plugin/schema/mysql/sdl_migration_omni_test.go+++ b/backend/plugin/schema/mysql/sdl_migration_omni_test.go@@ -215,6 +215,65 @@ func TestDiffMigrationUsesLegacyMetadataPath(t *testing.T) {require.Error(t, err, "sentinel view body must be un-loadable by the omni SDL path")}+// legacyColumnChangeSQL diffs two single-column tables through the registered legacy+// metadata path and returns the migration SQL.+func legacyColumnChangeSQL(t *testing.T, oldCol, newCol *storepb.ColumnMetadata) string {+ t.Helper()+ mk := func(col *storepb.ColumnMetadata) *model.DatabaseMetadata {+ return metadataFromProto(&storepb.DatabaseSchemaMetadata{+ Name: "d",+ Schemas: []*storepb.SchemaMetadata{{+ Name: "",+ Tables: []*storepb.TableMetadata{{Name: "t", Columns: []*storepb.ColumnMetadata{col}}},+ }},+ })+ }+ sql, err := schema.DiffMigration(storepb.Engine_MYSQL, mk(oldCol), mk(newCol))+ require.NoError(t, err)+ return sql+}++// TestLegacyDiffSRIDAndInvisible locks the X10 pairing with X1: with metadata diffs+// routed back onto the legacy differ/generator, that path must know the new SRID and+// INVISIBLE column fields — an SRID-only or INVISIBLE-only change must produce a MODIFY+// COLUMN rendering the dumper-canonical attribute comments.+func TestLegacyDiffSRIDAndInvisible(t *testing.T) {+ srid := func(v uint32) *uint32 { return &v }++ t.Run("srid_only_change_modifies", func(t *testing.T) {+ sql := legacyColumnChangeSQL(t,+ &storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false},+ &storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(4326)},+ )+ require.Contains(t, sql, "MODIFY COLUMN `pt` point NOT NULL /*!80003 SRID 4326 */")+ })++ t.Run("explicit_srid_zero_differs_from_unset", func(t *testing.T) {+ sql := legacyColumnChangeSQL(t,+ &storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false},+ &storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(0)},+ )+ require.Contains(t, sql, "MODIFY COLUMN `pt` point NOT NULL /*!80003 SRID 0 */")+ })++ t.Run("equal_srid_no_change", func(t *testing.T) {+ sql := legacyColumnChangeSQL(t,+ &storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(4326)},+ &storepb.ColumnMetadata{Name: "pt", Type: "point", Nullable: false, Srid: srid(4326)},+ )+ require.Empty(t, sql)+ })++ t.Run("invisible_only_change_modifies", func(t *testing.T) {+ sql := legacyColumnChangeSQL(t,+ &storepb.ColumnMetadata{Name: "c", Type: "int", Nullable: true, Default: "NULL"},+ &storepb.ColumnMetadata{Name: "c", Type: "int", Nullable: true, Default: "NULL", IsInvisible: true},+ )+ require.Contains(t, sql, "MODIFY COLUMN `c` int")+ require.Contains(t, sql, " /*!80023 INVISIBLE */")+ })+}+// TestStripDatabaseContext pins the literal-aware synthetic-qualifier strip (X13): a// string literal that happens to contain the `bbcatalog`.`x` byte sequence must survive// verbatim while identifier-position qualifiers are removed.@@ -259,8 +318,8 @@ func TestStripDatabaseContext(t *testing.T) {},{name: "hash_comment_opaque_and_executable_comment_scanned",- in: "CREATE TABLE `bbcatalog`.`t` (\n `c` int,\n KEY `i` (`c`) /*!80000 INVISIBLE */\n) # trailing 'note\n/* block 'c' */ ALTER TABLE `bbcatalog`.`t` COMMENT ''",- want: "CREATE TABLE `t` (\n `c` int,\n KEY `i` (`c`) /*!80000 INVISIBLE */\n) # trailing 'note\n/* block 'c' */ ALTER TABLE `t` COMMENT ''",+ in: "CREATE TABLE `bbcatalog`.`t` (\n `pt` point NOT NULL /*!80003 SRID 0 */\n) # trailing 'note\n/* block 'c' */ ALTER TABLE `bbcatalog`.`t` COMMENT ''",+ want: "CREATE TABLE `t` (\n `pt` point NOT NULL /*!80003 SRID 0 */\n) # trailing 'note\n/* block 'c' */ ALTER TABLE `t` COMMENT ''",},{name: "no_qualifier_untouched",diff --git a/backend/plugin/schema/mysql/testdata/walk_through.yaml b/backend/plugin/schema/mysql/testdata/walk_through.yamlindex aae50ed782..0ad129fa6c 100644--- a/backend/plugin/schema/mysql/testdata/walk_through.yaml+++ b/backend/plugin/schema/mysql/testdata/walk_through.yaml@@ -592,7 +592,8 @@"position": 1,"default": "'1'","nullable": true,- "type": "int"+ "type": "int",+ "isInvisible": true},{"name": "d",diff --git a/backend/plugin/schema/mysql/walk_through_loader.go b/backend/plugin/schema/mysql/walk_through_loader.goindex d9d422f719..2cb4a1da27 100644--- a/backend/plugin/schema/mysql/walk_through_loader.go+++ b/backend/plugin/schema/mysql/walk_through_loader.go@@ -553,6 +553,13 @@ func wtBuildColumnDef(col *storepb.ColumnMetadata) (*ast.ColumnDef, error) {if typeName.Collate == "" && col.Collation != "" {typeName.Collate = col.Collation}+ // Spatial SRID (MySQL 8.0): carry the explicit SRID by presence (including the valid+ // SRID 0) so a pre-synced `POINT SRID n` column seeds the catalog with its SRID and+ // tableToProto reads it back unchanged (no phantom SRID diff).+ if col.Srid != nil {+ typeName.SRID = int(col.GetSrid())+ typeName.HasSRID = true+ }def := &ast.ColumnDef{Name: col.Name,@@ -562,6 +569,12 @@ func wtBuildColumnDef(col *storepb.ColumnMetadata) (*ast.ColumnDef, error) {if !col.Nullable {def.Constraints = append(def.Constraints, &ast.ColumnConstraint{Type: ast.ColConstrNotNull})}+ // INVISIBLE column (MySQL 8.0.23+): seed the catalog as invisible so a pre-synced+ // INVISIBLE column round-trips (tableToProto re-reads it) instead of surfacing as a+ // phantom visibility change.+ if col.IsInvisible {+ def.Constraints = append(def.Constraints, &ast.ColumnConstraint{Type: ast.ColConstrInvisible})+ }// MySQL sync encodes AUTO_INCREMENT as the literal string "AUTO_INCREMENT"// in ColumnMetadata.Default. Detect it here and set AutoIncrement insteaddiff --git a/backend/plugin/schema/mysql/walk_through_omni.go b/backend/plugin/schema/mysql/walk_through_omni.goindex 101b09cf66..80f9702135 100644--- a/backend/plugin/schema/mysql/walk_through_omni.go+++ b/backend/plugin/schema/mysql/walk_through_omni.go@@ -762,6 +762,16 @@ func tableToProto(t *catalog.Table) *storepb.TableMetadata {Expression: col.Generated.Expr,}}+ // Spatial SRID (MySQL 8.0): presence-carrying — an explicit SRID (including the+ // valid SRID 0) is distinct from "no SRID". SRS_IDs are unsigned 32-bit, so the+ // omni catalog's int value is widened to uint32 to match the store proto.+ if col.HasSRID {+ srid := uint32(col.SRID)+ colMeta.Srid = &srid+ }+ // INVISIBLE column (MySQL 8.0.23+): user-declared invisibility (distinct from+ // system-hidden functional-index backing columns filtered above).+ colMeta.IsInvisible = col.Invisibletable.Columns = append(table.Columns, colMeta)}diff --git a/backend/plugin/schema/mysql/walk_through_test.go b/backend/plugin/schema/mysql/walk_through_test.goindex 18df99d48a..c6c0c2e418 100644--- a/backend/plugin/schema/mysql/walk_through_test.go+++ b/backend/plugin/schema/mysql/walk_through_test.go@@ -122,3 +122,91 @@ func TestWalkThroughOmniCreateTableIfNotExistsCTASExistingTable(t *testing.T) {require.Nil(t, advice)require.NotNil(t, state.GetSchemaMetadata("").GetTable("t1"))}++// TestWalkThroughOmniSRIDInvisible verifies the omni catalog -> storepb.ColumnMetadata+// conversion (tableToProto) carries the spatial SRID (presence + value, including the+// valid explicit SRID 0) and the INVISIBLE flag. Without this the WalkThroughOmni+// simulation path — used to compute the schema a changeset would produce — would silently+// drop these attributes, mirroring the v1-converter gap.+func TestWalkThroughOmniSRIDInvisible(t *testing.T) {+ state := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MYSQL, true)+ statement := "CREATE TABLE t (" ++ "id INT PRIMARY KEY, " ++ "g4326 GEOMETRY NOT NULL SRID 4326, " ++ "g0 GEOMETRY NOT NULL SRID 0, " ++ "gnone GEOMETRY NOT NULL, " ++ "secret INT INVISIBLE NOT NULL DEFAULT 0);"+ sm := sheet.NewManager()+ stmts, _ := sm.GetStatementsForChecks(storepb.Engine_MYSQL, statement)+ asts := base.ExtractASTs(stmts)++ advice := WalkThroughOmni(schema.WalkThroughContext{RawSQL: statement}, state, asts)+ require.Nil(t, advice)++ cols := map[string]*storepb.ColumnMetadata{}+ for _, c := range state.GetProto().GetSchemas()[0].GetTables()[0].GetColumns() {+ cols[c.GetName()] = c+ }++ // Explicit SRID must round-trip as presence (nil vs non-nil) plus value.+ require.NotNil(t, cols["g4326"].Srid)+ require.Equal(t, uint32(4326), *cols["g4326"].Srid)+ // Explicit SRID 0 is present-and-distinct from "no SRID"; presence must survive.+ require.NotNil(t, cols["g0"].Srid, "explicit SRID 0 must be captured as present")+ require.Equal(t, uint32(0), *cols["g0"].Srid)+ // A no-SRID spatial column must stay unset (no phantom SRID 0).+ require.Nil(t, cols["gnone"].Srid)+ // INVISIBLE captured; visible columns stay visible.+ require.True(t, cols["secret"].IsInvisible)+ require.False(t, cols["g4326"].IsInvisible)+}++// TestWalkThroughOmniSRIDInvisibleSeeded verifies the reverse leg of the WalkThroughOmni+// round-trip: when the walk-through starts from already-synced metadata that carries SRID+// / INVISIBLE columns, the proto->catalog seeding (wtBuildColumnDef) must install those+// attributes into the omni catalog so that running an UNRELATED DDL does not strip them+// from the resulting proto. Without seeding, the pre-existing columns load as+// plain/no-SRID and — because columnsEqual now compares these fields — surface as phantom+// changes.+func TestWalkThroughOmniSRIDInvisibleSeeded(t *testing.T) {+ origin := &storepb.DatabaseSchemaMetadata{+ Name: "test",+ Schemas: []*storepb.SchemaMetadata{{+ Name: "",+ Tables: []*storepb.TableMetadata{+ {+ Name: "geo",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Position: 1, Type: "int", Nullable: false, Default: "AUTO_INCREMENT"},+ {Name: "pt", Position: 2, Type: "point", Nullable: false, Srid: func() *uint32 { v := uint32(4326); return &v }()},+ {Name: "secret", Position: 3, Type: "int", Nullable: false, Default: "0", IsInvisible: true},+ },+ Indexes: []*storepb.IndexMetadata{+ {Name: "PRIMARY", Expressions: []string{"id"}, Primary: true, Unique: true},+ },+ },+ },+ }},+ }+ state := model.NewDatabaseMetadata(origin, nil, nil, storepb.Engine_MYSQL, true)++ // An unrelated DDL against a different table: it must not perturb geo's SRID/INVISIBLE.+ statement := "CREATE TABLE unrelated (x INT PRIMARY KEY);"+ sm := sheet.NewManager()+ stmts, _ := sm.GetStatementsForChecks(storepb.Engine_MYSQL, statement)+ asts := base.ExtractASTs(stmts)+ advice := WalkThroughOmni(schema.WalkThroughContext{RawSQL: statement}, state, asts)+ require.Nil(t, advice)++ geo := state.GetSchemaMetadata("").GetTable("geo")+ require.NotNil(t, geo)+ cols := map[string]*storepb.ColumnMetadata{}+ for _, c := range geo.GetProto().GetColumns() {+ cols[c.GetName()] = c+ }+ // The pre-synced SRID + INVISIBLE attributes must survive the seed -> catalog ->+ // proto round-trip unchanged.+ require.NotNil(t, cols["pt"].Srid, "seeded SRID must survive (no phantom strip)")+ require.Equal(t, uint32(4326), *cols["pt"].Srid)+ require.True(t, cols["secret"].IsInvisible, "seeded INVISIBLE must survive")+}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 8bb996eaca..8493bea0bc 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@@ -1631,6 +1631,23 @@ export declare type ColumnMetadata = Message<"bytebase.v1.ColumnMetadata"> & {* @generated from field: string default_constraint_name = 17;*/defaultConstraintName: string;++ /**+ * The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ * Unset means the column declares no SRID; presence carries the explicit SRID,+ * including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ * int32).+ *+ * @generated from field: optional uint32 srid = 18;+ */+ srid?: number | undefined;++ /**+ * Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.+ *+ * @generated from field: bool is_invisible = 19;+ */+ isInvisible: 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 a9cd31ad08..cd5a70b4d3 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("Chl2MS9kYXRhYmFzZV9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSJBChJHZXREYXRhYmFzZVJlcXVlc3QSKwoEbmFtZRgBIAEoCUId4EEC+kEXChVieXRlYmFzZS5jb20vRGF0YWJhc2UidwoYQmF0Y2hHZXREYXRhYmFzZXNSZXF1ZXN0Ei0KBnBhcmVudBgBIAEoCUId4EEC+kEXEhVieXRlYmFzZS5jb20vRGF0YWJhc2USLAoFbmFtZXMYAiADKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlIkUKGUJhdGNoR2V0RGF0YWJhc2VzUmVzcG9uc2USKAoJZGF0YWJhc2VzGAEgAygLMhUuYnl0ZWJhc2UudjEuRGF0YWJhc2UipAEKFExpc3REYXRhYmFzZXNSZXF1ZXN0Ei0KBnBhcmVudBgBIAEoCUId4EEC+kEXEhVieXRlYmFzZS5jb20vRGF0YWJhc2USEQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSDgoGZmlsdGVyGAQgASgJEhQKDHNob3dfZGVsZXRlZBgFIAEoCBIQCghvcmRlcl9ieRgGIAEoCSJaChVMaXN0RGF0YWJhc2VzUmVzcG9uc2USKAoJZGF0YWJhc2VzGAEgAygLMhUuYnl0ZWJhc2UudjEuRGF0YWJhc2USFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJIo0BChVVcGRhdGVEYXRhYmFzZVJlcXVlc3QSLAoIZGF0YWJhc2UYASABKAsyFS5ieXRlYmFzZS52MS5EYXRhYmFzZUID4EECEi8KC3VwZGF0ZV9tYXNrGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLkZpZWxkTWFzaxIVCg1hbGxvd19taXNzaW5nGAMgASgIImgKG0JhdGNoVXBkYXRlRGF0YWJhc2VzUmVxdWVzdBIOCgZwYXJlbnQYASABKAkSOQoIcmVxdWVzdHMYAiADKAsyIi5ieXRlYmFzZS52MS5VcGRhdGVEYXRhYmFzZVJlcXVlc3RCA+BBAiJIChxCYXRjaFVwZGF0ZURhdGFiYXNlc1Jlc3BvbnNlEigKCWRhdGFiYXNlcxgBIAMoCzIVLmJ5dGViYXNlLnYxLkRhdGFiYXNlIlkKGUJhdGNoU3luY0RhdGFiYXNlc1JlcXVlc3QSDgoGcGFyZW50GAEgASgJEiwKBW5hbWVzGAIgAygJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZSIcChpCYXRjaFN5bmNEYXRhYmFzZXNSZXNwb25zZSJCChNTeW5jRGF0YWJhc2VSZXF1ZXN0EisKBG5hbWUYASABKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlIhYKFFN5bmNEYXRhYmFzZVJlc3BvbnNlInAKGkdldERhdGFiYXNlTWV0YWRhdGFSZXF1ZXN0EjMKBG5hbWUYASABKAlCJeBBAvpBHwodYnl0ZWJhc2UuY29tL0RhdGFiYXNlTWV0YWRhdGESDgoGZmlsdGVyGAIgASgJEg0KBWxpbWl0GAMgASgFIk0KGEdldERhdGFiYXNlU2NoZW1hUmVxdWVzdBIxCgRuYW1lGAEgASgJQiPgQQL6QR0KG2J5dGViYXNlLmNvbS9EYXRhYmFzZVNjaGVtYSLYAQobR2V0RGF0YWJhc2VTRExTY2hlbWFSZXF1ZXN0EisKBG5hbWUYASABKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlEkIKBmZvcm1hdBgCIAEoDjIyLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlU0RMU2NoZW1hUmVxdWVzdC5TRExGb3JtYXQiSAoJU0RMRm9ybWF0EhoKFlNETF9GT1JNQVRfVU5TUEVDSUZJRUQQABIPCgtTSU5HTEVfRklMRRABEg4KCk1VTFRJX0ZJTEUQAiJxChFEaWZmU2NoZW1hUmVxdWVzdBIrCgRuYW1lGAEgASgJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZRIQCgZzY2hlbWEYAiABKAlIABITCgljaGFuZ2Vsb2cYAyABKAlIAEIICgZ0YXJnZXQiIgoSRGlmZlNjaGVtYVJlc3BvbnNlEgwKBGRpZmYYASABKAki6wQKCERhdGFiYXNlEgwKBG5hbWUYASABKAkSJgoFc3RhdGUYAiABKA4yEi5ieXRlYmFzZS52MS5TdGF0ZUID4EEDEj0KFHN1Y2Nlc3NmdWxfc3luY190aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEg8KB3Byb2plY3QYBCABKAkSFAoHcmVsZWFzZRgFIAEoCUID4EEDEh0KC2Vudmlyb25tZW50GAYgASgJQgPgQQFIAIgBARInChVlZmZlY3RpdmVfZW52aXJvbm1lbnQYByABKAlCA+BBA0gBiAEBEjEKBmxhYmVscxgIIAMoCzIhLmJ5dGViYXNlLnYxLkRhdGFiYXNlLkxhYmVsc0VudHJ5Ej0KEWluc3RhbmNlX3Jlc291cmNlGAkgASgLMh0uYnl0ZWJhc2UudjEuSW5zdGFuY2VSZXNvdXJjZUID4EEDEh0KEGJhY2t1cF9hdmFpbGFibGUYCiABKAhCA+BBAxIxCgtzeW5jX3N0YXR1cxgLIAEoDjIXLmJ5dGViYXNlLnYxLlN5bmNTdGF0dXNCA+BBAxIXCgpzeW5jX2Vycm9yGAwgASgJQgPgQQMaLQoLTGFiZWxzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ATpF6kFCChVieXRlYmFzZS5jb20vRGF0YWJhc2USKWluc3RhbmNlcy97aW5zdGFuY2V9L2RhdGFiYXNlcy97ZGF0YWJhc2V9Qg4KDF9lbnZpcm9ubWVudEIYChZfZWZmZWN0aXZlX2Vudmlyb25tZW50IqgCChBEYXRhYmFzZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSLAoHc2NoZW1hcxgCIAMoCzIbLmJ5dGViYXNlLnYxLlNjaGVtYU1ldGFkYXRhEhUKDWNoYXJhY3Rlcl9zZXQYAyABKAkSEQoJY29sbGF0aW9uGAQgASgJEjIKCmV4dGVuc2lvbnMYBSADKAsyHi5ieXRlYmFzZS52MS5FeHRlbnNpb25NZXRhZGF0YRINCgVvd25lchgGIAEoCRITCgtzZWFyY2hfcGF0aBgHIAEoCTpW6kFTCh1ieXRlYmFzZS5jb20vRGF0YWJhc2VNZXRhZGF0YRIyaW5zdGFuY2VzL3tpbnN0YW5jZX0vZGF0YWJhc2VzL3tkYXRhYmFzZX0vbWV0YWRhdGEipgUKDlNjaGVtYU1ldGFkYXRhEgwKBG5hbWUYASABKAkSKgoGdGFibGVzGAIgAygLMhouYnl0ZWJhc2UudjEuVGFibGVNZXRhZGF0YRI7Cg9leHRlcm5hbF90YWJsZXMYAyADKAsyIi5ieXRlYmFzZS52MS5FeHRlcm5hbFRhYmxlTWV0YWRhdGESKAoFdmlld3MYBCADKAsyGS5ieXRlYmFzZS52MS5WaWV3TWV0YWRhdGESMAoJZnVuY3Rpb25zGAUgAygLMh0uYnl0ZWJhc2UudjEuRnVuY3Rpb25NZXRhZGF0YRIyCgpwcm9jZWR1cmVzGAYgAygLMh4uYnl0ZWJhc2UudjEuUHJvY2VkdXJlTWV0YWRhdGESLAoHc3RyZWFtcxgHIAMoCzIbLmJ5dGViYXNlLnYxLlN0cmVhbU1ldGFkYXRhEigKBXRhc2tzGAggAygLMhkuYnl0ZWJhc2UudjEuVGFza01ldGFkYXRhEkEKEm1hdGVyaWFsaXplZF92aWV3cxgJIAMoCzIlLmJ5dGViYXNlLnYxLk1hdGVyaWFsaXplZFZpZXdNZXRhZGF0YRIuCghwYWNrYWdlcxgKIAMoCzIcLmJ5dGViYXNlLnYxLlBhY2thZ2VNZXRhZGF0YRINCgVvd25lchgLIAEoCRIwCglzZXF1ZW5jZXMYDCADKAsyHS5ieXRlYmFzZS52MS5TZXF1ZW5jZU1ldGFkYXRhEioKBmV2ZW50cxgNIAMoCzIaLmJ5dGViYXNlLnYxLkV2ZW50TWV0YWRhdGESMQoKZW51bV90eXBlcxgOIAMoCzIdLmJ5dGViYXNlLnYxLkVudW1UeXBlTWV0YWRhdGESEQoJc2tpcF9kdW1wGA8gASgIEg8KB2NvbW1lbnQYECABKAkiVAoQRW51bVR5cGVNZXRhZGF0YRIMCgRuYW1lGAEgASgJEg4KBnZhbHVlcxgCIAMoCRIPCgdjb21tZW50GAMgASgJEhEKCXNraXBfZHVtcBgEIAEoCCKjAQoNRXZlbnRNZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCmRlZmluaXRpb24YAiABKAkSEQoJdGltZV96b25lGAMgASgJEhAKCHNxbF9tb2RlGAQgASgJEhwKFGNoYXJhY3Rlcl9zZXRfY2xpZW50GAUgASgJEhwKFGNvbGxhdGlvbl9jb25uZWN0aW9uGAYgASgJEg8KB2NvbW1lbnQYByABKAkigQIKEFNlcXVlbmNlTWV0YWRhdGESDAoEbmFtZRgBIAEoCRIRCglkYXRhX3R5cGUYAiABKAkSDQoFc3RhcnQYAyABKAkSEQoJbWluX3ZhbHVlGAQgASgJEhEKCW1heF92YWx1ZRgFIAEoCRIRCglpbmNyZW1lbnQYBiABKAkSDQoFY3ljbGUYByABKAgSEgoKY2FjaGVfc2l6ZRgIIAEoCRISCgpsYXN0X3ZhbHVlGAkgASgJEhMKC293bmVyX3RhYmxlGAogASgJEhQKDG93bmVyX2NvbHVtbhgLIAEoCRIPCgdjb21tZW50GAwgASgJEhEKCXNraXBfZHVtcBgNIAEoCCK+AQoPVHJpZ2dlck1ldGFkYXRhEgwKBG5hbWUYASABKAkSDQoFZXZlbnQYAiABKAkSDgoGdGltaW5nGAMgASgJEgwKBGJvZHkYBCABKAkSEAoIc3FsX21vZGUYBSABKAkSHAoUY2hhcmFjdGVyX3NldF9jbGllbnQYBiABKAkSHAoUY29sbGF0aW9uX2Nvbm5lY3Rpb24YByABKAkSDwoHY29tbWVudBgIIAEoCRIRCglza2lwX2R1bXAYCSABKAgikQEKFUV4dGVybmFsVGFibGVNZXRhZGF0YRIMCgRuYW1lGAEgASgJEhwKFGV4dGVybmFsX3NlcnZlcl9uYW1lGAIgASgJEh4KFmV4dGVybmFsX2RhdGFiYXNlX25hbWUYAyABKAkSLAoHY29sdW1ucxgEIAMoCzIbLmJ5dGViYXNlLnYxLkNvbHVtbk1ldGFkYXRhIuwECg1UYWJsZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSLAoHY29sdW1ucxgCIAMoCzIbLmJ5dGViYXNlLnYxLkNvbHVtbk1ldGFkYXRhEisKB2luZGV4ZXMYAyADKAsyGi5ieXRlYmFzZS52MS5JbmRleE1ldGFkYXRhEg4KBmVuZ2luZRgEIAEoCRIRCgljb2xsYXRpb24YBSABKAkSDwoHY2hhcnNldBgGIAEoCRIRCglyb3dfY291bnQYByABKAMSEQoJZGF0YV9zaXplGAggASgDEhIKCmluZGV4X3NpemUYCSABKAMSEQoJZGF0YV9mcmVlGAogASgDEhYKDmNyZWF0ZV9vcHRpb25zGAsgASgJEg8KB2NvbW1lbnQYDCABKAkSNQoMZm9yZWlnbl9rZXlzGA0gAygLMh8uYnl0ZWJhc2UudjEuRm9yZWlnbktleU1ldGFkYXRhEjcKCnBhcnRpdGlvbnMYDiADKAsyIy5ieXRlYmFzZS52MS5UYWJsZVBhcnRpdGlvbk1ldGFkYXRhEj8KEWNoZWNrX2NvbnN0cmFpbnRzGA8gAygLMiQuYnl0ZWJhc2UudjEuQ2hlY2tDb25zdHJhaW50TWV0YWRhdGESDQoFb3duZXIYECABKAkSFAoMc29ydGluZ19rZXlzGBEgAygJEi4KCHRyaWdnZXJzGBIgAygLMhwuYnl0ZWJhc2UudjEuVHJpZ2dlck1ldGFkYXRhEhEKCXNraXBfZHVtcBgTIAEoCBIVCg1zaGFyZGluZ19pbmZvGBQgASgJEhgKEHByaW1hcnlfa2V5X3R5cGUYFSABKAkiOwoXQ2hlY2tDb25zdHJhaW50TWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpleHByZXNzaW9uGAIgASgJIs0DChZUYWJsZVBhcnRpdGlvbk1ldGFkYXRhEgwKBG5hbWUYASABKAkSNgoEdHlwZRgCIAEoDjIoLmJ5dGViYXNlLnYxLlRhYmxlUGFydGl0aW9uTWV0YWRhdGEuVHlwZRISCgpleHByZXNzaW9uGAMgASgJEg0KBXZhbHVlGAQgASgJEhMKC3VzZV9kZWZhdWx0GAUgASgJEjoKDXN1YnBhcnRpdGlvbnMYBiADKAsyIy5ieXRlYmFzZS52MS5UYWJsZVBhcnRpdGlvbk1ldGFkYXRhEisKB2luZGV4ZXMYByADKAsyGi5ieXRlYmFzZS52MS5JbmRleE1ldGFkYXRhEj8KEWNoZWNrX2NvbnN0cmFpbnRzGAggAygLMiQuYnl0ZWJhc2UudjEuQ2hlY2tDb25zdHJhaW50TWV0YWRhdGEiigEKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgkKBVJBTkdFEAESEQoNUkFOR0VfQ09MVU1OUxACEggKBExJU1QQAxIQCgxMSVNUX0NPTFVNTlMQBBIICgRIQVNIEAUSDwoLTElORUFSX0hBU0gQBhIHCgNLRVkQBxIOCgpMSU5FQVJfS0VZEAgi0QQKDkNvbHVtbk1ldGFkYXRhEgwKBG5hbWUYASABKAkSEAoIcG9zaXRpb24YAiABKAUSEwoLaGFzX2RlZmF1bHQYAyABKAgSDwoHZGVmYXVsdBgEIAEoCRIXCg9kZWZhdWx0X29uX251bGwYBSABKAgSEQoJb25fdXBkYXRlGAYgASgJEhAKCG51bGxhYmxlGAcgASgIEgwKBHR5cGUYCCABKAkSFQoNY2hhcmFjdGVyX3NldBgJIAEoCRIRCgljb2xsYXRpb24YCiABKAkSDwoHY29tbWVudBgLIAEoCRIzCgpnZW5lcmF0aW9uGAwgASgLMh8uYnl0ZWJhc2UudjEuR2VuZXJhdGlvbk1ldGFkYXRhEhMKC2lzX2lkZW50aXR5GA0gASgIEksKE2lkZW50aXR5X2dlbmVyYXRpb24YDiABKA4yLi5ieXRlYmFzZS52MS5Db2x1bW5NZXRhZGF0YS5JZGVudGl0eUdlbmVyYXRpb24SFQoNaWRlbnRpdHlfc2VlZBgPIAEoAxIaChJpZGVudGl0eV9pbmNyZW1lbnQYECABKAMSHwoXZGVmYXVsdF9jb25zdHJhaW50X25hbWUYESABKAkSEQoEc3JpZBgSIAEoDUgAiAEBEhQKDGlzX2ludmlzaWJsZRgTIAEoCCJVChJJZGVudGl0eUdlbmVyYXRpb24SIwofSURFTlRJVFlfR0VORVJBVElPTl9VTlNQRUNJRklFRBAAEgoKBkFMV0FZUxABEg4KCkJZX0RFRkFVTFQQAkIHCgVfc3JpZCKTAQoSR2VuZXJhdGlvbk1ldGFkYXRhEjIKBHR5cGUYASABKA4yJC5ieXRlYmFzZS52MS5HZW5lcmF0aW9uTWV0YWRhdGEuVHlwZRISCgpleHByZXNzaW9uGAIgASgJIjUKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgsKB1ZJUlRVQUwQARIKCgZTVE9SRUQQAiLtAQoMVmlld01ldGFkYXRhEgwKBG5hbWUYASABKAkSEgoKZGVmaW5pdGlvbhgCIAEoCRIPCgdjb21tZW50GAMgASgJEjkKEmRlcGVuZGVuY3lfY29sdW1ucxgEIAMoCzIdLmJ5dGViYXNlLnYxLkRlcGVuZGVuY3lDb2x1bW4SLAoHY29sdW1ucxgFIAMoCzIbLmJ5dGViYXNlLnYxLkNvbHVtbk1ldGFkYXRhEi4KCHRyaWdnZXJzGAYgAygLMhwuYnl0ZWJhc2UudjEuVHJpZ2dlck1ldGFkYXRhEhEKCXNraXBfZHVtcBgHIAEoCCJBChBEZXBlbmRlbmN5Q29sdW1uEg4KBnNjaGVtYRgBIAEoCRINCgV0YWJsZRgCIAEoCRIOCgZjb2x1bW4YAyABKAki+AEKGE1hdGVyaWFsaXplZFZpZXdNZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCmRlZmluaXRpb24YAiABKAkSDwoHY29tbWVudBgDIAEoCRI5ChJkZXBlbmRlbmN5X2NvbHVtbnMYBCADKAsyHS5ieXRlYmFzZS52MS5EZXBlbmRlbmN5Q29sdW1uEi4KCHRyaWdnZXJzGAUgAygLMhwuYnl0ZWJhc2UudjEuVHJpZ2dlck1ldGFkYXRhEisKB2luZGV4ZXMYBiADKAsyGi5ieXRlYmFzZS52MS5JbmRleE1ldGFkYXRhEhEKCXNraXBfZHVtcBgHIAEoCCIwCg9EZXBlbmRlbmN5VGFibGUSDgoGc2NoZW1hGAEgASgJEg0KBXRhYmxlGAIgASgJIo4CChBGdW5jdGlvbk1ldGFkYXRhEgwKBG5hbWUYASABKAkSEgoKZGVmaW5pdGlvbhgCIAEoCRIRCglzaWduYXR1cmUYAyABKAkSHAoUY2hhcmFjdGVyX3NldF9jbGllbnQYBCABKAkSHAoUY29sbGF0aW9uX2Nvbm5lY3Rpb24YBSABKAkSGgoSZGF0YWJhc2VfY29sbGF0aW9uGAYgASgJEhAKCHNxbF9tb2RlGAcgASgJEg8KB2NvbW1lbnQYCCABKAkSNwoRZGVwZW5kZW5jeV90YWJsZXMYCSADKAsyHC5ieXRlYmFzZS52MS5EZXBlbmRlbmN5VGFibGUSEQoJc2tpcF9kdW1wGAogASgIItYBChFQcm9jZWR1cmVNZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCmRlZmluaXRpb24YAiABKAkSEQoJc2lnbmF0dXJlGAMgASgJEhwKFGNoYXJhY3Rlcl9zZXRfY2xpZW50GAQgASgJEhwKFGNvbGxhdGlvbl9jb25uZWN0aW9uGAUgASgJEhoKEmRhdGFiYXNlX2NvbGxhdGlvbhgGIAEoCRIQCghzcWxfbW9kZRgHIAEoCRIPCgdjb21tZW50GAkgASgJEhEKCXNraXBfZHVtcBgIIAEoCCIzCg9QYWNrYWdlTWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpkZWZpbml0aW9uGAIgASgJIpYCCgxUYXNrTWV0YWRhdGESDAoEbmFtZRgBIAEoCRIKCgJpZBgCIAEoCRINCgVvd25lchgDIAEoCRIPCgdjb21tZW50GAQgASgJEhEKCXdhcmVob3VzZRgFIAEoCRIQCghzY2hlZHVsZRgGIAEoCRIUCgxwcmVkZWNlc3NvcnMYByADKAkSLgoFc3RhdGUYCCABKA4yHy5ieXRlYmFzZS52MS5UYXNrTWV0YWRhdGEuU3RhdGUSEQoJY29uZGl0aW9uGAkgASgJEhIKCmRlZmluaXRpb24YCiABKAkiOgoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABILCgdTVEFSVEVEEAESDQoJU1VTUEVOREVEEAIiywIKDlN0cmVhbU1ldGFkYXRhEgwKBG5hbWUYASABKAkSEgoKdGFibGVfbmFtZRgCIAEoCRINCgVvd25lchgDIAEoCRIPCgdjb21tZW50GAQgASgJEi4KBHR5cGUYBSABKA4yIC5ieXRlYmFzZS52MS5TdHJlYW1NZXRhZGF0YS5UeXBlEg0KBXN0YWxlGAYgASgIEi4KBG1vZGUYByABKA4yIC5ieXRlYmFzZS52MS5TdHJlYW1NZXRhZGF0YS5Nb2RlEhIKCmRlZmluaXRpb24YCCABKAkiJwoEVHlwZRIUChBUWVBFX1VOU1BFQ0lGSUVEEAASCQoFREVMVEEQASJLCgRNb2RlEhQKEE1PREVfVU5TUEVDSUZJRUQQABILCgdERUZBVUxUEAESDwoLQVBQRU5EX09OTFkQAhIPCgtJTlNFUlRfT05MWRADIr0BChJTcGF0aWFsSW5kZXhDb25maWcSDgoGbWV0aG9kGAEgASgJEjUKDHRlc3NlbGxhdGlvbhgCIAEoCzIfLmJ5dGViYXNlLnYxLlRlc3NlbGxhdGlvbkNvbmZpZxIrCgdzdG9yYWdlGAMgASgLMhouYnl0ZWJhc2UudjEuU3RvcmFnZUNvbmZpZxIzCgtkaW1lbnNpb25hbBgEIAEoCzIeLmJ5dGViYXNlLnYxLkRpbWVuc2lvbmFsQ29uZmlnIpsBChJUZXNzZWxsYXRpb25Db25maWcSDgoGc2NoZW1lGAEgASgJEisKC2dyaWRfbGV2ZWxzGAIgAygLMhYuYnl0ZWJhc2UudjEuR3JpZExldmVsEhgKEGNlbGxzX3Blcl9vYmplY3QYAyABKAUSLgoMYm91bmRpbmdfYm94GAQgASgLMhguYnl0ZWJhc2UudjEuQm91bmRpbmdCb3giKwoJR3JpZExldmVsEg0KBWxldmVsGAEgASgFEg8KB2RlbnNpdHkYAiABKAkiRQoLQm91bmRpbmdCb3gSDAoEeG1pbhgBIAEoARIMCgR5bWluGAIgASgBEgwKBHhtYXgYAyABKAESDAoEeW1heBgEIAEoASK+AgoNU3RvcmFnZUNvbmZpZxISCgpmaWxsZmFjdG9yGAEgASgFEhEKCWJ1ZmZlcmluZxgCIAEoCRISCgp0YWJsZXNwYWNlGAMgASgJEhcKD3dvcmtfdGFibGVzcGFjZRgEIAEoCRIRCglzZG9fbGV2ZWwYBSABKAUSFwoPY29tbWl0X2ludGVydmFsGAYgASgFEhEKCXBhZF9pbmRleBgHIAEoCBIWCg5zb3J0X2luX3RlbXBkYhgIIAEoCRIVCg1kcm9wX2V4aXN0aW5nGAkgASgIEg4KBm9ubGluZRgKIAEoCBIXCg9hbGxvd19yb3dfbG9ja3MYCyABKAgSGAoQYWxsb3dfcGFnZV9sb2NrcxgMIAEoCBIOCgZtYXhkb3AYDSABKAUSGAoQZGF0YV9jb21wcmVzc2lvbhgOIAEoCSJ/ChFEaW1lbnNpb25hbENvbmZpZxISCgpkaW1lbnNpb25zGAEgASgFEhEKCWRhdGFfdHlwZRgCIAEoCRIMCgRzcmlkGAMgASgFEjUKC2NvbnN0cmFpbnRzGAQgAygLMiAuYnl0ZWJhc2UudjEuRGltZW5zaW9uQ29uc3RyYWludCJhChNEaW1lbnNpb25Db25zdHJhaW50EhEKCWRpbWVuc2lvbhgBIAEoCRIRCgltaW5fdmFsdWUYAiABKAESEQoJbWF4X3ZhbHVlGAMgASgBEhEKCXRvbGVyYW5jZRgEIAEoASKNAwoNSW5kZXhNZXRhZGF0YRIMCgRuYW1lGAEgASgJEhMKC2V4cHJlc3Npb25zGAIgAygJEhIKCmtleV9sZW5ndGgYAyADKAMSEgoKZGVzY2VuZGluZxgEIAMoCBIMCgR0eXBlGAUgASgJEg4KBnVuaXF1ZRgGIAEoCBIPCgdwcmltYXJ5GAcgASgIEg8KB3Zpc2libGUYCCABKAgSDwoHY29tbWVudBgJIAEoCRISCgpkZWZpbml0aW9uGAogASgJEhsKE3BhcmVudF9pbmRleF9zY2hlbWEYCyABKAkSGQoRcGFyZW50X2luZGV4X25hbWUYDCABKAkSEwoLZ3JhbnVsYXJpdHkYDSABKAMSFQoNaXNfY29uc3RyYWludBgOIAEoCBI3Cg5zcGF0aWFsX2NvbmZpZxgPIAEoCzIfLmJ5dGViYXNlLnYxLlNwYXRpYWxJbmRleENvbmZpZxIVCg1vcGNsYXNzX25hbWVzGBAgAygJEhgKEG9wY2xhc3NfZGVmYXVsdHMYESADKAgiVwoRRXh0ZW5zaW9uTWV0YWRhdGESDAoEbmFtZRgBIAEoCRIOCgZzY2hlbWEYAiABKAkSDwoHdmVyc2lvbhgDIAEoCRITCgtkZXNjcmlwdGlvbhgEIAEoCSK+AQoSRm9yZWlnbktleU1ldGFkYXRhEgwKBG5hbWUYASABKAkSDwoHY29sdW1ucxgCIAMoCRIZChFyZWZlcmVuY2VkX3NjaGVtYRgDIAEoCRIYChByZWZlcmVuY2VkX3RhYmxlGAQgASgJEhoKEnJlZmVyZW5jZWRfY29sdW1ucxgFIAMoCRIRCglvbl9kZWxldGUYBiABKAkSEQoJb25fdXBkYXRlGAcgASgJEhIKCm1hdGNoX3R5cGUYCCABKAkiIAoORGF0YWJhc2VTY2hlbWESDgoGc2NoZW1hGAEgASgJIj4KEURhdGFiYXNlU0RMU2NoZW1hEg4KBnNjaGVtYRgBIAEoDBIZCgxjb250ZW50X3R5cGUYAiABKAlCA+BBAyKnAQoVTGlzdENoYW5nZWxvZ3NSZXF1ZXN0Ei0KBnBhcmVudBgBIAEoCUId4EEC+kEXChVieXRlYmFzZS5jb20vRGF0YWJhc2USEQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSKAoEdmlldxgEIAEoDjIaLmJ5dGViYXNlLnYxLkNoYW5nZWxvZ1ZpZXcSDgoGZmlsdGVyGAUgASgJIl0KFkxpc3RDaGFuZ2Vsb2dzUmVzcG9uc2USKgoKY2hhbmdlbG9ncxgBIAMoCzIWLmJ5dGViYXNlLnYxLkNoYW5nZWxvZxIXCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAkidQoTR2V0Q2hhbmdlbG9nUmVxdWVzdBI0CgRuYW1lGAEgASgJQibgQQL6QSAKHmJ5dGViYXNlLmNvbS9EYXRhYmFzZUNoYW5nZWxvZxIoCgR2aWV3GAIgASgOMhouYnl0ZWJhc2UudjEuQ2hhbmdlbG9nVmlldyL1AgoJQ2hhbmdlbG9nEgwKBG5hbWUYASABKAkSLwoLY3JlYXRlX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEi0KBnN0YXR1cxgDIAEoDjIdLmJ5dGViYXNlLnYxLkNoYW5nZWxvZy5TdGF0dXMSDgoGc2NoZW1hGAcgASgJEhMKC3NjaGVtYV9zaXplGAggASgDEhAKCHRhc2tfcnVuGAsgASgJEhcKCnBsYW5fdGl0bGUYDyABKAlCA+BBAyJDCgZTdGF0dXMSFgoSU1RBVFVTX1VOU1BFQ0lGSUVEEAASCwoHUEVORElORxABEggKBERPTkUQAhIKCgZGQUlMRUQQAzpl6kFiCh5ieXRlYmFzZS5jb20vRGF0YWJhc2VDaGFuZ2Vsb2cSQGluc3RhbmNlcy97aW5zdGFuY2V9L2RhdGFiYXNlcy97ZGF0YWJhc2V9L2NoYW5nZWxvZ3Mve2NoYW5nZWxvZ30i8QIKFkdldFNjaGVtYVN0cmluZ1JlcXVlc3QSKwoEbmFtZRgBIAEoCUId4EEC+kEXChVieXRlYmFzZS5jb20vRGF0YWJhc2USPAoEdHlwZRgCIAEoDjIuLmJ5dGViYXNlLnYxLkdldFNjaGVtYVN0cmluZ1JlcXVlc3QuT2JqZWN0VHlwZRIOCgZzY2hlbWEYAyABKAkSDgoGb2JqZWN0GAQgASgJEi8KCG1ldGFkYXRhGAUgASgLMh0uYnl0ZWJhc2UudjEuRGF0YWJhc2VNZXRhZGF0YSKaAQoKT2JqZWN0VHlwZRIbChdPQkpFQ1RfVFlQRV9VTlNQRUNJRklFRBAAEgwKCERBVEFCQVNFEAESCgoGU0NIRU1BEAISCQoFVEFCTEUQAxIICgRWSUVXEAQSFQoRTUFURVJJQUxJWkVEX1ZJRVcQBRIMCghGVU5DVElPThAGEg0KCVBST0NFRFVSRRAHEgwKCFNFUVVFTkNFEAgiMAoXR2V0U2NoZW1hU3RyaW5nUmVzcG9uc2USFQoNc2NoZW1hX3N0cmluZxgBIAEoCSo9CgpTeW5jU3RhdHVzEhsKF1NZTkNfU1RBVFVTX1VOU1BFQ0lGSUVEEAASBgoCT0sQARIKCgZGQUlMRUQQAipiCg1DaGFuZ2Vsb2dWaWV3Eh4KGkNIQU5HRUxPR19WSUVXX1VOU1BFQ0lGSUVEEAASGAoUQ0hBTkdFTE9HX1ZJRVdfQkFTSUMQARIXChNDSEFOR0VMT0dfVklFV19GVUxMEAIy7BQKD0RhdGFiYXNlU2VydmljZRKQAQoLR2V0RGF0YWJhc2USHy5ieXRlYmFzZS52MS5HZXREYXRhYmFzZVJlcXVlc3QaFS5ieXRlYmFzZS52MS5EYXRhYmFzZSJJ2kEEbmFtZYrqMBBiYi5kYXRhYmFzZXMuZ2V0kOowAYLT5JMCJBIiL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfRLdAQoRQmF0Y2hHZXREYXRhYmFzZXMSJS5ieXRlYmFzZS52MS5CYXRjaEdldERhdGFiYXNlc1JlcXVlc3QaJi5ieXRlYmFzZS52MS5CYXRjaEdldERhdGFiYXNlc1Jlc3BvbnNlInmK6jAQYmIuZGF0YWJhc2VzLmdldJDqMAKC0+STAltaLRIrL3YxL3twYXJlbnQ9aW5zdGFuY2VzLyp9L2RhdGFiYXNlczpiYXRjaEdldBIqL3YxL3twYXJlbnQ9cHJvamVjdHMvKn0vZGF0YWJhc2VzOmJhdGNoR2V0EusBCg1MaXN0RGF0YWJhc2VzEiEuYnl0ZWJhc2UudjEuTGlzdERhdGFiYXNlc1JlcXVlc3QaIi5ieXRlYmFzZS52MS5MaXN0RGF0YWJhc2VzUmVzcG9uc2UikgHaQQCK6jARYmIuZGF0YWJhc2VzLmxpc3SQ6jACgtPkkwJwWiQSIi92MS97cGFyZW50PWluc3RhbmNlcy8qfS9kYXRhYmFzZXNaJRIjL3YxL3twYXJlbnQ9d29ya3NwYWNlcy8qfS9kYXRhYmFzZXMSIS92MS97cGFyZW50PXByb2plY3RzLyp9L2RhdGFiYXNlcxLAAQoOVXBkYXRlRGF0YWJhc2USIi5ieXRlYmFzZS52MS5VcGRhdGVEYXRhYmFzZVJlcXVlc3QaFS5ieXRlYmFzZS52MS5EYXRhYmFzZSJz2kEUZGF0YWJhc2UsdXBkYXRlX21hc2uK6jATYmIuZGF0YWJhc2VzLnVwZGF0ZZDqMAGY6jABgtPkkwI3OghkYXRhYmFzZTIrL3YxL3tkYXRhYmFzZS5uYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfRLFAQoUQmF0Y2hVcGRhdGVEYXRhYmFzZXMSKC5ieXRlYmFzZS52MS5CYXRjaFVwZGF0ZURhdGFiYXNlc1JlcXVlc3QaKS5ieXRlYmFzZS52MS5CYXRjaFVwZGF0ZURhdGFiYXNlc1Jlc3BvbnNlIliK6jATYmIuZGF0YWJhc2VzLnVwZGF0ZZDqMAGY6jABgtPkkwIzOgEqIi4vdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoVXBkYXRlEqABCgxTeW5jRGF0YWJhc2USIC5ieXRlYmFzZS52MS5TeW5jRGF0YWJhc2VSZXF1ZXN0GiEuYnl0ZWJhc2UudjEuU3luY0RhdGFiYXNlUmVzcG9uc2UiS4rqMBFiYi5kYXRhYmFzZXMuc3luY5DqMAGC0+STAiw6ASoiJy92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn06c3luYxK3AQoSQmF0Y2hTeW5jRGF0YWJhc2VzEiYuYnl0ZWJhc2UudjEuQmF0Y2hTeW5jRGF0YWJhc2VzUmVxdWVzdBonLmJ5dGViYXNlLnYxLkJhdGNoU3luY0RhdGFiYXNlc1Jlc3BvbnNlIlCK6jARYmIuZGF0YWJhc2VzLnN5bmOQ6jABgtPkkwIxOgEqIiwvdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoU3luYxKwAQoTR2V0RGF0YWJhc2VNZXRhZGF0YRInLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlTWV0YWRhdGFSZXF1ZXN0Gh0uYnl0ZWJhc2UudjEuRGF0YWJhc2VNZXRhZGF0YSJRiuowFmJiLmRhdGFiYXNlcy5nZXRTY2hlbWGQ6jABgtPkkwItEisvdjEve25hbWU9aW5zdGFuY2VzLyovZGF0YWJhc2VzLyovbWV0YWRhdGF9EqgBChFHZXREYXRhYmFzZVNjaGVtYRIlLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlU2NoZW1hUmVxdWVzdBobLmJ5dGViYXNlLnYxLkRhdGFiYXNlU2NoZW1hIk+K6jAWYmIuZGF0YWJhc2VzLmdldFNjaGVtYZDqMAGC0+STAisSKS92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9zY2hlbWF9ErQBChRHZXREYXRhYmFzZVNETFNjaGVtYRIoLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlU0RMU2NoZW1hUmVxdWVzdBoeLmJ5dGViYXNlLnYxLkRhdGFiYXNlU0RMU2NoZW1hIlKK6jAWYmIuZGF0YWJhc2VzLmdldFNjaGVtYZDqMAGC0+STAi4SLC92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9zZGxTY2hlbWF9EuEBCgpEaWZmU2NoZW1hEh4uYnl0ZWJhc2UudjEuRGlmZlNjaGVtYVJlcXVlc3QaHy5ieXRlYmFzZS52MS5EaWZmU2NoZW1hUmVzcG9uc2UikQGK6jAQYmIuZGF0YWJhc2VzLmdldJDqMAGC0+STAnM6ASpaPzoBKiI6L3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qL2NoYW5nZWxvZ3MvKn06ZGlmZlNjaGVtYSItL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTpkaWZmU2NoZW1hErUBCg5MaXN0Q2hhbmdlbG9ncxIiLmJ5dGViYXNlLnYxLkxpc3RDaGFuZ2Vsb2dzUmVxdWVzdBojLmJ5dGViYXNlLnYxLkxpc3RDaGFuZ2Vsb2dzUmVzcG9uc2UiWtpBBnBhcmVudIrqMBJiYi5jaGFuZ2Vsb2dzLmxpc3SQ6jABgtPkkwIxEi8vdjEve3BhcmVudD1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn0vY2hhbmdlbG9ncxKhAQoMR2V0Q2hhbmdlbG9nEiAuYnl0ZWJhc2UudjEuR2V0Q2hhbmdlbG9nUmVxdWVzdBoWLmJ5dGViYXNlLnYxLkNoYW5nZWxvZyJX2kEEbmFtZYrqMBFiYi5jaGFuZ2Vsb2dzLmdldJDqMAGC0+STAjESLy92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9jaGFuZ2Vsb2dzLyp9EroBCg9HZXRTY2hlbWFTdHJpbmcSIy5ieXRlYmFzZS52MS5HZXRTY2hlbWFTdHJpbmdSZXF1ZXN0GiQuYnl0ZWJhc2UudjEuR2V0U2NoZW1hU3RyaW5nUmVzcG9uc2UiXNpBBG5hbWWK6jAWYmIuZGF0YWJhc2VzLmdldFNjaGVtYZDqMAGC0+STAjESLy92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9zY2hlbWFTdHJpbmd9QqoBCg9jb20uYnl0ZWJhc2UudjFCFERhdGFiYXNlU2VydmljZVByb3RvUAFaNGdpdGh1Yi5jb20vYnl0ZWJhc2UvYnl0ZWJhc2UvYmFja2VuZC9nZW5lcmF0ZWQtZ28vdjGiAgNCWFiqAgtCeXRlYmFzZS5WMcoCC0J5dGViYXNlXFYx4gIXQnl0ZWJhc2VcVjFcR1BCTWV0YWRhdGHqAgxCeXRlYmFzZTo6VjFiBnByb3RvMw", [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 5e5e07eb78..c5953e8d5d 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -3553,6 +3553,22 @@ paths:schema:type: stringtitle: default_constraint_name+ - name: metadata.schemas.tables.columns.srid+ in: query+ description: |-+ The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ Unset means the column declares no SRID; presence carries the explicit SRID,+ including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ int32).+ schema:+ type: integer+ title: srid+ - name: metadata.schemas.tables.columns.isInvisible+ in: query+ description: Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.+ schema:+ type: boolean+ title: is_invisible- name: metadata.schemas.tables.indexes.namein: querydescription: The name is the name of an index.@@ -17465,6 +17481,20 @@ components:This field is populated when syncing from the database. When empty (e.g., when parsingfrom SQL files), the system cannot automatically drop the constraint.+ srid:+ type:+ - integer+ - "null"+ title: srid+ description: |-+ The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ Unset means the column declares no SRID; presence carries the explicit SRID,+ including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ int32).+ isInvisible:+ type: boolean+ title: is_invisible+ description: Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.title: ColumnMetadataadditionalProperties: falsedescription: ColumnMetadata is the metadata for columns.diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex dfdc4666af..1c5da6a49a 100644--- a/proto/gen/grpc-doc/store/README.md+++ b/proto/gen/grpc-doc/store/README.md@@ -1058,6 +1058,8 @@ Will create a constraint with an auto-generated name like 'DF__employees__stTo modify the default, you must first drop the existing constraint by name: ALTER TABLE employees DROP CONSTRAINT DF__employees__statu__3B75D760 ALTER TABLE employees ADD CONSTRAINT DF_employees_status DEFAULT 'inactive' FOR statusThis field is populated when syncing from the database. When empty (e.g., when parsing from SQL files), the system cannot automatically drop the constraint. |+| srid | [uint32](#uint32) | optional | The spatial reference system identifier of a spatial column, MySQL 8.0 only. Unset means the column declares no SRID; presence carries the explicit SRID, including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed int32). Captured from information_schema.COLUMNS.SRS_ID and rendered as the `/*!80003 SRID n */` column attribute. |+| is_invisible | [bool](#bool) | | Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only. Captured from information_schema.COLUMNS.EXTRA containing INVISIBLE and rendered as the `/*!80023 INVISIBLE */` column attribute. |diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex db904931f3..e0bcea2ad1 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -3151,6 +3151,8 @@ Will create a constraint with an auto-generated name like 'DF__employees__stTo modify the default, you must first drop the existing constraint by name: ALTER TABLE employees DROP CONSTRAINT DF__employees__statu__3B75D760 ALTER TABLE employees ADD CONSTRAINT DF_employees_status DEFAULT 'inactive' FOR statusThis field is populated when syncing from the database. When empty (e.g., when parsing from SQL files), the system cannot automatically drop the constraint. |+| srid | [uint32](#uint32) | optional | The spatial reference system identifier of a spatial column, MySQL 8.0 only. Unset means the column declares no SRID; presence carries the explicit SRID, including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed int32). |+| is_invisible | [bool](#bool) | | Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only. |diff --git a/proto/store/store/database.proto b/proto/store/store/database.protoindex a343fe31d8..c4e983834f 100644--- a/proto/store/store/database.proto+++ b/proto/store/store/database.proto@@ -559,6 +559,18 @@ message ColumnMetadata {// This field is populated when syncing from the database. When empty (e.g., when parsing// from SQL files), the system cannot automatically drop the constraint.string default_constraint_name = 20;++ // The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ // Unset means the column declares no SRID; presence carries the explicit SRID,+ // including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ // int32). Captured from information_schema.COLUMNS.SRS_ID and rendered as the+ // `/*!80003 SRID n */` column attribute.+ optional uint32 srid = 21;++ // Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.+ // Captured from information_schema.COLUMNS.EXTRA containing INVISIBLE and+ // rendered as the `/*!80023 INVISIBLE */` column attribute.+ bool is_invisible = 22;}message GenerationMetadata {diff --git a/proto/v1/v1/database_service.proto b/proto/v1/v1/database_service.protoindex 799d54acbf..759163c9c1 100644--- a/proto/v1/v1/database_service.proto+++ b/proto/v1/v1/database_service.proto@@ -908,6 +908,15 @@ message ColumnMetadata {// This field is populated when syncing from the database. When empty (e.g., when parsing// from SQL files), the system cannot automatically drop the constraint.string default_constraint_name = 17;++ // The spatial reference system identifier of a spatial column, MySQL 8.0 only.+ // Unset means the column declares no SRID; presence carries the explicit SRID,+ // including the valid SRID 0. SRS_IDs are unsigned 32-bit (custom SRSs may exceed+ // int32).+ optional uint32 srid = 18;++ // Whether the column is invisible (hidden from SELECT *), MySQL 8.0.23+ only.+ bool is_invisible = 19;}message GenerationMetadata {