Skip to content

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

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.go
index 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 tidb
import (
"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.go
index 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 tidb
import (
"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.go
index 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 tidb
import (
"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.yaml
index 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: null
diff --git a/backend/plugin/advisor/tidb/test/naming_index_uk.yaml b/backend/plugin/advisor/tidb/test/naming_index_uk.yaml
index 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: null
diff --git a/backend/plugin/advisor/tidb/utils.go b/backend/plugin/advisor/tidb/utils.go
index 9c8af7bc10..cf4cda32fa 100644
--- a/backend/plugin/advisor/tidb/utils.go
+++ b/backend/plugin/advisor/tidb/utils.go
@@ -2,7 +2,9 @@
package tidb
import (
+ "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.go
index 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")
+}