Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

chore(mysql): lookup system schema in lowercase always (#20068)

h3n4l6e82487f89ff
diff --git a/backend/plugin/parser/mysql/query_span_extractor.go b/backend/plugin/parser/mysql/query_span_extractor.go
index e190a9c97f..25e7e09003 100644
--- a/backend/plugin/parser/mysql/query_span_extractor.go
+++ b/backend/plugin/parser/mysql/query_span_extractor.go
@@ -1531,18 +1531,31 @@ func isMixedQuery(m base.SourceColumnSet, ignoreCaseSensitive bool) (bool, bool)
return !hasUser && hasSystem, false
}
-var systemDatabases = map[string]bool{
+// reservedSystemDatabases are schema names MySQL itself reserves regardless of
+// lower_case_table_names. A user cannot create a schema whose lowercase name
+// collides with any of these, so matching is always case-insensitive.
+var reservedSystemDatabases = map[string]bool{
"information_schema": true,
"performance_schema": true,
- "mysql": true,
+}
+
+// onDiskSystemDatabases are system schemas stored on disk. On case-sensitive
+// instances (lower_case_table_names=0), users can legitimately create a distinct
+// schema whose name differs from these only by case, so we only match them
+// case-insensitively when the instance is case-insensitive.
+var onDiskSystemDatabases = map[string]bool{
+ "mysql": true,
}
func isSystemResource(resource base.ColumnResource, ignoreCaseSensitive bool) bool {
+ if reservedSystemDatabases[strings.ToLower(resource.Database)] {
+ return true
+ }
database := resource.Database
if ignoreCaseSensitive {
database = strings.ToLower(database)
}
- return systemDatabases[database]
+ return onDiskSystemDatabases[database]
}
func mysqlExtractColumnsClause(ctx parser.IColumnsClauseContext) []string {
diff --git a/backend/plugin/parser/mysql/system_resource_test.go b/backend/plugin/parser/mysql/system_resource_test.go
new file mode 100644
index 0000000000..b977dabbf1
--- /dev/null
+++ b/backend/plugin/parser/mysql/system_resource_test.go
@@ -0,0 +1,63 @@
+package mysql
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestIsSystemResource(t *testing.T) {
+ cases := []struct {
+ name string
+ database string
+ ignoreCaseSensitive bool
+ want bool
+ }{
+ // information_schema — reserved by MySQL server, always case-insensitive.
+ {"info_schema lowercase, case-sensitive instance", "information_schema", false, true},
+ {"info_schema uppercase, case-sensitive instance", "INFORMATION_SCHEMA", false, true},
+ {"info_schema mixed case, case-sensitive instance", "Information_Schema", false, true},
+ {"info_schema uppercase, case-insensitive instance", "INFORMATION_SCHEMA", true, true},
+
+ // performance_schema — reserved by MySQL server, always case-insensitive.
+ {"perf_schema lowercase, case-sensitive instance", "performance_schema", false, true},
+ {"perf_schema uppercase, case-sensitive instance", "PERFORMANCE_SCHEMA", false, true},
+
+ // mysql — on-disk schema, only case-insensitive when the instance is
+ // (lower_case_table_names != 0). Case-sensitive instances can host a
+ // separate user schema named e.g. `MySQL`, which must NOT be treated
+ // as a system schema.
+ {"mysql lowercase, case-sensitive instance", "mysql", false, true},
+ {"mysql uppercase, case-sensitive instance (user schema)", "MYSQL", false, false},
+ {"mysql mixed case, case-sensitive instance (user schema)", "MySQL", false, false},
+ {"mysql uppercase, case-insensitive instance", "MYSQL", true, true},
+ {"mysql mixed case, case-insensitive instance", "MySQL", true, true},
+
+ // Arbitrary user schemas are never system.
+ {"user schema lowercase", "byt9309_db", false, false},
+ {"user schema uppercase", "BYT9309_DB", false, false},
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ got := isSystemResource(base.ColumnResource{Database: tc.database}, tc.ignoreCaseSensitive)
+ require.Equal(t, tc.want, got)
+ })
+ }
+}
+
+// TestIsSystemResourceBYT9309 pins the specific regression: uppercase
+// `INFORMATION_SCHEMA` on a case-sensitive instance must be recognized as
+// a system schema, so `isMixedQuery` can short-circuit and prevent the
+// span extractor from flagging it as a not-found user database — which
+// previously cascaded into a nil-pointer panic in the schema syncer.
+func TestIsSystemResourceBYT9309(t *testing.T) {
+ set := base.SourceColumnSet{
+ {Database: "INFORMATION_SCHEMA", Table: "PROCESSLIST"}: true,
+ }
+ allSystem, mixed := isMixedQuery(set, false /* case-sensitive instance */)
+ require.True(t, allSystem, "INFORMATION_SCHEMA.PROCESSLIST should be treated as system on a case-sensitive instance")
+ require.False(t, mixed)
+}