Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(advisor/tidb): migrate naming index/UK/FK convention to omni AST (Phase 1.5 §1.5.3 batch 4) (#20204)
Vincent Huangdf8b579a30af
diff --git a/backend/plugin/advisor/tidb/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/tidb/advisor_naming_foreign_key_convention.goindex c8f5f31ca3..5f5089b561 100644--- a/backend/plugin/advisor/tidb/advisor_naming_foreign_key_convention.go+++ b/backend/plugin/advisor/tidb/advisor_naming_foreign_key_convention.go@@ -2,14 +2,10 @@ package tidbimport ("context"- "fmt""strings"- "github.com/pkg/errors"+ "github.com/bytebase/omni/tidb/ast"- "github.com/pingcap/tidb/pkg/parser/ast"-- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"@@ -17,7 +13,6 @@ import (var (_ advisor.Advisor = (*NamingFKConventionAdvisor)(nil)- _ ast.Visitor = (*namingFKConventionChecker)(nil))func init() {@@ -30,161 +25,86 @@ type NamingFKConventionAdvisor struct {// Check checks for foreign key naming convention.func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := getTiDBNodes(checkCtx)-- if err != nil {- return nil, err- }-- level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)- if err != nil {- return nil, err- }-- namingPayload := checkCtx.Rule.GetNamingPayload()- if namingPayload == nil {- return nil, errors.New("naming_payload is required for this rule")- }-- format := namingPayload.Format- templateList, _ := advisor.ParseTemplateTokens(format)-- for _, key := range templateList {- if _, ok := advisor.TemplateNamingTokens[checkCtx.Rule.Type][key]; !ok {- return nil, errors.Errorf("invalid template %s for rule %s", key, checkCtx.Rule.Type)+ return runNamingConventionRule(checkCtx, namingRuleConfig{+ mismatchCode: code.NamingFKConventionMismatch,+ typeNoun: "Foreign key",+ internalErrorTitle: "Internal error for foreign key naming convention rule",+ }, func(ostmt OmniStmt) []*indexMetaData {+ switch n := ostmt.Node.(type) {+ case *ast.CreateTableStmt:+ return collectFKCreateTable(ostmt, n)+ case *ast.AlterTableStmt:+ return collectFKAlterTable(ostmt, n)}- }-- maxLength := int(namingPayload.MaxLength)- if maxLength == 0 {- maxLength = advisor.DefaultNameLengthLimit- }- checker := &namingFKConventionChecker{- level: level,- title: checkCtx.Rule.Type.String(),- format: format,- maxLength: maxLength,- templateList: templateList,- }- for _, stmtNode := range root {- (stmtNode).Accept(checker)- }-- return checker.adviceList, nil+ return nil+ })}-type namingFKConventionChecker struct {- adviceList []*storepb.Advice- level storepb.Advice_Status- title string- format string- maxLength int- templateList []string-}--// Enter implements the ast.Visitor interface.-func (checker *namingFKConventionChecker) Enter(in ast.Node) (ast.Node, bool) {- indexDataList := checker.getMetaDataList(in)-- for _, indexData := range indexDataList {- regex, err := getTemplateRegexp(checker.format, checker.templateList, indexData.metaData)- if err != nil {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.Internal.Int32(),- Title: "Internal error for foreign key naming convention rule",- Content: fmt.Sprintf("%q meet internal error %q", in.Text(), err.Error()),- })+func collectFKCreateTable(ostmt OmniStmt, n *ast.CreateTableStmt) []*indexMetaData {+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ var res []*indexMetaData+ for _, constraint := range n.Constraints {+ // Nil-check before evaluating constraint.Loc.Start; otherwise the+ // line-computation argument would panic ahead of buildFKMetaData's+ // own nil guard. Mirrors the index/UK CreateTable collectors.+ if constraint == nil {continue}- if !regex.MatchString(indexData.indexName) {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.NamingFKConventionMismatch.Int32(),- Title: checker.title,- Content: fmt.Sprintf("Foreign key in table `%s` mismatches the naming convention, expect %q but found `%s`", indexData.tableName, regex, indexData.indexName),- StartPosition: common.ConvertANTLRLineToPosition(indexData.line),- })- }- if checker.maxLength > 0 && len(indexData.indexName) > checker.maxLength {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.NamingFKConventionMismatch.Int32(),- Title: checker.title,- Content: fmt.Sprintf("Foreign key `%s` in table `%s` mismatches the naming convention, its length should be within %d characters", indexData.indexName, indexData.tableName, checker.maxLength),- StartPosition: common.ConvertANTLRLineToPosition(indexData.line),- })+ if metaData := buildFKMetaData(tableName, constraint, ostmt.AbsoluteLine(constraint.Loc.Start)); metaData != nil {+ res = append(res, metaData)}}-- return in, false-}--// Leave implements the ast.Visitor interface.-func (*namingFKConventionChecker) Leave(in ast.Node) (ast.Node, bool) {- return in, true+ return res}-// getMetaDataList returns the list of foreign key with meta data.-func (*namingFKConventionChecker) getMetaDataList(in ast.Node) []*indexMetaData {+func collectFKAlterTable(ostmt OmniStmt, n *ast.AlterTableStmt) []*indexMetaData {+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ stmtLine := ostmt.FirstTokenLine()var res []*indexMetaData-- switch node := in.(type) {- case *ast.CreateTableStmt:- for _, constraint := range node.Constraints {- if constraint.Tp == ast.ConstraintForeignKey {- var referencingColumnList []string- for _, key := range constraint.Keys {- referencingColumnList = append(referencingColumnList, key.Column.Name.String())- }- var referencedColumnList []string- for _, spec := range constraint.Refer.IndexPartSpecifications {- referencedColumnList = append(referencedColumnList, spec.Column.Name.String())- }-- metaData := map[string]string{- advisor.ReferencingTableNameTemplateToken: node.Table.Name.String(),- advisor.ReferencingColumnNameTemplateToken: strings.Join(referencingColumnList, "_"),- advisor.ReferencedTableNameTemplateToken: constraint.Refer.Table.Name.String(),- advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumnList, "_"),- }-- res = append(res, &indexMetaData{- indexName: constraint.Name,- tableName: node.Table.Name.String(),- metaData: metaData,- line: constraint.OriginTextPosition(),- })- }+ for _, cmd := range n.Commands {+ if cmd == nil {+ continue}- case *ast.AlterTableStmt:- for _, spec := range node.Specs {- if spec.Tp == ast.AlterTableAddConstraint && spec.Constraint.Tp == ast.ConstraintForeignKey {- var referencingColumnList []string- for _, key := range spec.Constraint.Keys {- referencingColumnList = append(referencingColumnList, key.Column.Name.String())- }- var referencedColumnList []string- for _, spec := range spec.Constraint.Refer.IndexPartSpecifications {- referencedColumnList = append(referencedColumnList, spec.Column.Name.String())- }-- metaData := map[string]string{- advisor.ReferencingTableNameTemplateToken: node.Table.Name.String(),- advisor.ReferencingColumnNameTemplateToken: strings.Join(referencingColumnList, "_"),- advisor.ReferencedTableNameTemplateToken: spec.Constraint.Refer.Table.Name.String(),- advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumnList, "_"),- }- res = append(res, &indexMetaData{- indexName: spec.Constraint.Name,- tableName: node.Table.Name.String(),- metaData: metaData,- line: in.OriginTextPosition(),- })- }+ // FOREIGN KEY definitions land on ATAddConstraint only — no+ // ATAddIndex equivalent (mirroring mysql omni rule).+ if cmd.Type != ast.ATAddConstraint {+ continue+ }+ if metaData := buildFKMetaData(tableName, cmd.Constraint, stmtLine); metaData != nil {+ res = append(res, metaData)}- default:}-return res}++func buildFKMetaData(tableName string, constraint *ast.Constraint, line int) *indexMetaData {+ if constraint == nil || constraint.Type != ast.ConstrForeignKey {+ return nil+ }+ referencingColumnList := constraint.Columns+ referencedTable := ""+ // constraint.RefTable can be nil even on FK constraints in pathological+ // inputs; guard defensively per the mysql omni analog.+ if constraint.RefTable != nil {+ referencedTable = constraint.RefTable.Name+ }+ referencedColumnList := constraint.RefColumns+ metaData := map[string]string{+ advisor.ReferencingTableNameTemplateToken: tableName,+ advisor.ReferencingColumnNameTemplateToken: strings.Join(referencingColumnList, "_"),+ advisor.ReferencedTableNameTemplateToken: referencedTable,+ advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumnList, "_"),+ }+ return &indexMetaData{+ indexName: constraint.Name,+ tableName: tableName,+ metaData: metaData,+ line: line,+ }+}diff --git a/backend/plugin/advisor/tidb/advisor_naming_index_convention.go b/backend/plugin/advisor/tidb/advisor_naming_index_convention.goindex 34e62e3361..ee0bc509ef 100644--- a/backend/plugin/advisor/tidb/advisor_naming_index_convention.go+++ b/backend/plugin/advisor/tidb/advisor_naming_index_convention.go@@ -2,15 +2,10 @@ package tidbimport ("context"- "fmt"- "regexp""strings"- "github.com/pkg/errors"+ "github.com/bytebase/omni/tidb/ast"- "github.com/pingcap/tidb/pkg/parser/ast"-- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"@@ -19,7 +14,6 @@ import (var (_ advisor.Advisor = (*NamingIndexConventionAdvisor)(nil)- _ ast.Visitor = (*namingIndexConventionChecker)(nil))func init() {@@ -32,221 +26,142 @@ type NamingIndexConventionAdvisor struct {// Check checks for index naming convention.func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := getTiDBNodes(checkCtx)-- if err != nil {- return nil, err- }-- level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)- if err != nil {- return nil, err- }-- namingPayload := checkCtx.Rule.GetNamingPayload()- if namingPayload == nil {- return nil, errors.New("naming_payload is required for this rule")- }-- format := namingPayload.Format- templateList, _ := advisor.ParseTemplateTokens(format)-- for _, key := range templateList {- if _, ok := advisor.TemplateNamingTokens[checkCtx.Rule.Type][key]; !ok {- return nil, errors.Errorf("invalid template %s for rule %s", key, checkCtx.Rule.Type)+ // Capture originalMetadata in a local so the collector closure can read+ // it without runNamingConventionRule needing advisor.Context in its+ // callback signature — the FK rule doesn't need metadata, so keeping+ // the helper signature uniform is cleaner than threading a Context arg.+ originalMetadata := checkCtx.OriginalMetadata+ return runNamingConventionRule(checkCtx, namingRuleConfig{+ mismatchCode: code.NamingIndexConventionMismatch,+ typeNoun: "Index",+ internalErrorTitle: "Internal error for index naming convention rule",+ }, func(ostmt OmniStmt) []*indexMetaData {+ switch n := ostmt.Node.(type) {+ case *ast.CreateTableStmt:+ return collectIndexCreateTable(ostmt, n)+ case *ast.AlterTableStmt:+ return collectIndexAlterTable(ostmt, n, originalMetadata)+ case *ast.CreateIndexStmt:+ return collectIndexCreateIndex(ostmt, n)}- }-- maxLength := int(namingPayload.MaxLength)- if maxLength == 0 {- maxLength = advisor.DefaultNameLengthLimit- }- checker := &namingIndexConventionChecker{- level: level,- title: checkCtx.Rule.Type.String(),- format: format,- maxLength: maxLength,- templateList: templateList,- originalMetadata: checkCtx.OriginalMetadata,- }- for _, stmtNode := range root {- (stmtNode).Accept(checker)- }-- return checker.adviceList, nil+ return nil+ })}-type namingIndexConventionChecker struct {- adviceList []*storepb.Advice- level storepb.Advice_Status- title string- format string- maxLength int- templateList []string- originalMetadata *model.DatabaseMetadata-}--// Enter implements the ast.Visitor interface.-func (checker *namingIndexConventionChecker) Enter(in ast.Node) (ast.Node, bool) {- indexDataList := checker.getMetaDataList(in)-- for _, indexData := range indexDataList {- regex, err := getTemplateRegexp(checker.format, checker.templateList, indexData.metaData)- if err != nil {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.Internal.Int32(),- Title: "Internal error for index naming convention rule",- Content: fmt.Sprintf("%q meet internal error %q", in.Text(), err.Error()),- })+func collectIndexCreateTable(ostmt OmniStmt, n *ast.CreateTableStmt) []*indexMetaData {+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ var res []*indexMetaData+ for _, constraint := range n.Constraints {+ if constraint == nil || constraint.Type != ast.ConstrIndex {continue}- if !regex.MatchString(indexData.indexName) {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.NamingIndexConventionMismatch.Int32(),- Title: checker.title,- Content: fmt.Sprintf("Index in table `%s` mismatches the naming convention, expect %q but found `%s`", indexData.tableName, regex, indexData.indexName),- StartPosition: common.ConvertANTLRLineToPosition(indexData.line),- })+ columnList := constraint.Columns+ if len(columnList) == 0 {+ columnList = omniIndexColumns(constraint.IndexColumns)}- if checker.maxLength > 0 && len(indexData.indexName) > checker.maxLength {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.NamingIndexConventionMismatch.Int32(),- Title: checker.title,- Content: fmt.Sprintf("Index `%s` in table `%s` mismatches the naming convention, its length should be within %d characters", indexData.indexName, indexData.tableName, checker.maxLength),- StartPosition: common.ConvertANTLRLineToPosition(indexData.line),- })+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,}+ res = append(res, &indexMetaData{+ indexName: constraint.Name,+ tableName: tableName,+ metaData: metaData,+ line: ostmt.AbsoluteLine(constraint.Loc.Start),+ })}-- return in, false-}--// Leave implements the ast.Visitor interface.-func (*namingIndexConventionChecker) Leave(in ast.Node) (ast.Node, bool) {- return in, true-}--type indexMetaData struct {- indexName string- tableName string- metaData map[string]string- line int+ return res}-// getMetaDataList returns the list of index with meta data.-func (checker *namingIndexConventionChecker) getMetaDataList(in ast.Node) []*indexMetaData {+func collectIndexAlterTable(ostmt OmniStmt, n *ast.AlterTableStmt, originalMetadata *model.DatabaseMetadata) []*indexMetaData {+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ stmtLine := ostmt.FirstTokenLine()var res []*indexMetaData-- switch node := in.(type) {- case *ast.CreateTableStmt:- for _, constraint := range node.Constraints {- if constraint.Tp == ast.ConstraintIndex {- var columnList []string- for _, key := range constraint.Keys {- if key.Column == nil {- continue- }- columnList = append(columnList, key.Column.Name.String())- }- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),- }- res = append(res, &indexMetaData{- indexName: constraint.Name,- tableName: node.Table.Name.String(),- metaData: metaData,- line: constraint.OriginTextPosition(),- })- }+ for _, cmd := range n.Commands {+ if cmd == nil {+ continue}- case *ast.AlterTableStmt:- for _, spec := range node.Specs {- switch spec.Tp {- case ast.AlterTableRenameIndex:- schema := checker.originalMetadata.GetSchemaMetadata("")- var index *model.IndexMetadata- if schema != nil {- index = schema.GetIndex(spec.FromKey.String())- }- if index == nil {- continue- }- if index.GetProto().GetUnique() {- // Unique index naming convention should in advisor_naming_unique_key_convention.go- continue- }- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),- }- res = append(res, &indexMetaData{- indexName: spec.ToKey.String(),- tableName: node.Table.Name.String(),- metaData: metaData,- line: in.OriginTextPosition(),- })- case ast.AlterTableAddConstraint:- if spec.Constraint.Tp == ast.ConstraintIndex {- var columnList []string- for _, key := range spec.Constraint.Keys {- if key.Column == nil {- continue- }- columnList = append(columnList, key.Column.Name.String())- }-- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),- }- res = append(res, &indexMetaData{- indexName: spec.Constraint.Name,- tableName: node.Table.Name.String(),- metaData: metaData,- line: in.OriginTextPosition(),- })- }- default:- // Skip other alter table specification types+ switch cmd.Type {+ // ATAddIndex (omni) and ATAddConstraint (omni) are split where pingcap+ // collapsed both ALTER TABLE ADD INDEX and ALTER TABLE ADD CONSTRAINT+ // INDEX into AlterTableAddConstraint. Mirror the mysql omni branching+ // to cover both syntactic forms.+ case ast.ATAddConstraint, ast.ATAddIndex:+ if cmd.Constraint == nil || cmd.Constraint.Type != ast.ConstrIndex {+ continue}- }- case *ast.CreateIndexStmt:- if node.KeyType != ast.IndexKeyTypeUnique {- var columnList []string- for _, spec := range node.IndexPartSpecifications {- if spec.Column == nil {- continue- }- columnList = append(columnList, spec.Column.Name.String())+ columnList := cmd.Constraint.Columns+ if len(columnList) == 0 {+ columnList = omniIndexColumns(cmd.Constraint.IndexColumns)}metaData := map[string]string{advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),+ advisor.TableNameTemplateToken: tableName,+ }+ res = append(res, &indexMetaData{+ indexName: cmd.Constraint.Name,+ tableName: tableName,+ metaData: metaData,+ line: stmtLine,+ })+ case ast.ATRenameIndex:+ schema := originalMetadata.GetSchemaMetadata("")+ if schema == nil {+ continue+ }+ index := schema.GetIndex(cmd.Name)+ if index == nil {+ continue+ }+ if index.GetProto().GetUnique() {+ // Unique index naming convention is handled by+ // advisor_naming_unique_key_convention.go.+ continue+ }+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),+ advisor.TableNameTemplateToken: tableName,}res = append(res, &indexMetaData{- indexName: node.IndexName,- tableName: node.Table.Name.String(),+ indexName: cmd.NewName,+ tableName: tableName,metaData: metaData,- line: in.OriginTextPosition(),+ line: stmtLine,})+ default:}- default:}-return res}-// getTemplateRegexp formats the template as regex.-func getTemplateRegexp(template string, templateList []string, tokens map[string]string) (*regexp.Regexp, error) {- for _, key := range templateList {- if token, ok := tokens[key]; ok {- template = strings.ReplaceAll(template, key, token)- }+func collectIndexCreateIndex(ostmt OmniStmt, n *ast.CreateIndexStmt) []*indexMetaData {+ // Preserve pingcap behavior: only exclude unique indexes. Fulltext/spatial+ // CREATE INDEX statements were checked by the pingcap-typed advisor and+ // remain checked here. The mysql omni rule additionally excludes Fulltext+ // and Spatial; aligning tidb with mysql on that is a separate behavior+ // change, deferred from this AST migration.+ if n.Unique {+ return nil}-- return regexp.Compile(template)+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ columnList := omniIndexColumns(n.Columns)+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ return []*indexMetaData{{+ indexName: n.IndexName,+ tableName: tableName,+ metaData: metaData,+ line: ostmt.FirstTokenLine(),+ }}}diff --git a/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.goindex 16d647acb7..fb3944ff56 100644--- a/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.go+++ b/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.go@@ -2,14 +2,10 @@ package tidbimport ("context"- "fmt""strings"- "github.com/pkg/errors"+ "github.com/bytebase/omni/tidb/ast"- "github.com/pingcap/tidb/pkg/parser/ast"-- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"@@ -18,7 +14,6 @@ import (var (_ advisor.Advisor = (*NamingUKConventionAdvisor)(nil)- _ ast.Visitor = (*namingUKConventionChecker)(nil))func init() {@@ -29,199 +24,142 @@ func init() {type NamingUKConventionAdvisor struct {}-// Check checks for index naming convention.+// Check checks for unique key naming convention.func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- root, err := getTiDBNodes(checkCtx)-- if err != nil {- return nil, err- }-- level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)- if err != nil {- return nil, err- }-- namingPayload := checkCtx.Rule.GetNamingPayload()- if namingPayload == nil {- return nil, errors.New("naming_payload is required for this rule")- }-- format := namingPayload.Format- templateList, _ := advisor.ParseTemplateTokens(format)-- for _, key := range templateList {- if _, ok := advisor.TemplateNamingTokens[checkCtx.Rule.Type][key]; !ok {- return nil, errors.Errorf("invalid template %s for rule %s", key, checkCtx.Rule.Type)+ // Capture originalMetadata in a local so the collector closure can read+ // it without runNamingConventionRule needing advisor.Context in its+ // callback signature — the FK rule doesn't need metadata, so keeping+ // the helper signature uniform is cleaner than threading a Context arg.+ originalMetadata := checkCtx.OriginalMetadata+ return runNamingConventionRule(checkCtx, namingRuleConfig{+ mismatchCode: code.NamingUKConventionMismatch,+ typeNoun: "Unique key",+ internalErrorTitle: "Internal error for unique key naming convention rule",+ }, func(ostmt OmniStmt) []*indexMetaData {+ switch n := ostmt.Node.(type) {+ case *ast.CreateTableStmt:+ return collectUKCreateTable(ostmt, n)+ case *ast.AlterTableStmt:+ return collectUKAlterTable(ostmt, n, originalMetadata)+ case *ast.CreateIndexStmt:+ return collectUKCreateIndex(ostmt, n)}- }-- maxLength := int(namingPayload.MaxLength)- if maxLength == 0 {- maxLength = advisor.DefaultNameLengthLimit- }- checker := &namingUKConventionChecker{- level: level,- title: checkCtx.Rule.Type.String(),- format: format,- maxLength: maxLength,- templateList: templateList,- originalMetadata: checkCtx.OriginalMetadata,- }- for _, stmtNode := range root {- (stmtNode).Accept(checker)- }-- return checker.adviceList, nil+ return nil+ })}-type namingUKConventionChecker struct {- adviceList []*storepb.Advice- level storepb.Advice_Status- title string- format string- maxLength int- templateList []string- originalMetadata *model.DatabaseMetadata-}--// Enter implements the ast.Visitor interface.-func (checker *namingUKConventionChecker) Enter(in ast.Node) (ast.Node, bool) {- indexDataList := checker.getMetaDataList(in)-- for _, indexData := range indexDataList {- regex, err := getTemplateRegexp(checker.format, checker.templateList, indexData.metaData)- if err != nil {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.Internal.Int32(),- Title: "Internal error for unique key naming convention rule",- Content: fmt.Sprintf("%q meet internal error %q", in.Text(), err.Error()),- })+// Pingcap had three distinct constraint enums (ConstraintUniq /+// ConstraintUniqKey / ConstraintUniqIndex) for the syntactic forms+// `UNIQUE`, `UNIQUE KEY`, and `UNIQUE INDEX`. Omni unifies all three under+// `ast.ConstrUnique`. The single switch arm here covers all three forms.+// Per Phase 1.5 cumulative shape-divergence table item #2.+func collectUKCreateTable(ostmt OmniStmt, n *ast.CreateTableStmt) []*indexMetaData {+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ var res []*indexMetaData+ for _, constraint := range n.Constraints {+ if constraint == nil || constraint.Type != ast.ConstrUnique {continue}- if !regex.MatchString(indexData.indexName) {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.NamingUKConventionMismatch.Int32(),- Title: checker.title,- Content: fmt.Sprintf("Unique key in table `%s` mismatches the naming convention, expect %q but found `%s`", indexData.tableName, regex, indexData.indexName),- StartPosition: common.ConvertANTLRLineToPosition(indexData.line),- })+ columnList := constraint.Columns+ if len(columnList) == 0 {+ columnList = omniIndexColumns(constraint.IndexColumns)}- if checker.maxLength > 0 && len(indexData.indexName) > checker.maxLength {- checker.adviceList = append(checker.adviceList, &storepb.Advice{- Status: checker.level,- Code: code.NamingUKConventionMismatch.Int32(),- Title: checker.title,- Content: fmt.Sprintf("Unique key `%s` in table `%s` mismatches the naming convention, its length should be within %d characters", indexData.indexName, indexData.tableName, checker.maxLength),- StartPosition: common.ConvertANTLRLineToPosition(indexData.line),- })+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,}+ res = append(res, &indexMetaData{+ indexName: constraint.Name,+ tableName: tableName,+ metaData: metaData,+ line: ostmt.AbsoluteLine(constraint.Loc.Start),+ })}-- return in, false-}--// Leave implements the ast.Visitor interface.-func (*namingUKConventionChecker) Leave(in ast.Node) (ast.Node, bool) {- return in, true+ return res}-// getMetaDataList returns the list of unique key with meta data.-func (checker *namingUKConventionChecker) getMetaDataList(in ast.Node) []*indexMetaData {+func collectUKAlterTable(ostmt OmniStmt, n *ast.AlterTableStmt, originalMetadata *model.DatabaseMetadata) []*indexMetaData {+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ stmtLine := ostmt.FirstTokenLine()var res []*indexMetaData-- switch node := in.(type) {- case *ast.CreateTableStmt:- for _, constraint := range node.Constraints {- switch constraint.Tp {- case ast.ConstraintUniq, ast.ConstraintUniqKey, ast.ConstraintUniqIndex:- var columnList []string- for _, key := range constraint.Keys {- columnList = append(columnList, key.Column.Name.String())- }- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),- }- res = append(res, &indexMetaData{- indexName: constraint.Name,- tableName: node.Table.Name.String(),- metaData: metaData,- line: constraint.OriginTextPosition(),- })- default:- }+ for _, cmd := range n.Commands {+ if cmd == nil {+ continue}- case *ast.AlterTableStmt:- for _, spec := range node.Specs {- switch spec.Tp {- case ast.AlterTableRenameIndex:- schema := checker.originalMetadata.GetSchemaMetadata("")- var index *model.IndexMetadata- if schema != nil {- index = schema.GetIndex(spec.FromKey.String())- }- if index == nil {- continue- }- if !index.GetProto().GetUnique() {- // Index naming convention should in advisor_naming_index_convention.go- continue- }- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),- }- res = append(res, &indexMetaData{- indexName: spec.ToKey.String(),- tableName: node.Table.Name.String(),- metaData: metaData,- line: in.OriginTextPosition(),- })- case ast.AlterTableAddConstraint:- switch spec.Constraint.Tp {- case ast.ConstraintUniq, ast.ConstraintUniqKey, ast.ConstraintUniqIndex:- var columnList []string- for _, key := range spec.Constraint.Keys {- columnList = append(columnList, key.Column.Name.String())- }-- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),- }- res = append(res, &indexMetaData{- indexName: spec.Constraint.Name,- tableName: node.Table.Name.String(),- metaData: metaData,- line: in.OriginTextPosition(),- })- default:- }- default:+ switch cmd.Type {+ // Mirror mysql omni: ATAddIndex covers `ALTER TABLE ... ADD UNIQUE+ // INDEX uk (col)`, ATAddConstraint covers `ADD CONSTRAINT uk UNIQUE`.+ case ast.ATAddConstraint, ast.ATAddIndex:+ if cmd.Constraint == nil || cmd.Constraint.Type != ast.ConstrUnique {+ continue}- }- case *ast.CreateIndexStmt:- if node.KeyType == ast.IndexKeyTypeUnique {- var columnList []string- for _, spec := range node.IndexPartSpecifications {- columnList = append(columnList, spec.Column.Name.String())+ columnList := cmd.Constraint.Columns+ if len(columnList) == 0 {+ columnList = omniIndexColumns(cmd.Constraint.IndexColumns)}metaData := map[string]string{advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: node.Table.Name.String(),+ advisor.TableNameTemplateToken: tableName,}res = append(res, &indexMetaData{- indexName: node.IndexName,- tableName: node.Table.Name.String(),+ indexName: cmd.Constraint.Name,+ tableName: tableName,metaData: metaData,- line: in.OriginTextPosition(),+ line: stmtLine,})+ case ast.ATRenameIndex:+ schema := originalMetadata.GetSchemaMetadata("")+ if schema == nil {+ continue+ }+ index := schema.GetIndex(cmd.Name)+ if index == nil {+ continue+ }+ if !index.GetProto().GetUnique() {+ // Non-unique index naming convention is handled by+ // advisor_naming_index_convention.go.+ continue+ }+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ res = append(res, &indexMetaData{+ indexName: cmd.NewName,+ tableName: tableName,+ metaData: metaData,+ line: stmtLine,+ })+ default:}- default:}-return res}++func collectUKCreateIndex(ostmt OmniStmt, n *ast.CreateIndexStmt) []*indexMetaData {+ if !n.Unique {+ return nil+ }+ if n.Table == nil {+ return nil+ }+ tableName := n.Table.Name+ columnList := omniIndexColumns(n.Columns)+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ return []*indexMetaData{{+ indexName: n.IndexName,+ tableName: tableName,+ metaData: metaData,+ line: ostmt.FirstTokenLine(),+ }}+}diff --git a/backend/plugin/advisor/tidb/test/naming_index_idx.yaml b/backend/plugin/advisor/tidb/test/naming_index_idx.yamlindex 05e6b6ef71..8df16a004b 100644--- a/backend/plugin/advisor/tidb/test/naming_index_idx.yaml+++ b/backend/plugin/advisor/tidb/test/naming_index_idx.yaml@@ -60,3 +60,21 @@changeType: 1- statement: CREATE TABLE tech_book_copy(id INT PRIMARY KEY, name VARCHAR(20), INDEX (name))changeType: 1+# Pins omni's ATAddConstraint vs ATAddIndex split: pingcap collapsed both+# `ADD INDEX` (above) and `ADD CONSTRAINT name INDEX` (below) into+# AlterTableAddConstraint, but omni preserves the syntactic distinction.+# The advisor's switch covers both arms — these cases prove the+# ATAddConstraint+ConstrIndex path is exercised, not just ATAddIndex.+- statement: ALTER TABLE tech_book ADD CONSTRAINT idx_tech_book_id_name INDEX (id, name)+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT bad_idx INDEX (id, name)+ changeType: 1+ want:+ - status: 2+ code: 303+ title: NAMING_INDEX_IDX+ content: Index in table `tech_book` mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found `bad_idx`+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/tidb/test/naming_index_uk.yaml b/backend/plugin/advisor/tidb/test/naming_index_uk.yamlindex b755170fcf..13a7900886 100644--- a/backend/plugin/advisor/tidb/test/naming_index_uk.yaml+++ b/backend/plugin/advisor/tidb/test/naming_index_uk.yaml@@ -62,3 +62,36 @@changeType: 1- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20), UNIQUE INDEX (name))changeType: 1+# Pins omni's ATAddConstraint vs ATAddIndex split + ConstrUnique+# unification. Pingcap had three distinct constraint enums for the+# UNIQUE/UNIQUE KEY/UNIQUE INDEX syntactic forms; omni unifies them under+# ConstrUnique. The existing `ALTER TABLE ... ADD UNIQUE name` cases+# above hit the bare-UNIQUE form; these pin the UNIQUE INDEX and UNIQUE+# KEY variants, which omni routes through ATAddIndex (not+# ATAddConstraint).+- statement: ALTER TABLE tech_book ADD UNIQUE INDEX uk_tech_book_id_name (id, name)+ changeType: 1+- statement: ALTER TABLE tech_book ADD UNIQUE INDEX bad_uk (id, name)+ changeType: 1+ want:+ - status: 2+ code: 304+ title: NAMING_INDEX_UK+ content: Unique key in table `tech_book` mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found `bad_uk`+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book ADD UNIQUE KEY uk_tech_book_id_name (id, name)+ changeType: 1+- statement: ALTER TABLE tech_book ADD UNIQUE KEY bad_uk (id, name)+ changeType: 1+ want:+ - status: 2+ code: 304+ title: NAMING_INDEX_UK+ content: Unique key in table `tech_book` mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found `bad_uk`+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/tidb/utils.go b/backend/plugin/advisor/tidb/utils.goindex 9c8af7bc10..cf4cda32fa 100644--- a/backend/plugin/advisor/tidb/utils.go+++ b/backend/plugin/advisor/tidb/utils.go@@ -2,7 +2,9 @@package tidbimport (+ "fmt""log/slog"+ "regexp""slices""strings""unicode"@@ -15,7 +17,10 @@ import (omniast "github.com/bytebase/omni/tidb/ast"+ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"tidbparser "github.com/bytebase/bytebase/backend/plugin/parser/tidb")@@ -248,3 +253,143 @@ func getTiDBOmniNodes(checkCtx advisor.Context) ([]OmniStmt, error) {checkCtx.SetMemo(omniStmtsCacheKey, result)return result, nil}++// indexMetaData captures naming metadata used by the index/UK/FK convention+// rules. Plain Go fields, AST-agnostic — shared between all 3 advisors that+// were previously coupled via this struct in advisor_naming_index_convention.go.+type indexMetaData struct {+ indexName string+ tableName string+ metaData map[string]string+ line int+}++// getTemplateRegexp formats the template as regex by substituting tokens.+// Shared by the index/UK/FK naming convention rules.+func getTemplateRegexp(template string, templateList []string, tokens map[string]string) (*regexp.Regexp, error) {+ for _, key := range templateList {+ if token, ok := tokens[key]; ok {+ template = strings.ReplaceAll(template, key, token)+ }+ }+ return regexp.Compile(template)+}++// omniIndexColumns extracts column names from an omni IndexColumn list.+// Expression-based parts that are not bare column refs are silently+// skipped — e.g., functional indexes like `INDEX idx ((LOWER(name)))`+// contribute no name to the column-list substitution. This matches the+// mysql omni analog and the pingcap-typed naming rules' historical+// "name-only" behavior; any future rule that needs to inspect index+// expressions should not route through this helper.+func omniIndexColumns(cols []*omniast.IndexColumn) []string {+ if len(cols) == 0 {+ return nil+ }+ var names []string+ for _, col := range cols {+ if col == nil {+ continue+ }+ if ref, ok := col.Expr.(*omniast.ColumnRef); ok {+ names = append(names, ref.Column)+ }+ }+ return names+}++// namingRuleConfig parameterizes the naming-convention rule scaffold for the+// index, unique-key, and foreign-key advisors. Only the per-rule labels and+// the mismatch advice code differ — everything else (payload validation,+// regex match, length check, advice emission) is shared.+type namingRuleConfig struct {+ mismatchCode code.Code+ typeNoun string // "Index" / "Unique key" / "Foreign key" — embedded in advice content+ internalErrorTitle string+}++// runNamingConventionRule is the shared scaffold for the index/UK/FK naming+// rules. The collect closure returns []*indexMetaData, so all callers are+// coupled to that 4-field shape. If a future naming rule needs additional+// per-finding fields (e.g. an isUnique flag or a per-finding line distinct+// from the metadata's), expect either widening indexMetaData (everyone+// pays) or replacing the closure return type (breaks the helper). The+// current shape is the lowest common denominator across the 3 rules.+//+// Behavior: parses the naming payload, walks each statement through `collect`,+// and emits regex-mismatch + length-overflow advices.+//+// The advice content is byte-identical to the pre-extraction inline form+// (`"<noun> in table ..."` and `"<noun> `<name>` in table ..."`), so existing+// fixture coverage is the safety net for this refactor — no fixture updates+// needed.+//+// Mysql analogs left similar duplication inline (pre-Sonar-gate); we extract+// here because the trio is new code and Sonar gates duplication on new code.+// Future naming-rule migrations (naming_table, naming_column,+// naming_auto_increment_column) reuse this scaffold.+func runNamingConventionRule(+ checkCtx advisor.Context,+ cfg namingRuleConfig,+ collect func(OmniStmt) []*indexMetaData,+) ([]*storepb.Advice, error) {+ stmts, err := getTiDBOmniNodes(checkCtx)+ if err != nil {+ return nil, err+ }+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }+ namingPayload := checkCtx.Rule.GetNamingPayload()+ if namingPayload == nil {+ return nil, errors.New("naming_payload is required for this rule")+ }+ formatStr := namingPayload.Format+ templateList, _ := advisor.ParseTemplateTokens(formatStr)+ for _, key := range templateList {+ if _, ok := advisor.TemplateNamingTokens[checkCtx.Rule.Type][key]; !ok {+ return nil, errors.Errorf("invalid template %s for rule %s", key, checkCtx.Rule.Type)+ }+ }+ maxLength := int(namingPayload.MaxLength)+ if maxLength == 0 {+ maxLength = advisor.DefaultNameLengthLimit+ }+ title := checkCtx.Rule.Type.String()++ var adviceList []*storepb.Advice+ for _, ostmt := range stmts {+ for _, indexData := range collect(ostmt) {+ regex, err := getTemplateRegexp(formatStr, templateList, indexData.metaData)+ if err != nil {+ adviceList = append(adviceList, &storepb.Advice{+ Status: level,+ Code: code.Internal.Int32(),+ Title: cfg.internalErrorTitle,+ Content: fmt.Sprintf("%q meet internal error %q", ostmt.TrimmedText(), err.Error()),+ })+ continue+ }+ if !regex.MatchString(indexData.indexName) {+ adviceList = append(adviceList, &storepb.Advice{+ Status: level,+ Code: cfg.mismatchCode.Int32(),+ Title: title,+ Content: fmt.Sprintf("%s in table `%s` mismatches the naming convention, expect %q but found `%s`", cfg.typeNoun, indexData.tableName, regex, indexData.indexName),+ StartPosition: common.ConvertANTLRLineToPosition(indexData.line),+ })+ }+ if maxLength > 0 && len(indexData.indexName) > maxLength {+ adviceList = append(adviceList, &storepb.Advice{+ Status: level,+ Code: cfg.mismatchCode.Int32(),+ Title: title,+ Content: fmt.Sprintf("%s `%s` in table `%s` mismatches the naming convention, its length should be within %d characters", cfg.typeNoun, indexData.indexName, indexData.tableName, maxLength),+ StartPosition: common.ConvertANTLRLineToPosition(indexData.line),+ })+ }+ }+ }+ return adviceList, nil+}diff --git a/backend/plugin/advisor/tidb/utils_test.go b/backend/plugin/advisor/tidb/utils_test.goindex 326f923c18..701358d587 100644--- a/backend/plugin/advisor/tidb/utils_test.go+++ b/backend/plugin/advisor/tidb/utils_test.go@@ -5,8 +5,11 @@ import ("github.com/stretchr/testify/require"+ omniast "github.com/bytebase/omni/tidb/ast"+storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/bytebase/bytebase/backend/plugin/parser/base"tidbparser "github.com/bytebase/bytebase/backend/plugin/parser/tidb")@@ -133,3 +136,113 @@ func TestGetTiDBNodesSoftFailsOnBridgeMiss(t *testing.T) {require.Len(t, got, 1,"expected 1 statement from the bridge-hit branch; the bridge-miss statement should be skipped silently")}++// TestCollectFKCreateTableNilConstraintGuard pins the defensive nil-check+// in collectFKCreateTable. The original batch-4 form passed+// `ostmt.AbsoluteLine(constraint.Loc.Start)` as the line argument to+// buildFKMetaData, which evaluated the dereference BEFORE the helper's+// internal nil check could fire — a nil entry in n.Constraints would+// panic. Per Codex round-1 review on PR #20204; sibling collectFKAlterTable+// was safe because it precomputes stmtLine outside the loop, and+// collectIndexCreateTable / collectUKCreateTable already nil-checked.+//+// Omni's parser doesn't currently produce nil entries from valid SQL, so+// the YAML fixture suite can't reach this branch. The synthetic AST here+// pins the contract: a future change that re-orders the loop body or+// removes the guard fails here.+func TestCollectFKCreateTableNilConstraintGuard(t *testing.T) {+ stmt := &omniast.CreateTableStmt{+ Table: &omniast.TableRef{Name: "t"},+ Constraints: []*omniast.Constraint{+ nil, // would panic on AbsoluteLine(constraint.Loc.Start) without the guard+ {+ Type: omniast.ConstrForeignKey,+ Name: "fk_t_author_id_author_id",+ Columns: []string{"author_id"},+ RefTable: &omniast.TableRef{Name: "author"},+ RefColumns: []string{"id"},+ },+ },+ }+ ostmt := OmniStmt{+ Node: stmt,+ Text: "CREATE TABLE t (author_id INT, FOREIGN KEY (author_id) REFERENCES author(id))",+ BaseLine: 0,+ }++ require.NotPanics(t, func() {+ result := collectFKCreateTable(ostmt, stmt)+ // The non-nil FK constraint must still be collected — the nil guard+ // is `continue`, not an early exit.+ require.Len(t, result, 1, "non-nil FK constraint should still be collected after the nil guard skips the nil entry")+ require.Equal(t, "fk_t_author_id_author_id", result[0].indexName)+ })+}++// TestRunNamingConventionRuleEmitsInternalErrorAdvice pins the+// internal-error advice path in the runNamingConventionRule helper —+// the path that fires when getTemplateRegexp's regexp.Compile fails on+// the post-substitution template. The YAML fixture suite can't reach+// this branch because every fixture uses a valid template; without this+// test, an accidental swap of cfg.internalErrorTitle vs cfg.typeNoun+// (or a regression in the advice's Status/Code/Content shape) would go+// unnoticed.+//+// The test feeds a Format containing an unbalanced paren — no template+// tokens (so payload-token validation passes), but regexp.Compile fails+// after the no-op substitution.+func TestRunNamingConventionRuleEmitsInternalErrorAdvice(t *testing.T) {+ ctx := advisor.Context{+ Rule: &storepb.SQLReviewRule{+ Type: storepb.SQLReviewRule_NAMING_INDEX_IDX,+ Level: storepb.SQLReviewRule_WARNING,+ Payload: &storepb.SQLReviewRule_NamingPayload{+ NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{+ Format: "(unbalanced", // valid (no tokens) but fails regexp.Compile+ MaxLength: 64,+ },+ },+ },+ ParsedStatements: []base.ParsedStatement{+ {+ Statement: base.Statement{+ Text: "CREATE INDEX idx_x ON t (a)",+ Start: &storepb.Position{Line: 1},+ },+ },+ },+ }+ ctx.InitMemo()++ advices, err := runNamingConventionRule(ctx, namingRuleConfig{+ mismatchCode: code.NamingIndexConventionMismatch,+ typeNoun: "Index",+ internalErrorTitle: "Internal error for index naming convention rule",+ }, func(ostmt OmniStmt) []*indexMetaData {+ // Synthetic collector: surface one indexMetaData per parsed+ // statement so the helper proceeds to regex compilation.+ n, ok := ostmt.Node.(*omniast.CreateIndexStmt)+ if !ok || n.Table == nil {+ return nil+ }+ return []*indexMetaData{{+ indexName: n.IndexName,+ tableName: n.Table.Name,+ metaData: map[string]string{+ advisor.ColumnListTemplateToken: "a",+ advisor.TableNameTemplateToken: n.Table.Name,+ },+ line: ostmt.FirstTokenLine(),+ }}+ })++ require.NoError(t, err, "regex-compile failure must surface as a per-finding internal-error advice, not a rule-level error")+ require.Len(t, advices, 1, "expected exactly 1 internal-error advice")+ require.Equal(t, "Internal error for index naming convention rule", advices[0].Title,+ "Title must come from cfg.internalErrorTitle, not cfg.typeNoun or the rule.Type string")+ require.Equal(t, code.Internal.Int32(), advices[0].Code,+ "internal-error advices must use code.Internal, not the per-rule mismatch code")+ require.Equal(t, storepb.Advice_WARNING, advices[0].Status)+ require.Contains(t, advices[0].Content, "meet internal error",+ "content shape preserved from pre-extraction inline form")+}