pkg/lightning: normalize view restore dependency lookup

haiboumich · haiboumich · commit 27006a5c1540 · 2026-05-19T16:29:08.000+08:00
diff --git a/pkg/lightning/mydump/schema_import.go b/pkg/lightning/mydump/schema_import.go
@@ -240,13 +240,14 @@ func (si *SchemaImporter) importViews(ctx context.Context, plan *SchemaImportPla
 	p.SetSQLMode(si.sqlMode)
 
 	for _, node := range plan.viewPlan.ordered {
-		if existingViews.has(node.key) {
+		normalizedKey := normalizeTableName(node.key.Schema, node.key.Name)
+		if existingViews.has(normalizedKey) {
 			si.logger.Info("view already exists in downstream, skip",
 				zap.String("db", node.key.Schema),
 				zap.String("view-name", node.key.Name))
 			continue
 		}
-		if existingTables.has(node.key) {
+		if existingTables.has(normalizedKey) {
 			return common.ErrCreateSchema.GenWithStack("downstream table already exists for view '%s'", node.key.String())
 		}
 		if err := si.runCommonJob(ctx, p, &schemaJob{
diff --git a/pkg/lightning/mydump/schema_import_test.go b/pkg/lightning/mydump/schema_import_test.go
@@ -285,6 +285,30 @@ func TestSchemaImporter(t *testing.T) {
 		require.NoError(t, os.Remove(path.Join(tempDir, fileNameV2)))
 		require.NoError(t, os.Remove(path.Join(tempDir, fileNameValidV1)))
 	})
+
+	t.Run("view: skip existing view with different case", func(t *testing.T) {
+		fileNameV2 := "test03.V2-schema-view.sql"
+		require.NoError(t, os.WriteFile(path.Join(tempDir, fileNameV2), []byte("create view V2 as select * from t;"), 0o644))
+		dbMetas := []*MDDatabaseMeta{
+			{Name: "test03", Tables: []*MDTableMeta{{DB: "test03", Name: "t"}}},
+			{Name: "test03", Views: []*MDTableMeta{
+				{DB: "test03", Name: "V2", charSet: "auto", SchemaFile: FileInfo{FileMeta: SourceFileMeta{Path: fileNameV2}}},
+			}},
+		}
+
+		mock.ExpectQuery(`information_schema.SCHEMATA`).WillReturnRows(
+			sqlmock.NewRows([]string{"SCHEMA_NAME"}).AddRow("test03"))
+		mock.ExpectQuery("SHOW CREATE TABLE `test03`.`t`").
+			WillReturnRows(sqlmock.NewRows([]string{"Table", "Create Table"}).AddRow("t", "CREATE TABLE `t` (a int);"))
+		mock.ExpectQuery("TABLES WHERE TABLE_SCHEMA = 'test03' AND TABLE_NAME = 't'").
+			WillReturnRows(sqlmock.NewRows([]string{"TABLE_TYPE"}).AddRow("BASE TABLE"))
+		mock.ExpectQuery("TABLES WHERE TABLE_SCHEMA = 'test03' AND TABLE_NAME = 'V2'").
+			WillReturnRows(sqlmock.NewRows([]string{"TABLE_TYPE"}).AddRow("VIEW"))
+
+		require.NoError(t, importer.Run(ctx, dbMetas))
+		require.NoError(t, mock.ExpectationsWereMet())
+		require.NoError(t, os.Remove(path.Join(tempDir, fileNameV2)))
+	})
 }
 
 func TestNewSchemaImportPlan(t *testing.T) {
diff --git a/pkg/lightning/mydump/view_restore.go b/pkg/lightning/mydump/view_restore.go
@@ -36,14 +36,14 @@ func (s tableNameSet) add(tbl filter.Table) {
 	if s == nil {
 		return
 	}
-	s[tbl] = struct{}{}
+	s[normalizeTableName(tbl.Schema, tbl.Name)] = struct{}{}
 }
 
 func (s tableNameSet) has(tbl filter.Table) bool {
 	if s == nil {
 		return false
 	}
-	_, ok := s[tbl]
+	_, ok := s[normalizeTableName(tbl.Schema, tbl.Name)]
 	return ok
 }
 
@@ -85,24 +85,75 @@ type SchemaImportPlan struct {
 type viewDependencyCollector struct {
 	currentSchema string
 	deps          tableNameSet
+	cteNameScopes []map[string]struct{}
+}
+
+func (c *viewDependencyCollector) pushCTEScope() {
+	c.cteNameScopes = append(c.cteNameScopes, make(map[string]struct{}))
+}
+
+func (c *viewDependencyCollector) popCTEScope() {
+	if len(c.cteNameScopes) == 0 {
+		return
+	}
+	c.cteNameScopes = c.cteNameScopes[:len(c.cteNameScopes)-1]
+}
+
+func (c *viewDependencyCollector) recordCTEName(name string) {
+	if len(c.cteNameScopes) == 0 {
+		return
+	}
+	c.cteNameScopes[len(c.cteNameScopes)-1][strings.ToLower(name)] = struct{}{}
+}
+
+func (c *viewDependencyCollector) isCTEName(name string) bool {
+	normalized := strings.ToLower(name)
+	for i := len(c.cteNameScopes) - 1; i >= 0; i-- {
+		if _, ok := c.cteNameScopes[i][normalized]; ok {
+			return true
+		}
+	}
+	return false
 }
 
 func (c *viewDependencyCollector) Enter(n ast.Node) (ast.Node, bool) {
-	tbl, ok := n.(*ast.TableName)
-	if !ok {
+	switch node := n.(type) {
+	case *ast.SelectStmt:
+		if node.With != nil {
+			c.pushCTEScope()
+		}
 		return n, false
-	}
+	case *ast.CommonTableExpression:
+		if node.IsRecursive {
+			c.recordCTEName(node.Name.O)
+		}
+		return n, false
+	case *ast.TableName:
+		if node.Schema.O == "" && c.isCTEName(node.Name.O) {
+			return n, true
+		}
 
-	schema := tbl.Schema.O
-	if schema == "" {
-		// Dumpling may omit the schema for same-database references.
-		schema = c.currentSchema
+		schema := node.Schema.O
+		if schema == "" {
+			// Dumpling may omit the schema for same-database references.
+			schema = c.currentSchema
+		}
+		c.deps.add(filterTableName(schema, node.Name.O))
+		return n, true
+	default:
+		return n, false
 	}
-	c.deps.add(filter.Table{Schema: schema, Name: tbl.Name.O})
-	return n, true
 }
 
-func (*viewDependencyCollector) Leave(n ast.Node) (ast.Node, bool) {
+func (c *viewDependencyCollector) Leave(n ast.Node) (ast.Node, bool) {
+	switch node := n.(type) {
+	case *ast.CommonTableExpression:
+		c.recordCTEName(node.Name.O)
+	case *ast.SelectStmt:
+		if node.With != nil {
+			c.popCTEScope()
+		}
+	}
 	return n, true
 }
 
@@ -235,30 +286,33 @@ func buildViewRestorePlan(parsedViews []*parsedViewSchema, dumpTables tableNameS
 	}
 
 	for _, parsed := range parsedViews {
-		if _, exists := plan.nodes[parsed.key]; exists {
+		normalizedKey := normalizeTableName(parsed.key.Schema, parsed.key.Name)
+		if _, exists := plan.nodes[normalizedKey]; exists {
 			return nil, errors.Errorf("duplicate view definition for %s", parsed.key.String())
 		}
-		plan.nodes[parsed.key] = &viewNode{
+		plan.nodes[normalizedKey] = &viewNode{
 			key:       parsed.key,
 			deps:      append([]filter.Table(nil), parsed.deps...),
 			createSQL: parsed.createSQL,
 		}
 	}
 
 	for _, node := range plan.nodes {
+		nodeKey := normalizeTableName(node.key.Schema, node.key.Name)
 		for _, dep := range node.deps {
-			if dep == node.key {
+			normalizedDep := normalizeTableName(dep.Schema, dep.Name)
+			if normalizedDep == nodeKey {
 				return nil, errors.Errorf("cyclic view dependency detected for %s", node.key.String())
 			}
-			if depNode, ok := plan.nodes[dep]; ok {
+			if depNode, ok := plan.nodes[normalizedDep]; ok {
 				node.indegree++
-				depNode.dependents = append(depNode.dependents, node.key)
+				depNode.dependents = append(depNode.dependents, nodeKey)
 				continue
 			}
-			if dumpTables.has(dep) {
+			if dumpTables.has(normalizedDep) {
 				continue
 			}
-			node.externalDeps = append(node.externalDeps, dep)
+			node.externalDeps = append(node.externalDeps, normalizedDep)
 		}
 		sort.Slice(node.dependents, func(i, j int) bool {
 			if node.dependents[i].Schema != node.dependents[j].Schema {
diff --git a/pkg/lightning/mydump/view_restore_test.go b/pkg/lightning/mydump/view_restore_test.go
@@ -103,6 +103,22 @@ JOIN db2.base_table ON base_table.id = src.id;
 	)
 }
 
+func TestParseViewSchemaSQLIgnoresCTEDependencies(t *testing.T) {
+	p := parser.New()
+	currentView := filter.Table{Schema: "test", Name: "v_cte"}
+	sql := `
+CREATE VIEW v_cte AS
+WITH cte AS (
+	SELECT id FROM t1
+)
+SELECT cte.id FROM cte;
+`
+
+	parsed, err := parseViewSchemaSQL(p, currentView, sql)
+	require.NoError(t, err)
+	require.Equal(t, []filter.Table{{Schema: "test", Name: "t1"}}, parsed.deps)
+}
+
 func TestBuildViewRestorePlan(t *testing.T) {
 	v1 := filter.Table{Schema: "test", Name: "v1"}
 	v2 := filter.Table{Schema: "test", Name: "v2"}
@@ -171,6 +187,31 @@ func TestBuildViewRestorePlanSupportsMultipleAndCrossSchemaViewDeps(t *testing.T
 	require.Equal(t, []filter.Table{db2v2}, plan.nodes[db2v3].dependents)
 }
 
+func TestBuildViewRestorePlanNormalizesCaseInsensitiveDeps(t *testing.T) {
+	v1 := filter.Table{Schema: "test", Name: "v1"}
+	v2 := filter.Table{Schema: "test", Name: "V2"}
+	dumpTables := make(tableNameSet)
+	dumpTables.add(filter.Table{Schema: "test", Name: "t"})
+
+	plan, err := buildViewRestorePlan([]*parsedViewSchema{
+		{
+			key:       v1,
+			deps:      []filter.Table{{Schema: "test", Name: "t"}},
+			createSQL: "CREATE VIEW `test`.`v1` AS SELECT `id` FROM `test`.`t`;",
+		},
+		{
+			key:       v2,
+			deps:      []filter.Table{{Schema: "Test", Name: "V1"}},
+			createSQL: "CREATE VIEW `test`.`V2` AS SELECT `id` FROM `test`.`v1`;",
+		},
+	}, dumpTables)
+	require.NoError(t, err)
+	require.Len(t, plan.ordered, 2)
+	require.Equal(t, v1, plan.ordered[0].key)
+	require.Equal(t, v2, plan.ordered[1].key)
+	require.Empty(t, plan.nodes[normalizeTableName(v2.Schema, v2.Name)].externalDeps)
+}
+
 func TestBuildViewRestorePlanDetectsCycle(t *testing.T) {
 	_, err := buildViewRestorePlan([]*parsedViewSchema{
 		{
