Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(advisor/pg): migrate PostgreSQL SQL review from ANTLR to omni AST (#19671)
h3n4l5fe13502a667
diff --git a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.goindex 50d2429e21..7a2851b3a8 100644--- a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go@@ -3,20 +3,15 @@ package pgimport ("context""fmt"- "log/slog"- "github.com/antlr4-go/antlr/v4"- "github.com/pkg/errors"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast""github.com/bytebase/bytebase/backend/common"- "github.com/bytebase/bytebase/backend/common/log"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"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")const (@@ -54,22 +49,25 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisorif stmt.AST == nil {continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)+ node, ok := pgparser.GetOmniNode(stmt.AST)if !ok {continue}- rule := &ddlRule{- BaseRule: BaseRule{- level: level,- title: title,- },- tokens: antlrAST.Tokens,+ baseLine := stmt.BaseLine()+ if omniIsDDLStatement(node) {+ stmtText := omniTrimmedStmtText(stmt.Text)+ startLine := omniContentStartLine(stmt.Text)+ adviceList = append(adviceList, &storepb.Advice{+ Status: level,+ Title: title,+ Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", stmtText),+ Code: code.BuiltinPriorBackupCheck.Int32(),+ StartPosition: &storepb.Position{+ Line: int32(baseLine) + startLine,+ Column: 0,+ },+ })}- rule.SetBaseLine(stmt.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)}// Check if backup schema exists@@ -116,147 +114,99 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisorreturn adviceList, nil}-// isDDLStatement checks if a context is a DDL statement-func isDDLStatement(ctx antlr.Tree) bool {- switch ctx.(type) {+// omniIsDDLStatement checks if a node is a DDL statement.+func omniIsDDLStatement(node ast.Node) bool {+ switch node.(type) {// CREATE statements- case *parser.CreatestmtContext,- *parser.CreateasstmtContext,- *parser.CreateassertionstmtContext,- *parser.CreatecaststmtContext,- *parser.CreateconversionstmtContext,- *parser.CreatedomainstmtContext,- *parser.CreateextensionstmtContext,- *parser.CreatefdwstmtContext,- *parser.CreateforeignserverstmtContext,- *parser.CreateforeigntablestmtContext,- *parser.CreatefunctionstmtContext,- *parser.CreategroupstmtContext,- *parser.CreatematviewstmtContext,- *parser.CreateopclassstmtContext,- *parser.CreateopfamilystmtContext,- *parser.CreatepublicationstmtContext,- *parser.CreatepolicystmtContext,- *parser.CreateplangstmtContext,- *parser.CreateschemastmtContext,- *parser.CreateseqstmtContext,- *parser.CreatesubscriptionstmtContext,- *parser.CreatestatsstmtContext,- *parser.CreatetablespacestmtContext,- *parser.CreatetransformstmtContext,- *parser.CreatetrigstmtContext,- *parser.CreateeventtrigstmtContext,- *parser.CreaterolestmtContext,- *parser.CreateuserstmtContext,- *parser.CreateusermappingstmtContext,- *parser.CreatedbstmtContext,- *parser.CreateamstmtContext,- *parser.IndexstmtContext, // CREATE INDEX+ case *ast.CreateStmt,+ *ast.CreateTableAsStmt,+ *ast.CreateDomainStmt,+ *ast.CreateExtensionStmt,+ *ast.CreateFdwStmt,+ *ast.CreateForeignServerStmt,+ *ast.CreateForeignTableStmt,+ *ast.CreateFunctionStmt,+ *ast.CreateRoleStmt,+ *ast.CreatePolicyStmt,+ *ast.CreatePLangStmt,+ *ast.CreateSchemaStmt,+ *ast.CreateSeqStmt,+ *ast.CreateSubscriptionStmt,+ *ast.CreateStatsStmt,+ *ast.CreateTableSpaceStmt,+ *ast.CreateTransformStmt,+ *ast.CreateTrigStmt,+ *ast.CreateEventTrigStmt,+ *ast.CreateUserMappingStmt,+ *ast.CreatedbStmt,+ *ast.CreateAmStmt,+ *ast.CreatePublicationStmt,+ *ast.CreateOpClassStmt,+ *ast.CreateOpFamilyStmt,+ *ast.CreateCastStmt,+ *ast.CreateConversionStmt,+ *ast.CreateRangeStmt,+ *ast.CompositeTypeStmt,+ *ast.CreateEnumStmt,+ *ast.IndexStmt,+ *ast.ViewStmt,// ALTER statements- *parser.AltereventtrigstmtContext,- *parser.AltercollationstmtContext,- *parser.AlterdatabasestmtContext,- *parser.AlterdatabasesetstmtContext,- *parser.AlterdefaultprivilegesstmtContext,- *parser.AlterdomainstmtContext,- *parser.AlterenumstmtContext,- *parser.AlterextensionstmtContext,- *parser.AlterextensioncontentsstmtContext,- *parser.AlterfdwstmtContext,- *parser.AlterforeignserverstmtContext,- *parser.AlterfunctionstmtContext,- *parser.AltergroupstmtContext,- *parser.AlterobjectdependsstmtContext,- *parser.AlterobjectschemastmtContext,- *parser.AlterownerstmtContext,- *parser.AlteroperatorstmtContext,- *parser.AltertypestmtContext,- *parser.AlterpolicystmtContext,- *parser.AlterseqstmtContext,- *parser.AltersystemstmtContext,- *parser.AltertablestmtContext,- *parser.AltertblspcstmtContext,- *parser.AltercompositetypestmtContext,- *parser.AlterpublicationstmtContext,- *parser.AlterrolesetstmtContext,- *parser.AlterrolestmtContext,- *parser.AltersubscriptionstmtContext,- *parser.AlterstatsstmtContext,- *parser.AltertsconfigurationstmtContext,- *parser.AltertsdictionarystmtContext,- *parser.AlterusermappingstmtContext,- *parser.AlteropfamilystmtContext,+ *ast.AlterEventTrigStmt,+ *ast.AlterCollationStmt,+ *ast.AlterDatabaseStmt,+ *ast.AlterDatabaseSetStmt,+ *ast.AlterDefaultPrivilegesStmt,+ *ast.AlterDomainStmt,+ *ast.AlterEnumStmt,+ *ast.AlterExtensionStmt,+ *ast.AlterExtensionContentsStmt,+ *ast.AlterFdwStmt,+ *ast.AlterForeignServerStmt,+ *ast.AlterFunctionStmt,+ *ast.AlterObjectDependsStmt,+ *ast.AlterObjectSchemaStmt,+ *ast.AlterOwnerStmt,+ *ast.AlterOperatorStmt,+ *ast.AlterTypeStmt,+ *ast.AlterPolicyStmt,+ *ast.AlterSeqStmt,+ *ast.AlterSystemStmt,+ *ast.AlterTableStmt,+ *ast.AlterTableSpaceOptionsStmt,+ *ast.AlterPublicationStmt,+ *ast.AlterRoleSetStmt,+ *ast.AlterRoleStmt,+ *ast.AlterSubscriptionStmt,+ *ast.AlterStatsStmt,+ *ast.AlterTSConfigurationStmt,+ *ast.AlterTSDictionaryStmt,+ *ast.AlterUserMappingStmt,+ *ast.AlterOpFamilyStmt,// DROP statements- *parser.DropstmtContext,- *parser.DropcaststmtContext,- *parser.DropopclassstmtContext,- *parser.DropopfamilystmtContext,- *parser.DropownedstmtContext,- *parser.DropsubscriptionstmtContext,- *parser.DroptablespacestmtContext,- *parser.DroptransformstmtContext,- *parser.DroprolestmtContext,- *parser.DropusermappingstmtContext,- *parser.DropdbstmtContext,+ *ast.DropStmt,+ *ast.DropOwnedStmt,+ *ast.DropSubscriptionStmt,+ *ast.DropTableSpaceStmt,+ *ast.DropRoleStmt,+ *ast.DropUserMappingStmt,+ *ast.DropdbStmt,// Other DDL statements- *parser.TruncatestmtContext,- *parser.RenamestmtContext,- *parser.CommentstmtContext,- *parser.DefinestmtContext,- *parser.RemoveaggrstmtContext,- *parser.RemovefuncstmtContext,- *parser.RemoveoperstmtContext,- *parser.ReindexstmtContext,- *parser.ClusterstmtContext,- *parser.RefreshmatviewstmtContext,- *parser.RulestmtContext,- *parser.SeclabelstmtContext,- *parser.ReassignownedstmtContext:+ *ast.TruncateStmt,+ *ast.RenameStmt,+ *ast.CommentStmt,+ *ast.DefineStmt,+ *ast.ReindexStmt,+ *ast.ClusterStmt,+ *ast.RefreshMatViewStmt,+ *ast.RuleStmt,+ *ast.SecLabelStmt,+ *ast.ReassignOwnedStmt:return truedefault:return false}}-// ddlRule checks for DDL statements in DML context-type ddlRule struct {- BaseRule- tokens *antlr.CommonTokenStream-}--func (*ddlRule) Name() string {- return "ddl-in-dml-check"-}--func (r *ddlRule) OnEnter(ctx antlr.ParserRuleContext, _ string) error {- return r.handleEveryRule(ctx)-}--func (*ddlRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *ddlRule) handleEveryRule(ctx antlr.ParserRuleContext) error {- // Check if this is a top-level DDL statement- if !isTopLevel(ctx.GetParent()) {- return nil- }-- if isDDLStatement(ctx) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Title: r.title,- Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", getTextFromTokens(r.tokens, ctx)),- Code: code.BuiltinPriorBackupCheck.Int32(),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- }- return nil-}-// StatementType represents the type of DML statementtype StatementType int@@ -278,101 +228,107 @@ type TableReference struct {type statementInfo struct {offset intstatement string- tree antlr.ParserRuleContexttable *TableReference}func prepareTransformation(parsedStatements []base.ParsedStatement) []statementInfo {- extractor := &dmlExtractor{}+ var dmls []statementInfo+ offset := 0for _, stmt := range parsedStatements {if stmt.AST == nil {+ offset++continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)+ node, ok := pgparser.GetOmniNode(stmt.AST)if !ok {+ offset++continue}- antlr.ParseTreeWalkerDefault.Walk(extractor, antlrAST.Tree)- }- return extractor.dmls-}--type dmlExtractor struct {- *parser.BasePostgreSQLParserListener-- dmls []statementInfo- offset int-}--func (e *dmlExtractor) ExitStmt(ctx *parser.StmtContext) {- if isTopLevel(ctx) {- e.offset++- }-}-func (e *dmlExtractor) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {- if isTopLevel(ctx.GetParent()) {- table := extractTableReference(ctx.Relation_expr_opt_alias())- if table == nil {- return+ switch n := node.(type) {+ case *ast.UpdateStmt:+ table := omniExtractTableReferenceFromRangeVar(n.Relation)+ if table != nil {+ table.StatementType = StatementTypeUpdate+ dmls = append(dmls, statementInfo{+ offset: offset,+ statement: stmt.Text,+ table: table,+ })+ }+ case *ast.DeleteStmt:+ // DeleteStmt uses UsingClause for FROM but Relation for the target table+ table := omniExtractTableReferenceFromRangeVar(n.Relation)+ if table != nil {+ table.StatementType = StatementTypeDelete+ dmls = append(dmls, statementInfo{+ offset: offset,+ statement: stmt.Text,+ table: table,+ })+ }+ default:}- table.StatementType = StatementTypeUpdate- e.dmls = append(e.dmls, statementInfo{- offset: e.offset,- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),- tree: ctx,- table: table,- })- }-}-func (e *dmlExtractor) EnterDeletestmt(ctx *parser.DeletestmtContext) {- if isTopLevel(ctx.GetParent()) {- table := extractTableReference(ctx.Relation_expr_opt_alias())- if table == nil {- return- }- table.StatementType = StatementTypeDelete- e.dmls = append(e.dmls, statementInfo{- offset: e.offset,- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),- tree: ctx,- table: table,- })+ offset++}+ return dmls}-func extractTableReference(ctx parser.IRelation_expr_opt_aliasContext) *TableReference {- if ctx == nil {+func omniExtractTableReferenceFromRangeVar(rv *ast.RangeVar) *TableReference {+ if rv == nil {return nil}table := TableReference{}+ if rv.Catalogname != "" {+ table.Database = rv.Catalogname+ }+ if rv.Schemaname != "" {+ table.Schema = rv.Schemaname+ } else {+ table.Schema = defaultSchema+ }+ table.Table = rv.Relname+ if rv.Alias != nil {+ table.Alias = rv.Alias.Aliasname+ }- relationExpr := ctx.Relation_expr()- if relationExpr == nil {+ if table.Table == "" {return nil}+ return &table+}- list := pg.NormalizePostgreSQLQualifiedName(relationExpr.Qualified_name())- switch len(list) {- case 3:- table.Database = list[0]- table.Schema = list[1]- table.Table = list[2]- case 2:- table.Schema = list[0]- table.Table = list[1]- case 1:- table.Schema = defaultSchema- table.Table = list[0]- default:- slog.Debug("Invalid table name", log.BBError(errors.Errorf("Invalid table name: %v", list)))- return nil+// omniTrimmedStmtText returns the statement text with leading/trailing whitespace+// and trailing semicolons removed.+func omniTrimmedStmtText(text string) string {+ result := text+ // Trim leading/trailing whitespace+ for len(result) > 0 && (result[0] == ' ' || result[0] == '\t' || result[0] == '\n' || result[0] == '\r') {+ result = result[1:]+ }+ for len(result) > 0 {+ last := result[len(result)-1]+ if last == ' ' || last == '\t' || last == '\n' || last == '\r' || last == ';' {+ result = result[:len(result)-1]+ } else {+ break+ }}+ return result+}- if ctx.Colid() != nil {- table.Alias = pg.NormalizePostgreSQLColid(ctx.Colid())+// omniContentStartLine returns the 1-based line number of the first non-whitespace+// character in the text.+func omniContentStartLine(text string) int32 {+ line := int32(1)+ for _, c := range text {+ if c == '\n' {+ line+++ } else if c != ' ' && c != '\t' && c != '\r' {+ break+ }}- return &table+ return line}diff --git a/backend/plugin/advisor/pg/advisor_collation_allowlist.go b/backend/plugin/advisor/pg/advisor_collation_allowlist.goindex 1f1f7715aa..8f629e03ea 100644--- a/backend/plugin/advisor/pg/advisor_collation_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_collation_allowlist.go@@ -3,15 +3,13 @@ package pgimport ("context""fmt"+ "strings"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -40,169 +38,94 @@ func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Cont}rule := &collationAllowlistRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},allowlist: allowlist,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- rule.tokens = antlrAST.Tokens- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type collationAllowlistRule struct {- BaseRule+ OmniBaseRuleallowlist map[string]bool- tokens *antlr.CommonTokenStream}func (*collationAllowlistRule) Name() string {return "collation-allowlist"}-func (r *collationAllowlistRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- return r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- return r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))+func (r *collationAllowlistRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*collationAllowlistRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-// handleCreatestmt handles CREATE TABLE statements-func (r *collationAllowlistRule) handleCreatestmt(ctx *parser.CreatestmtContext) error {- if !isTopLevel(ctx.GetParent()) {- return nil- }-- // Extract collations from column definitions- if ctx.Opttableelementlist() != nil {- r.checkTableElementList(ctx.Opttableelementlist(), ctx)+func (r *collationAllowlistRule) handleCreateStmt(n *ast.CreateStmt) {+ cols, _ := omniTableElements(n)+ for _, col := range cols {+ r.checkColumnCollation(col)}- return nil}-// handleAltertablestmt handles ALTER TABLE statements-func (r *collationAllowlistRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) error {- if !isTopLevel(ctx.GetParent()) {- return nil- }-- // Check ALTER TABLE ADD COLUMN- if ctx.Alter_table_cmds() != nil {- r.checkAlterTableCmds(ctx.Alter_table_cmds(), ctx)- }- return nil-}--func (r *collationAllowlistRule) checkTableElementList(listCtx parser.IOpttableelementlistContext, stmtCtx antlr.ParserRuleContext) {- if listCtx == nil || listCtx.Tableelementlist() == nil {- return- }-- allElements := listCtx.Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.ColumnDef() != nil {- r.checkColumnDef(elem.ColumnDef(), stmtCtx)- }- }-}--func (r *collationAllowlistRule) checkColumnDef(colDef parser.IColumnDefContext, stmtCtx antlr.ParserRuleContext) {- if colDef == nil || colDef.Colquallist() == nil {- return- }-- // Check column constraints for COLLATE clause- // colquallist -> colconstraint* -> COLLATE any_name- allConstraints := colDef.Colquallist().AllColconstraint()- for _, constraint := range allConstraints {- // Check if this constraint is a COLLATE constraint- if constraint.COLLATE() != nil && constraint.Any_name() != nil {- collName := r.extractCollationNameFromAnyName(constraint.Any_name())- if collName != "" && !r.allowlist[collName] {- r.addAdvice(collName, stmtCtx)+func (r *collationAllowlistRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ for _, cmd := range omniAlterTableCmds(n) {+ switch ast.AlterTableType(cmd.Subtype) {+ case ast.AT_AddColumn:+ if colDef, ok := cmd.Def.(*ast.ColumnDef); ok {+ r.checkColumnCollation(colDef)+ }+ case ast.AT_AlterColumnType:+ if colDef, ok := cmd.Def.(*ast.ColumnDef); ok {+ r.checkColumnCollation(colDef)}+ default:}}}-func (r *collationAllowlistRule) checkAlterTableCmds(cmds parser.IAlter_table_cmdsContext, stmtCtx antlr.ParserRuleContext) {- if cmds == nil {+func (r *collationAllowlistRule) checkColumnCollation(col *ast.ColumnDef) {+ if col == nil || col.CollClause == nil {return}-- allCmds := cmds.AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- r.checkColumnDef(cmd.ColumnDef(), stmtCtx)- }-- // ALTER COLUMN TYPE with COLLATE- // Check if this is ALTER COLUMN ... TYPE ...- // Grammar: ALTER opt_column? colid opt_set_data? TYPE_P typename opt_collate_clause? alter_using?- if cmd.ALTER() != nil && cmd.TYPE_P() != nil && cmd.Opt_collate_clause() != nil && cmd.Opt_collate_clause().Any_name() != nil {- collName := r.extractCollationNameFromAnyName(cmd.Opt_collate_clause().Any_name())- if collName != "" && !r.allowlist[collName] {- r.addAdvice(collName, stmtCtx)- }- }+ collName := r.extractCollationName(col.CollClause)+ if collName != "" && !r.allowlist[collName] {+ r.addCollationAdvice(collName)}}-func (*collationAllowlistRule) extractCollationNameFromAnyName(anyName parser.IAny_nameContext) string {- if anyName == nil {+func (*collationAllowlistRule) extractCollationName(cc *ast.CollateClause) string {+ if cc == nil || cc.Collname == nil {return ""}-- // any_name can be: colid | colid attrs- // For collation names like "unknown" or "utf8mb4_0900_ai_ci", we need the text- // Handle quoted strings by getting the full text and removing quotes if present- text := anyName.GetText()-- // Remove leading/trailing quotes if present- if len(text) >= 2 && text[0] == '"' && text[len(text)-1] == '"' {- return text[1 : len(text)-1]+ var parts []string+ for _, item := range cc.Collname.Items {+ if s, ok := item.(*ast.String); ok {+ parts = append(parts, s.Str)+ }}-- return text+ if len(parts) > 0 {+ return parts[len(parts)-1]+ }+ return ""}-func (r *collationAllowlistRule) addAdvice(collation string, ctx antlr.ParserRuleContext) {- text := r.tokens.GetTextFromRuleContext(ctx)-+func (r *collationAllowlistRule) addCollationAdvice(collation string) {+ stmtText := strings.TrimSpace(r.StmtText)r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.DisabledCollation.Int32(),- Title: r.title,- Content: fmt.Sprintf("Use disabled collation \"%s\", related statement \"%s\"", collation, text),+ Title: r.Title,+ Content: fmt.Sprintf("Use disabled collation \"%s\", related statement \"%s\"", collation, stmtText),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_column_comment_convention.go b/backend/plugin/advisor/pg/advisor_column_comment_convention.goindex 5d97f1ca0d..7a32bbfc39 100644--- a/backend/plugin/advisor/pg/advisor_column_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_column_comment_convention.go@@ -4,15 +4,12 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")var (@@ -35,27 +32,25 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorcommentPayload := checkCtx.Rule.GetCommentConventionPayload()rule := &columnCommentConventionRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },payload: commentPayload,}- checker := NewGenericChecker([]Rule{rule})-for _, stmt := range checkCtx.ParsedStatements {if stmt.AST == nil {continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)+ node, ok := pgparser.GetOmniNode(stmt.AST)if !ok {continue}- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)+ rule.SetStatement(stmt.BaseLine(), stmt.Text)+ rule.OnStatement(node)}- // Now validate all collected columns against commentsreturn rule.generateAdvice(), nil}@@ -63,7 +58,7 @@ type columnInfo struct {schema stringtable stringcolumn string- line int+ line int32}type commentInfo struct {@@ -71,14 +66,12 @@ type commentInfo struct {table stringcolumn stringcomment string- line int+ line int32}type columnCommentConventionRule struct {- BaseRule+ OmniBaseRule- level storepb.Advice_Status- title stringpayload *storepb.SQLReviewRule_CommentConventionRulePayloadcolumns []columnInfo@@ -89,168 +82,124 @@ func (*columnCommentConventionRule) Name() string {return "column_comment_convention"}-func (r *columnCommentConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- case "Commentstmt":- r.handleCommentstmt(ctx.(*parser.CommentstmtContext))+func (r *columnCommentConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)+ case *ast.CommentStmt:+ r.handleCommentStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*columnCommentConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-func (r *columnCommentConventionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {+func (r *columnCommentConventionRule) handleCreateStmt(n *ast.CreateStmt) {+ if n.Relation == nil {return}-- tableName := r.extractTableName(ctx.AllQualified_name())- if tableName == "" {- return- }-- // Extract all columns- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.ColumnDef() != nil && elem.ColumnDef().Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(elem.ColumnDef().Colid())- r.columns = append(r.columns, columnInfo{- schema: "public", // Default schema- table: tableName,- column: columnName,- line: elem.ColumnDef().GetStart().GetLine(),- })- }- }+ tableName := n.Relation.Relname+ cols, _ := omniTableElements(n)+ for _, col := range cols {+ r.columns = append(r.columns, columnInfo{+ schema: "public",+ table: tableName,+ column: col.Colname,+ line: r.absoluteLine(),+ })}}-func (r *columnCommentConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := ctx.Relation_expr().Qualified_name().GetText()- if tableName == "" {+func (r *columnCommentConventionRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ if n.Relation == nil {return}-- // Check ALTER TABLE ADD COLUMN- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil && cmd.ColumnDef().Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(cmd.ColumnDef().Colid())+ tableName := n.Relation.Relname+ for _, cmd := range omniAlterTableCmds(n) {+ if cmd.Subtype == int(ast.AT_AddColumn) {+ if colDef, ok := cmd.Def.(*ast.ColumnDef); ok {r.columns = append(r.columns, columnInfo{- schema: "public", // Default schema+ schema: "public",table: tableName,- column: columnName,- line: cmd.ColumnDef().GetStart().GetLine(),+ column: colDef.Colname,+ line: r.absoluteLine(),})}}}}-func (r *columnCommentConventionRule) handleCommentstmt(ctx *parser.CommentstmtContext) {- if !isTopLevel(ctx.GetParent()) {+func (r *columnCommentConventionRule) handleCommentStmt(n *ast.CommentStmt) {+ if n.Objtype != ast.OBJECT_COLUMN {return}- // Check if this is a COMMENT ON COLUMN statement- if ctx.COLUMN() == nil || ctx.Any_name() == nil {+ list, ok := n.Object.(*ast.List)+ if !ok || len(list.Items) < 2 {return}- // Extract table.column name from any_name- // any_name is like: table.column or schema.table.column- anyName := ctx.Any_name()- parts := pg.NormalizePostgreSQLAnyName(anyName)- if len(parts) < 2 {+ var tableName, columnName string+ items := list.Items+ switch len(items) {+ case 2:+ tableName = omniStringVal(items[0])+ columnName = omniStringVal(items[1])+ case 3:+ tableName = omniStringVal(items[1])+ columnName = omniStringVal(items[2])+ default:return}- tableName := parts[len(parts)-2]- columnName := parts[len(parts)-1]-- // Extract comment text- comment := ""- if ctx.Comment_text() != nil && ctx.Comment_text().Sconst() != nil {- comment = extractStringConstant(ctx.Comment_text().Sconst())- }-r.comments = append(r.comments, commentInfo{schema: "public",table: tableName,column: columnName,- comment: comment,- line: ctx.GetStart().GetLine(),+ comment: n.Comment,+ line: r.absoluteLine(),})}-func (*columnCommentConventionRule) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {- if len(qualifiedNames) == 0 {- return ""- }-- // Return the last part (table name) from qualified name- return extractTableName(qualifiedNames[0])+// absoluteLine returns the absolute 1-based line number for the current statement.+func (r *columnCommentConventionRule) absoluteLine() int32 {+ return r.ContentStartLine() + int32(r.BaseLine)}func (r *columnCommentConventionRule) generateAdvice() []*storepb.Advice {var adviceList []*storepb.Advice- // For each column, find its comment and validatefor _, col := range r.columns {- // Find the last matching comment for this columnvar matchedComment *commentInfofor i := range r.comments {comment := &r.comments[i]if comment.schema == col.schema && comment.table == col.table && comment.column == col.column {matchedComment = comment- // Continue to find the last one}}if matchedComment == nil || matchedComment.comment == "" {if r.payload.Required {adviceList = append(adviceList, &storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.CommentEmpty.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Comment is required for column `%s.%s`", col.table, col.column),StartPosition: &storepb.Position{- Line: int32(col.line),+ Line: col.line,Column: 0,},})}} else {- comment := matchedComment.comment-- // Check max length- if r.payload.MaxLength > 0 && int32(len(comment)) > r.payload.MaxLength {+ if r.payload.MaxLength > 0 && int32(len(matchedComment.comment)) > r.payload.MaxLength {adviceList = append(adviceList, &storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.CommentTooLong.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Column `%s.%s` comment is too long. The length of comment should be within %d characters", col.table, col.column, r.payload.MaxLength),StartPosition: &storepb.Position{- Line: int32(matchedComment.line),+ Line: matchedComment.line,Column: 0,},})@@ -260,3 +209,11 @@ func (r *columnCommentConventionRule) generateAdvice() []*storepb.Advice {return adviceList}++// omniStringVal extracts a string value from a Node.+func omniStringVal(n ast.Node) string {+ if s, ok := n.(*ast.String); ok {+ return s.Str+ }+ return ""+}diff --git a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.goindex 8a21667825..e6d17abeff 100644--- a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go+++ b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go@@ -3,18 +3,12 @@ package pgimport ("context""fmt"- "slices"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -37,198 +31,90 @@ func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx a}rule := &columnDefaultDisallowVolatileRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},- columnSet: make(map[string]columnData),- }-- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)}- return checker.GetAdviceList(), nil-}--type columnData struct {- schema string- table string- name string- line int+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDefaultDisallowVolatileRule struct {- BaseRule-- columnSet map[string]columnData+ OmniBaseRule}func (*columnDefaultDisallowVolatileRule) Name() string {return string(storepb.SQLReviewRule_COLUMN_DEFAULT_DISALLOW_VOLATILE)}-func (r *columnDefaultDisallowVolatileRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- // Do nothing for other node types+func (r *columnDefaultDisallowVolatileRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:}- return nil-}--func (r *columnDefaultDisallowVolatileRule) OnExit(_ antlr.ParserRuleContext, nodeType string) error {- // Generate advice when we exit the root node- if nodeType == "Root" {- r.generateAdvice()- }- return nil}-func (r *columnDefaultDisallowVolatileRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := ctx.Relation_expr().Qualified_name().GetText()+func (r *columnDefaultDisallowVolatileRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Check ALTER TABLE ADD COLUMN- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- colDef := cmd.ColumnDef()- if colDef.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())-- // Check if this column has a volatile DEFAULT- if r.hasVolatileDefault(colDef) {- r.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())- }- }- }+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) != ast.AT_AddColumn {+ continue}- }-}--func (r *columnDefaultDisallowVolatileRule) hasVolatileDefault(colDef parser.IColumnDefContext) bool {- if colDef == nil || colDef.Colquallist() == nil {- return false- }-- // Check all column constraints- allConstraints := colDef.Colquallist().AllColconstraint()- for _, constraint := range allConstraints {- // Check if this is a DEFAULT constraint- if constraint.Colconstraintelem() != nil {- elem := constraint.Colconstraintelem()- if elem.DEFAULT() != nil && elem.B_expr() != nil {- // If the default expression contains a function call, it's potentially volatile- // We check if the expression contains a function call by looking for FuncExpr patterns- if r.containsFunctionCall(elem.B_expr()) {- return true- }- }+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok || colDef == nil {+ continue}- }-- return false-}-func (r *columnDefaultDisallowVolatileRule) containsFunctionCall(expr antlr.Tree) bool {- if expr == nil {- return false+ if r.hasVolatileDefault(colDef) {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.NoDefault.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Column %q.%q in schema %q has volatile DEFAULT", tableName, colDef.Colname, "public"),+ StartPosition: &storepb.Position{+ Line: r.FindLineByName(colDef.Colname),+ Column: 0,+ },+ })+ }}-- // Check if this expression is or contains a function call- // In PostgreSQL, function calls are represented as func_expr- return r.hasFuncExpr(expr)}-func (r *columnDefaultDisallowVolatileRule) hasFuncExpr(node antlr.Tree) bool {- if node == nil {- return false- }-- // Check if this node is a function expression- switch node.(type) {- case *parser.Func_exprContext,- *parser.Func_expr_windowlessContext,- *parser.Func_expr_common_subexprContext:+// hasVolatileDefault checks if a column definition has a default that contains a function call.+func (*columnDefaultDisallowVolatileRule) hasVolatileDefault(col *ast.ColumnDef) bool {+ // Check RawDefault for function calls+ if col.RawDefault != nil && containsFuncCall(col.RawDefault) {return true}- // Recursively check children- if parserRule, ok := node.(antlr.ParserRuleContext); ok {- for i := 0; i < parserRule.GetChildCount(); i++ {- child := parserRule.GetChild(i)- if r.hasFuncExpr(child) {- return true- }+ // Check constraints for DEFAULT with function calls+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_DEFAULT && c.RawExpr != nil && containsFuncCall(c.RawExpr) {+ return true}}return false}-func (r *columnDefaultDisallowVolatileRule) addColumn(schema string, table string, column string, line int) {- if schema == "" {- schema = "public"- }-- r.columnSet[fmt.Sprintf("%s.%s.%s", schema, table, column)] = columnData{- schema: schema,- table: table,- name: column,- line: line,- }-}--func (r *columnDefaultDisallowVolatileRule) generateAdvice() {- var columnList []columnData- for _, column := range r.columnSet {- columnList = append(columnList, column)- }- slices.SortFunc(columnList, func(i, j columnData) int {- if i.line < j.line {- return -1+// containsFuncCall uses ast.Inspect to walk the expression tree looking for FuncCall nodes.+func containsFuncCall(node ast.Node) bool {+ found := false+ ast.Inspect(node, func(n ast.Node) bool {+ if found {+ return false}- if i.line > j.line {- return 1+ if _, ok := n.(*ast.FuncCall); ok {+ found = true+ return false}- return 0+ return true})-- for _, column := range columnList {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.NoDefault.Int32(),- Title: r.title,- Content: fmt.Sprintf("Column %q.%q in schema %q has volatile DEFAULT", column.table, column.name, column.schema),- StartPosition: &storepb.Position{- Line: int32(column.line),- Column: 0,- },- })- }+ return found}diff --git a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.goindex 47ac1de355..a1f4b6ee5b 100644--- a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go+++ b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go@@ -3,16 +3,13 @@ package pgimport ("context""fmt"+ "strings"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -35,83 +32,47 @@ func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advi}rule := &columnDisallowChangingTypeRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- rule.tokens = antlrAST.Tokens- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowChangingTypeRule struct {- BaseRule-- tokens *antlr.CommonTokenStream+ OmniBaseRule}func (*columnDisallowChangingTypeRule) Name() string {return "column-disallow-changing-type"}-func (r *columnDisallowChangingTypeRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- default:- // Do nothing for other node types- }- return nil-}--func (*columnDisallowChangingTypeRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *columnDisallowChangingTypeRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check for ALTER COLUMN TYPE statements- if ctx.Alter_table_cmds() == nil {+func (r *columnDisallowChangingTypeRule) OnStatement(node ast.Node) {+ n, ok := node.(*ast.AlterTableStmt)+ if !ok {return}- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ALTER opt_column? colid opt_set_data? TYPE_P typename ...- if cmd.ALTER() != nil && cmd.TYPE_P() != nil {- // This is an ALTER COLUMN TYPE statement- text := r.tokens.GetTextFromRuleContext(ctx)+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AlterColumnType {+ stmtText := strings.TrimSpace(r.StmtText)+ // Remove trailing semicolons for cleaner display+ stmtText = strings.TrimRight(stmtText, ";")+ stmtText = strings.TrimSpace(stmtText)r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.ChangeColumnType.Int32(),- Title: r.title,- Content: fmt.Sprintf("The statement \"%s\" changes column type", text),+ Title: r.Title,+ Content: fmt.Sprintf("The statement \"%s\" changes column type", stmtText),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})- break // Only report once per ALTER TABLE statement+ return // Only report once per ALTER TABLE statement}}}diff --git a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.goindex 488e3e77b1..d35bf6bbcd 100644--- a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go+++ b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go@@ -3,19 +3,15 @@ package pgimport ("context""fmt"+ "strings""github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -46,33 +42,18 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx ad}rule := &columnMaximumCharacterLengthRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},maximum: int(numberPayload.Number),}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnMaximumCharacterLengthRule struct {- BaseRule+ OmniBaseRulemaximum int}@@ -81,178 +62,115 @@ func (*columnMaximumCharacterLengthRule) Name() string {return "column-maximum-character-length"}-func (r *columnMaximumCharacterLengthRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))+func (r *columnMaximumCharacterLengthRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil}-func (*columnMaximumCharacterLengthRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *columnMaximumCharacterLengthRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {+func (r *columnMaximumCharacterLengthRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniFormatTableName(n.Relation)+ if tableName == "" {return}- tableName := r.extractTableName(ctx.AllQualified_name())-- // Check all columns- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.ColumnDef() != nil {- colDef := elem.ColumnDef()- if colDef.Colid() != nil && colDef.Typename() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- charLength := r.getCharLength(colDef.Typename())- if charLength > r.maximum {- r.addAdvice(tableName, columnName, colDef.GetStart().GetLine())- return // Only report first violation- }- }- }+ cols, _ := omniTableElements(n)+ for _, col := range cols {+ if col.TypeName == nil {+ continue+ }+ charLength := r.getCharLength(col.TypeName)+ if charLength > r.maximum {+ r.addAdvice(tableName, col.Colname, col.Colname)+ return // Only report first violation}}}-func (r *columnMaximumCharacterLengthRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- parts := pg.NormalizePostgreSQLQualifiedName(ctx.Relation_expr().Qualified_name())- if len(parts) == 0 {+func (r *columnMaximumCharacterLengthRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniFormatTableName(n.Relation)+ if tableName == "" {return}- var tableName string- // Format: schema.table or just table (always with quotes)- if len(parts) == 1 {- tableName = fmt.Sprintf("%q", parts[0])- } else {- tableName = fmt.Sprintf("%q.%q", parts[0], parts[1])- }-- // Check ALTER TABLE commands- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- colDef := cmd.ColumnDef()- if colDef.Colid() != nil && colDef.Typename() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- charLength := r.getCharLength(colDef.Typename())- if charLength > r.maximum {- r.addAdvice(tableName, columnName, colDef.GetStart().GetLine())- return- }- }+ for _, cmd := range omniAlterTableCmds(n) {+ switch ast.AlterTableType(cmd.Subtype) {+ case ast.AT_AddColumn:+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok || colDef == nil || colDef.TypeName == nil {+ continue}-- // ALTER COLUMN TYPE- if cmd.ALTER() != nil && cmd.TYPE_P() != nil && cmd.Typename() != nil {- // Get column name- allColids := cmd.AllColid()- if len(allColids) > 0 {- columnName := pg.NormalizePostgreSQLColid(allColids[0])- charLength := r.getCharLength(cmd.Typename())- if charLength > r.maximum {- r.addAdvice(tableName, columnName, cmd.GetStart().GetLine())- return- }- }+ charLength := r.getCharLength(colDef.TypeName)+ if charLength > r.maximum {+ r.addAdvice(tableName, colDef.Colname, colDef.Colname)+ return}+ case ast.AT_AlterColumnType:+ typeName, ok := cmd.Def.(*ast.ColumnDef)+ if !ok || typeName == nil || typeName.TypeName == nil {+ continue+ }+ charLength := r.getCharLength(typeName.TypeName)+ if charLength > r.maximum {+ r.addAdvice(tableName, cmd.Name, cmd.Name)+ return+ }+ default:}}}-func (*columnMaximumCharacterLengthRule) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {- if len(qualifiedNames) == 0 {- return ""- }-- parts := pg.NormalizePostgreSQLQualifiedName(qualifiedNames[0])- if len(parts) == 0 {- return ""- }-- // Format: schema.table or just table (always with quotes)- if len(parts) == 1 {- return fmt.Sprintf("%q", parts[0])- }- return fmt.Sprintf("%q.%q", parts[0], parts[1])-}--func (*columnMaximumCharacterLengthRule) getCharLength(typename parser.ITypenameContext) int {- if typename == nil {- return 0- }-- // Check if this is a character type- if typename.Simpletypename() == nil {- return 0- }-- simpleType := typename.Simpletypename()+// getCharLength returns the character length if the type is CHAR/CHARACTER/NCHAR (without VARYING).+// Returns 0 for non-character types or VARCHAR types.+func (*columnMaximumCharacterLengthRule) getCharLength(tn *ast.TypeName) int {+ name := strings.ToLower(omniTypeName(tn))- // Check if it's a character type- if simpleType.Character() == nil {- return 0- }-- character := simpleType.Character()- if character.Character_c() == nil {- return 0- }-- characterC := character.Character_c()-- // Skip VARCHAR - we only check CHAR types- if characterC.VARCHAR() != nil {+ // Only check fixed-length char types (char, character, bpchar, nchar)+ // Skip varchar, character varying, text+ switch name {+ case "char", "character", "bpchar", "nchar":+ // OK, continue+ default:return 0}- // Skip CHARACTER VARYING, CHAR VARYING, etc.- // Only check CHAR/CHARACTER/NCHAR without VARYING- if (characterC.CHARACTER() != nil || characterC.CHAR_P() != nil || characterC.NCHAR() != nil) && characterC.Opt_varying() != nil {+ // Get the length from Typmods+ if tn.Typmods == nil || len(tn.Typmods.Items) == 0 {return 0}- // Now check if it has a size- if character.Iconst() != nil {- size, err := extractIntegerConstant(character.Iconst())- if err != nil {- // If parsing fails, return 0 (no length limit to check)- return 0- }- return size+ // First typmod item is the length+ if intVal, ok := tn.Typmods.Items[0].(*ast.Integer); ok {+ return int(intVal.Ival)}return 0}-func (r *columnMaximumCharacterLengthRule) addAdvice(tableName, columnName string, line int) {+func (r *columnMaximumCharacterLengthRule) addAdvice(tableName, columnName, searchName string) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.CharLengthExceedsLimit.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("The length of the CHAR column %q in table %s is bigger than %d, please use VARCHAR instead", columnName, tableName, r.maximum),StartPosition: &storepb.Position{- Line: int32(line),+ Line: r.FindLineByName(searchName),Column: 0,},})}++// omniFormatTableName formats a RangeVar as a quoted table name string for display.+func omniFormatTableName(rv *ast.RangeVar) string {+ if rv == nil || rv.Relname == "" {+ return ""+ }+ if rv.Schemaname != "" {+ return fmt.Sprintf("%q.%q", rv.Schemaname, rv.Relname)+ }+ return fmt.Sprintf("%q", rv.Relname)+}diff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.goindex 768a02c73b..e3c82696fc 100644--- a/backend/plugin/advisor/pg/advisor_column_no_null.go+++ b/backend/plugin/advisor/pg/advisor_column_no_null.go@@ -4,16 +4,14 @@ import ("context""fmt""slices"+ "strings"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -37,33 +35,31 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (}rule := &columnNoNullRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},originalMetadata: checkCtx.OriginalMetadata,nullableColumns: make(columnMap),}- checker := NewGenericChecker([]Rule{rule})-+ // Manually iterate statements instead of using RunOmniRules because+ // generateAdvice must be called AFTER all statements have been processed.for _, stmt := range checkCtx.ParsedStatements {if stmt.AST == nil {continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)+ node, ok := pgparser.GetOmniNode(stmt.AST)if !ok {continue}- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)+ rule.SetStatement(stmt.BaseLine(), stmt.Text)+ rule.OnStatement(node)}- // Generate advice after all parse trees have been walkedrule.generateAdvice()- return checker.GetAdviceList(), nil+ return rule.GetAdviceList(), nil}type columnName struct {@@ -79,41 +75,53 @@ func (c columnName) normalizeTableName() string {return fmt.Sprintf("%q.%q", c.schema, c.table)}-type columnMap map[columnName]int+type columnMap map[columnName]int32type columnNoNullRule struct {- BaseRule+ OmniBaseRuleoriginalMetadata *model.DatabaseMetadatanullableColumns columnMap}func (*columnNoNullRule) Name() string {- return "CreatestmtAltertablestmt"+ return string(storepb.SQLReviewRule_COLUMN_NO_NULL)}-func (r *columnNoNullRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- if createStmt, ok := ctx.(*parser.CreatestmtContext); ok {- r.handleCreatestmt(createStmt)- }- case "Altertablestmt":- if alterStmt, ok := ctx.(*parser.AltertablestmtContext); ok {- r.handleAltertablestmt(alterStmt)- }+func (r *columnNoNullRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil}-func (*columnNoNullRule) OnExit(antlr.ParserRuleContext, string) error {- return nil+// columnLine finds the 1-based line number of a column name within the current+// statement text, searching from the given byte offset. Returns the line number+// and the updated search offset (past the found occurrence).+// Falls back to ContentStartLine() if not found.+func (r *columnNoNullRule) columnLine(colName string, searchFrom int) (int32, int) {+ text := r.StmtText+ if searchFrom < len(text) {+ idx := strings.Index(text[searchFrom:], colName)+ if idx >= 0 {+ pos := searchFrom + idx+ line := int32(1)+ for i := 0; i < pos; i++ {+ if text[i] == '\n' {+ line+++ }+ }+ return line, pos + len(colName)+ }+ }+ return r.ContentStartLine(), searchFrom}// generateAdvice generates advice for all nullable columns.-// This should be called AFTER walking all parse trees to avoid duplicates.+// This should be called AFTER processing all statements to avoid duplicates.func (r *columnNoNullRule) generateAdvice() {var columnList []columnNamefor column := range r.nullableColumns {@@ -121,7 +129,6 @@ func (r *columnNoNullRule) generateAdvice() {}if len(columnList) > 0 {- // Order it cause the random iteration order in Goslices.SortFunc(columnList, func(i, j columnName) int {if i.schema != j.schema {if i.schema < j.schema {@@ -146,122 +153,130 @@ func (r *columnNoNullRule) generateAdvice() {}for _, column := range columnList {- // Note: We already added baseLine offset when storing the line number,- // but AddAdvice will add it again, so we need to subtract it firstlineNumber := r.nullableColumns[column]- r.AddAdvice(&storepb.Advice{- Status: r.level,+ r.AddAdviceAbsolute(&storepb.Advice{+ Status: r.Level,Code: code.ColumnCannotNull.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Column %q in %s cannot have NULL value", column.column, column.normalizeTableName()),StartPosition: &storepb.Position{- Line: int32(lineNumber - r.baseLine),+ Line: lineNumber,Column: 0,},})}}-func (r *columnNoNullRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- tableName := r.extractTableName(ctx.AllQualified_name())+func (r *columnNoNullRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)if tableName == "" {return}+ schema := omniSchemaName(n.Relation)- // Track all columns and their line numbers- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- // Column definition- if elem.ColumnDef() != nil {- colDef := elem.ColumnDef()- if colDef.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- // Add column as nullable by default- r.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())-- // Check column constraints for NOT NULL or PRIMARY KEY- r.removeColumnByColConstraints("public", tableName, colDef)- }- }+ cols, constraints := omniTableElements(n)- // Table constraint (like PRIMARY KEY (id))- if elem.Tableconstraint() != nil {- r.removeColumnByTableConstraint("public", tableName, elem.Tableconstraint())+ searchFrom := 0+ for _, col := range cols {+ var line int32+ line, searchFrom = r.columnLine(col.Colname, searchFrom)+ r.addColumn(schema, tableName, col.Colname, line)++ // Check column-level constraints for NOT NULL or PRIMARY KEY+ if col.IsNotNull {+ r.removeColumn(schema, tableName, col.Colname)+ continue+ }+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_NOTNULL || c.Contype == ast.CONSTR_PRIMARY {+ r.removeColumn(schema, tableName, col.Colname)+ break}}}-}-func (r *columnNoNullRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return+ // Table-level constraints (e.g., PRIMARY KEY (col1, col2))+ for _, c := range constraints {+ if c.Contype == ast.CONSTR_PRIMARY {+ for _, colName := range omniConstraintColumns(c) {+ r.removeColumn(schema, tableName, colName)+ }+ }}+}- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {+func (r *columnNoNullRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)+ if tableName == "" {return}-- tableName := ctx.Relation_expr().Qualified_name().GetText()-- // Check ALTER TABLE commands- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- colDef := cmd.ColumnDef()- if colDef.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- r.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())- r.removeColumnByColConstraints("public", tableName, colDef)- }+ schema := omniSchemaName(n.Relation)++ for _, cmd := range omniAlterTableCmds(n) {+ switch ast.AlterTableType(cmd.Subtype) {+ case ast.AT_AddColumn:+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok || colDef == nil {+ continue}+ line, _ := r.columnLine(colDef.Colname, 0)+ r.addColumn(schema, tableName, colDef.Colname, line)- // ALTER COLUMN SET NOT NULL- if cmd.ALTER() != nil && cmd.SET() != nil && cmd.NOT() != nil && cmd.NULL_P() != nil {- allColids := cmd.AllColid()- if len(allColids) > 0 {- columnName := pg.NormalizePostgreSQLColid(allColids[0])- r.removeColumn("public", tableName, columnName)+ // Check column-level constraints+ if colDef.IsNotNull {+ r.removeColumn(schema, tableName, colDef.Colname)+ continue+ }+ for _, c := range omniColumnConstraints(colDef) {+ if c.Contype == ast.CONSTR_NOTNULL || c.Contype == ast.CONSTR_PRIMARY {+ r.removeColumn(schema, tableName, colDef.Colname)+ break}}- // ALTER COLUMN DROP NOT NULL- if cmd.ALTER() != nil && cmd.DROP() != nil && cmd.NOT() != nil && cmd.NULL_P() != nil {- allColids := cmd.AllColid()- if len(allColids) > 0 {- columnName := pg.NormalizePostgreSQLColid(allColids[0])- r.addColumn("public", tableName, columnName, cmd.GetStart().GetLine())- }+ case ast.AT_SetNotNull:+ r.removeColumn(schema, tableName, cmd.Name)++ case ast.AT_DropNotNull:+ r.addColumn(schema, tableName, cmd.Name, r.ContentStartLine())++ case ast.AT_AddConstraint:+ constraint, ok := cmd.Def.(*ast.Constraint)+ if !ok || constraint == nil {+ continue}+ if constraint.Contype == ast.CONSTR_PRIMARY {+ for _, colName := range omniConstraintColumns(constraint) {+ r.removeColumn(schema, tableName, colName)+ }- // ADD table constraint- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- r.removeColumnByTableConstraint("public", tableName, cmd.Tableconstraint())+ // PRIMARY KEY USING INDEX+ if constraint.Indexname != "" && r.originalMetadata != nil {+ schemaMetadata := r.originalMetadata.GetSchemaMetadata(schema)+ if schemaMetadata != nil {+ dbTable := schemaMetadata.GetTable(tableName)+ if dbTable != nil {+ index := dbTable.GetIndex(constraint.Indexname)+ if index != nil {+ for _, expression := range index.GetProto().GetExpressions() {+ r.removeColumn(schema, tableName, expression)+ }+ }+ }+ }+ }}+ default:}}}-func (*columnNoNullRule) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {- if len(qualifiedNames) == 0 {- return ""- }-- return extractTableName(qualifiedNames[0])-}--func (r *columnNoNullRule) addColumn(schema, table, column string, line int) {+func (r *columnNoNullRule) addColumn(schema, table, column string, line int32) {if schema == "" {schema = "public"}- // Store absolute line number (adding baseLine offset now, not later in AddAdvice)- r.nullableColumns[columnName{schema: schema, table: table, column: column}] = line + r.baseLine+ // Store absolute line number (BaseLine + relative line)+ r.nullableColumns[columnName{schema: schema, table: table, column: column}] = line + int32(r.BaseLine)}func (r *columnNoNullRule) removeColumn(schema, table, column string) {@@ -270,74 +285,3 @@ func (r *columnNoNullRule) removeColumn(schema, table, column string) {}delete(r.nullableColumns, columnName{schema: schema, table: table, column: column})}--func (r *columnNoNullRule) removeColumnByColConstraints(schema, table string, colDef parser.IColumnDefContext) {- if colDef.Colquallist() == nil {- return- }-- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- allConstraints := colDef.Colquallist().AllColconstraint()- for _, constraint := range allConstraints {- if constraint.Colconstraintelem() == nil {- continue- }-- elem := constraint.Colconstraintelem()-- // NOT NULL constraint- if elem.NOT() != nil && elem.NULL_P() != nil {- r.removeColumn(schema, table, columnName)- return- }-- // PRIMARY KEY constraint- if elem.PRIMARY() != nil && elem.KEY() != nil {- r.removeColumn(schema, table, columnName)- return- }- }-}--func (r *columnNoNullRule) removeColumnByTableConstraint(schema, table string, constraint parser.ITableconstraintContext) {- if constraint.Constraintelem() == nil {- return- }-- elem := constraint.Constraintelem()-- // PRIMARY KEY (col1, col2, ...)- if elem.PRIMARY() != nil && elem.KEY() != nil && elem.Columnlist() != nil {- allColumnElems := elem.Columnlist().AllColumnElem()- for _, columnElem := range allColumnElems {- if columnElem.Colid() != nil {- r.removeColumn(schema, table, pg.NormalizePostgreSQLColid(columnElem.Colid()))- }- }- return- }-- // PRIMARY KEY USING INDEX- if elem.PRIMARY() != nil && elem.KEY() != nil && elem.Existingindex() != nil {- existingIndex := elem.Existingindex()- if existingIndex.Name() != nil {- indexName := pg.NormalizePostgreSQLName(existingIndex.Name())- // Try to find index in catalog- if r.originalMetadata != nil {- schemaMetadata := r.originalMetadata.GetSchemaMetadata(schema)- var index *model.IndexMetadata- if schemaMetadata != nil {- dbTable := schemaMetadata.GetTable(table)- if dbTable != nil {- index = dbTable.GetIndex(indexName)- }- }- if index != nil {- for _, expression := range index.GetProto().GetExpressions() {- r.removeColumn(schema, table, expression)- }- }- }- }- }-}diff --git a/backend/plugin/advisor/pg/advisor_column_require_default.go b/backend/plugin/advisor/pg/advisor_column_require_default.goindex 6ace247119..1488c8b3c9 100644--- a/backend/plugin/advisor/pg/advisor_column_require_default.go+++ b/backend/plugin/advisor/pg/advisor_column_require_default.go@@ -5,16 +5,11 @@ import ("fmt""strings"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -37,170 +32,104 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Co}rule := &columnRequireDefaultRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequireDefaultRule struct {- BaseRule+ OmniBaseRule}func (*columnRequireDefaultRule) Name() string {return "column_require_default"}-func (r *columnRequireDefaultRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- if c, ok := ctx.(*parser.CreatestmtContext); ok {- r.handleCreatestmt(c)- }- case "Altertablestmt":- if c, ok := ctx.(*parser.AltertablestmtContext); ok {- r.handleAltertablestmt(c)- }+func (r *columnRequireDefaultRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*columnRequireDefaultRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-func (r *columnRequireDefaultRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- qualifiedNames := ctx.AllQualified_name()- if len(qualifiedNames) == 0 {- return- }-- tableName := extractTableName(qualifiedNames[0])+func (r *columnRequireDefaultRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Check all columns for DEFAULT clause- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.ColumnDef() != nil {- colDef := elem.ColumnDef()- if colDef.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- // Check if column has DEFAULT- if !r.hasDefault(colDef) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.NoDefault.Int32(),- Title: r.title,- Content: fmt.Sprintf("Column %q.%q in schema %q doesn't have DEFAULT", tableName, columnName, "public"),- StartPosition: &storepb.Position{- Line: int32(colDef.GetStart().GetLine()),- Column: 0,- },- })- }- }- }+ cols, _ := omniTableElements(n)+ for _, col := range cols {+ if !r.hasDefault(col) {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.NoDefault.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Column %q.%q in schema %q doesn't have DEFAULT", tableName, col.Colname, "public"),+ StartPosition: &storepb.Position{+ Line: r.FindLineByName(col.Colname),+ Column: 0,+ },+ })}}}-func (r *columnRequireDefaultRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := extractTableName(ctx.Relation_expr().Qualified_name())+func (r *columnRequireDefaultRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Check ALTER TABLE ADD COLUMN- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- colDef := cmd.ColumnDef()- if colDef.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- // Check if column has DEFAULT- if !r.hasDefault(colDef) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.NoDefault.Int32(),- Title: r.title,- Content: fmt.Sprintf("Column %q.%q in schema %q doesn't have DEFAULT", tableName, columnName, "public"),- StartPosition: &storepb.Position{- Line: int32(colDef.GetStart().GetLine()),- Column: 0,- },- })- }- }- }+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) != ast.AT_AddColumn {+ continue+ }+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok || colDef == nil {+ continue+ }+ if !r.hasDefault(colDef) {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.NoDefault.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Column %q.%q in schema %q doesn't have DEFAULT", tableName, colDef.Colname, "public"),+ StartPosition: &storepb.Position{+ Line: r.FindLineByName(colDef.Colname),+ Column: 0,+ },+ })}}}// hasDefault checks if a column definition has a DEFAULT clause-// or uses a type that implicitly includes a default (like serial, bigserial, smallserial)-func (*columnRequireDefaultRule) hasDefault(colDef parser.IColumnDefContext) bool {- // Check if the type is serial/bigserial/smallserial (which have implicit defaults)- if colDef.Typename() != nil && colDef.Typename().Simpletypename() != nil {- simpleType := colDef.Typename().Simpletypename()- typeText := strings.ToLower(simpleType.GetText())- // serial, bigserial, smallserial all have implicit DEFAULT nextval()- if typeText == "serial" || typeText == "bigserial" || typeText == "smallserial" {- return true- }+// or uses a serial type (which has an implicit default).+func (*columnRequireDefaultRule) hasDefault(col *ast.ColumnDef) bool {+ // Check if ColumnDef has RawDefault set directly+ if col.RawDefault != nil {+ return true}- // Check for explicit DEFAULT constraint- if colDef.Colquallist() == nil {- return false+ // Check if the type is serial/bigserial/smallserial (which have implicit defaults)+ typeName := omniTypeName(col.TypeName)+ lower := strings.ToLower(typeName)+ if lower == "serial" || lower == "bigserial" || lower == "smallserial" ||+ lower == "serial4" || lower == "serial8" || lower == "serial2" {+ return true}- allConstraints := colDef.Colquallist().AllColconstraint()- for _, constraint := range allConstraints {- if constraint.Colconstraintelem() == nil {- continue- }-- elem := constraint.Colconstraintelem()-- // Check for DEFAULT constraint- if elem.DEFAULT() != nil {+ // Check for explicit DEFAULT constraint in the constraints list+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_DEFAULT {return true}}diff --git a/backend/plugin/advisor/pg/advisor_column_required.go b/backend/plugin/advisor/pg/advisor_column_required.goindex c5762118ad..db8dfa8ea5 100644--- a/backend/plugin/advisor/pg/advisor_column_required.go+++ b/backend/plugin/advisor/pg/advisor_column_required.go@@ -8,16 +8,11 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -46,211 +41,127 @@ func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Contereturn nil, errors.New("string_array_payload is required for column required rule")}- // Convert to map for O(1) lookuprequiredColumnsMap := make(columnSet)for _, col := range stringArrayPayload.List {requiredColumnsMap[col] = true}rule := &columnRequirementRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},requiredColumnsMap: requiredColumnsMap,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequirementRule struct {- BaseRule+ OmniBaseRule- requiredColumnsMap columnSet // Map of all required columns (from config)- requiredColumns columnSet // Temp map for checking CREATE TABLE+ requiredColumnsMap columnSet}func (*columnRequirementRule) Name() string {return "column_requirement"}-func (r *columnRequirementRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx)- case "Altertablestmt":- r.handleAltertablestmt(ctx)- case "Renamestmt":- r.handleRenamestmt(ctx)+func (r *columnRequirementRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)+ case *ast.RenameStmt:+ r.handleRenameStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*columnRequirementRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-func (r *columnRequirementRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- // Initialize required columns for this statement (copy from config map)- r.requiredColumns = make(columnSet)- for column := range r.requiredColumnsMap {- r.requiredColumns[column] = true- }-- qualifiedNames := createCtx.AllQualified_name()- if len(qualifiedNames) == 0 {+func (r *columnRequirementRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ if tableName == "" {return}- tableName := extractTableName(qualifiedNames[0])- if tableName == "" {- return+ // Copy required columns to check against+ required := make(columnSet)+ for col := range r.requiredColumnsMap {+ required[col] = true}- // Mark columns as present- if createCtx.Opttableelementlist() != nil && createCtx.Opttableelementlist().Tableelementlist() != nil {- allElements := createCtx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.ColumnDef() != nil && elem.ColumnDef().Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(elem.ColumnDef().Colid())- delete(r.requiredColumns, columnName)- }- }+ cols, _ := omniTableElements(n)+ for _, col := range cols {+ delete(required, col.Colname)}- // Check if any required columns are missing- if len(r.requiredColumns) > 0 {+ if len(required) > 0 {var missingColumns []string- for column := range r.requiredColumns {+ for column := range required {missingColumns = append(missingColumns, column)}slices.Sort(missingColumns)r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NoRequiredColumn.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Table %q requires columns: %s", tableName, strings.Join(missingColumns, ", ")),StartPosition: &storepb.Position{- Line: int32(createCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}-func (r *columnRequirementRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- alterCtx, ok := ctx.(*parser.AltertablestmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- if alterCtx.Relation_expr() == nil || alterCtx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := extractTableName(alterCtx.Relation_expr().Qualified_name())+func (r *columnRequirementRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Check ALTER TABLE commands- if alterCtx.Alter_table_cmds() != nil {- allCmds := alterCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // DROP COLUMN (note: COLUMN keyword is optional in PostgreSQL)- if cmd.DROP() != nil {- allColids := cmd.AllColid()- if len(allColids) > 0 {- columnName := pg.NormalizePostgreSQLColid(allColids[0])- // Check if this is a required column (O(1) lookup)- if r.requiredColumnsMap[columnName] {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.NoRequiredColumn.Int32(),- Title: r.title,- Content: fmt.Sprintf("Table %q requires columns: %s", tableName, columnName),- StartPosition: &storepb.Position{- Line: int32(alterCtx.GetStart().GetLine()),- Column: 0,- },- })- }- }+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_DropColumn {+ colName := cmd.Name+ if r.requiredColumnsMap[colName] {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.NoRequiredColumn.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Table %q requires columns: %s", tableName, colName),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}}}}-func (r *columnRequirementRule) handleRenamestmt(ctx antlr.ParserRuleContext) {- renameCtx, ok := ctx.(*parser.RenamestmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is RENAME COLUMN- if renameCtx.Opt_column() == nil || renameCtx.Opt_column().COLUMN() == nil {+func (r *columnRequirementRule) handleRenameStmt(n *ast.RenameStmt) {+ if n.RenameType != ast.OBJECT_COLUMN {return}- // Get table name- var tableName string- if renameCtx.Relation_expr() != nil && renameCtx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(renameCtx.Relation_expr().Qualified_name())- }+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Get old and new column names- allNames := renameCtx.AllName()- if len(allNames) < 2 {- return- }-- oldName := pg.NormalizePostgreSQLName(allNames[0])- newName := pg.NormalizePostgreSQLName(allNames[1])+ oldName := n.Subname+ newName := n.Newname- // Check if renaming away from a required column name (O(1) lookup)if r.requiredColumnsMap[oldName] && oldName != newName {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NoRequiredColumn.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Table %q requires columns: %s", tableName, oldName),StartPosition: &storepb.Position{- Line: int32(renameCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.goindex 5c379a9ee4..d8a2f03d97 100644--- a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go+++ b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go@@ -5,16 +5,11 @@ import ("fmt""strings"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -38,40 +33,24 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.stringArrayPayload := checkCtx.Rule.GetStringArrayPayload()- // Convert disallowed types to lowercase for case-insensitive comparisontypeRestriction := make(map[string]bool)for _, tp := range stringArrayPayload.List {typeRestriction[strings.ToLower(tp)] = true}rule := &columnTypeDisallowListRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},typeRestriction: typeRestriction,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnTypeDisallowListRule struct {- BaseRule+ OmniBaseRuletypeRestriction map[string]bool}@@ -80,104 +59,59 @@ func (*columnTypeDisallowListRule) Name() string {return "column_type_disallow_list"}-func (r *columnTypeDisallowListRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- if c, ok := ctx.(*parser.CreatestmtContext); ok {- r.handleCreatestmt(c)- }- case "Altertablestmt":- if c, ok := ctx.(*parser.AltertablestmtContext); ok {- r.handleAltertablestmt(c)- }+func (r *columnTypeDisallowListRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil}-func (*columnTypeDisallowListRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *columnTypeDisallowListRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- qualifiedNames := ctx.AllQualified_name()- if len(qualifiedNames) == 0 {- return- }-- tableName := extractTableName(qualifiedNames[0])+func (r *columnTypeDisallowListRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Check all columns for disallowed types- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.ColumnDef() != nil {- colDef := elem.ColumnDef()- if colDef.Colid() != nil && colDef.Typename() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- r.checkType(tableName, columnName, colDef.Typename(), colDef.GetStart().GetLine())- }- }+ cols, _ := omniTableElements(n)+ for _, col := range cols {+ if col.TypeName != nil {+ r.checkType(tableName, col.Colname, col.TypeName, col.Colname)}}}-func (r *columnTypeDisallowListRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := extractTableName(ctx.Relation_expr().Qualified_name())+func (r *columnTypeDisallowListRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Check ALTER TABLE ADD COLUMN- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- colDef := cmd.ColumnDef()- if colDef.Colid() != nil && colDef.Typename() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- r.checkType(tableName, columnName, colDef.Typename(), colDef.GetStart().GetLine())- }+ for _, cmd := range omniAlterTableCmds(n) {+ switch ast.AlterTableType(cmd.Subtype) {+ case ast.AT_AddColumn:+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok || colDef == nil || colDef.TypeName == nil {+ continue}-- // ALTER COLUMN TYPE- if cmd.ALTER() != nil && cmd.TYPE_P() != nil && cmd.Typename() != nil {- allColids := cmd.AllColid()- if len(allColids) > 0 {- columnName := pg.NormalizePostgreSQLColid(allColids[0])- r.checkType(tableName, columnName, cmd.Typename(), cmd.GetStart().GetLine())- }+ r.checkType(tableName, colDef.Colname, colDef.TypeName, colDef.Colname)+ case ast.AT_AlterColumnType:+ typeName, ok := cmd.Def.(*ast.ColumnDef)+ if !ok || typeName == nil || typeName.TypeName == nil {+ continue}+ r.checkType(tableName, cmd.Name, typeName.TypeName, cmd.Name)+ default:}}}-func (r *columnTypeDisallowListRule) checkType(tableName, columnName string, typename parser.ITypenameContext, line int) {- if typename == nil {- return- }-- // Get the type text- typeText := typename.GetText()+func (r *columnTypeDisallowListRule) checkType(tableName, columnName string, tn *ast.TypeName, searchName string) {+ // Build a type text from the TypeName for equivalence checking+ typeText := omniTypeName(tn)- // Check if this type is equivalent to any type in the disallow listvar matchedDisallowedType stringfor disallowedType := range r.typeRestriction {if areTypesEquivalent(typeText, disallowedType) {@@ -188,12 +122,12 @@ func (r *columnTypeDisallowListRule) checkType(tableName, columnName string, typif matchedDisallowedType != "" {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.DisabledColumnType.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Disallow column type %s but column %q.%q is", strings.ToUpper(matchedDisallowedType), tableName, columnName),StartPosition: &storepb.Position{- Line: int32(line),+ Line: r.FindLineByName(searchName),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.goindex 63b460ee6e..874bc97d22 100644--- a/backend/plugin/advisor/pg/advisor_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_comment_convention.go@@ -6,14 +6,11 @@ import ("github.com/pkg/errors"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -41,33 +38,18 @@ func (*CommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Conte}rule := &commentConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},maxLength: int(numberPayload.Number),}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type commentConventionRule struct {- BaseRule+ OmniBaseRulemaxLength int}@@ -76,46 +58,22 @@ func (*commentConventionRule) Name() string {return "comment_convention"}-func (r *commentConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Commentstmt":- r.handleCommentstmt(ctx)- default:- // Do nothing for other node types- }- return nil-}--func (*commentConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *commentConventionRule) handleCommentstmt(ctx antlr.ParserRuleContext) {- commentstmtCtx, ok := ctx.(*parser.CommentstmtContext)+func (r *commentConventionRule) OnStatement(node ast.Node) {+ cs, ok := node.(*ast.CommentStmt)if !ok {return}- if !isTopLevel(commentstmtCtx.GetParent()) {- return- }-- // Extract comment text- if commentstmtCtx.Comment_text() != nil && commentstmtCtx.Comment_text().Sconst() != nil {- comment := extractStringConstant(commentstmtCtx.Comment_text().Sconst())-- // Check length- if r.maxLength > 0 && len(comment) > r.maxLength {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.CommentTooLong.Int32(),- Title: r.title,- Content: fmt.Sprintf("The length of comment should be within %d characters", r.maxLength),- StartPosition: &storepb.Position{- Line: int32(commentstmtCtx.GetStart().GetLine()),- Column: 0,- },- })- }+ if r.maxLength > 0 && len(cs.Comment) > r.maxLength {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.CommentTooLong.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("The length of comment should be within %d characters", r.maxLength),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}}diff --git a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go b/backend/plugin/advisor/pg/advisor_encoding_allowlist.goindex 97d101da0a..42c3b16758 100644--- a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go@@ -5,14 +5,11 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -36,40 +33,24 @@ func (*EncodingAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.ContestringArrayPayload := checkCtx.Rule.GetStringArrayPayload()- // Convert allowlist to lowercase for case-insensitive comparisonallowlist := make(map[string]bool)for _, encoding := range stringArrayPayload.List {allowlist[strings.ToLower(encoding)] = true}rule := &encodingAllowlistRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},allowlist: allowlist,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type encodingAllowlistRule struct {- BaseRule+ OmniBaseRuleallowlist map[string]bool}@@ -78,78 +59,45 @@ func (*encodingAllowlistRule) Name() string {return "encoding-allowlist"}-func (r *encodingAllowlistRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createdbstmt":- r.handleCreatedbstmt(ctx.(*parser.CreatedbstmtContext))- default:- // Do nothing for other node types- }- return nil-}--func (*encodingAllowlistRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *encodingAllowlistRule) handleCreatedbstmt(ctx *parser.CreatedbstmtContext) {- if !isTopLevel(ctx.GetParent()) {+func (r *encodingAllowlistRule) OnStatement(node ast.Node) {+ n, ok := node.(*ast.CreatedbStmt)+ if !ok {return}- // Extract encoding from createdb_opt_list- // Check both with and without WITH keyword- var encoding string- if ctx.Createdb_opt_list() != nil {- encoding = r.extractEncoding(ctx.Createdb_opt_list())+ encoding := r.extractEncoding(n)+ if encoding == "" {+ return}- if encoding != "" {- // Check if encoding is in allowlist- if !r.allowlist[strings.ToLower(encoding)] {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.DisabledCharset.Int32(),- Title: r.title,- Content: fmt.Sprintf("\"\" used disabled encoding '%s'", strings.ToLower(encoding)),- StartPosition: &storepb.Position{- Line: 0,- Column: 0,- },- })- }+ if !r.allowlist[strings.ToLower(encoding)] {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.DisabledCharset.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("\"\" used disabled encoding '%s'", strings.ToLower(encoding)),+ StartPosition: &storepb.Position{+ Line: 0,+ Column: 0,+ },+ })}}-func (*encodingAllowlistRule) extractEncoding(optList parser.ICreatedb_opt_listContext) string {- if optList == nil {+func (*encodingAllowlistRule) extractEncoding(n *ast.CreatedbStmt) string {+ if n.Options == nil {return ""}-- // Iterate through all createdb_opt_items- if optList.Createdb_opt_items() == nil {- return ""- }-- for _, item := range optList.Createdb_opt_items().AllCreatedb_opt_item() {- if item == nil {+ for _, item := range n.Options.Items {+ defElem, ok := item.(*ast.DefElem)+ if !ok {continue}-- // Check if this is an ENCODING option- if item.Createdb_opt_name() != nil && item.Createdb_opt_name().ENCODING() != nil {- // Get the encoding value from Opt_boolean_or_string- if item.Opt_boolean_or_string() != nil {- // Could be a string constant or identifier- text := item.Opt_boolean_or_string().GetText()- // Remove quotes if present- if len(text) >= 2 && text[0] == '\'' && text[len(text)-1] == '\'' {- return text[1 : len(text)-1]- }- return text+ if strings.EqualFold(defElem.Defname, "encoding") {+ if s, ok := defElem.Arg.(*ast.String); ok {+ return s.Str}}}-return ""}diff --git a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go b/backend/plugin/advisor/pg/advisor_index_create_concurrently.goindex 1bc8b2b87c..c7ffc1f9ea 100644--- a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go+++ b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go@@ -3,15 +3,11 @@ package pgimport ("context"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -34,133 +30,63 @@ func (*IndexConcurrentlyAdvisor) Check(_ context.Context, checkCtx advisor.Conte}rule := &indexCreateConcurrentlyRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},newlyCreatedTables: make(map[string]bool),}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexCreateConcurrentlyRule struct {- BaseRule+ OmniBaseRulenewlyCreatedTables map[string]bool}func (*indexCreateConcurrentlyRule) Name() string {- return "index_create_concurrently"+ return string(storepb.SQLReviewRule_INDEX_CREATE_CONCURRENTLY)}-func (r *indexCreateConcurrentlyRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- if c, ok := ctx.(*parser.CreatestmtContext); ok {- r.handleCreatestmt(c)- }- case "Indexstmt":- if c, ok := ctx.(*parser.IndexstmtContext); ok {- r.handleIndexstmt(c)- }- case "Dropstmt":- if c, ok := ctx.(*parser.DropstmtContext); ok {- r.handleDropstmt(c)- }- default:- // Do nothing for other node types- }- return nil-}--func (*indexCreateConcurrentlyRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleCreatestmt collects newly created tables-func (r *indexCreateConcurrentlyRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Extract table name- qualifiedNames := ctx.AllQualified_name()- if len(qualifiedNames) > 0 {- tableName := extractTableName(qualifiedNames[0])+func (r *indexCreateConcurrentlyRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ tableName := omniTableName(n.Relation)if tableName != "" {r.newlyCreatedTables[tableName] = true}- }-}--// handleIndexstmt checks CREATE INDEX statements-func (r *indexCreateConcurrentlyRule) handleIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if CONCURRENTLY is used (via Opt_concurrently)- hasConcurrently := ctx.Opt_concurrently() != nil && ctx.Opt_concurrently().CONCURRENTLY() != nil-- if !hasConcurrently {- // Check if the index is being created on a newly created table- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- tableName := extractTableName(ctx.Relation_expr().Qualified_name())- // Skip the check if the table is newly created+ case *ast.IndexStmt:+ if !n.Concurrent {+ tableName := omniTableName(n.Relation)if r.newlyCreatedTables[tableName] {return}+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.CreateIndexUnconcurrently.Int32(),+ Title: r.Title,+ Content: "Creating indexes will block writes on the table, unless use CONCURRENTLY",+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}-- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.CreateIndexUnconcurrently.Int32(),- Title: r.title,- Content: "Creating indexes will block writes on the table, unless use CONCURRENTLY",- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- }-}--// handleDropstmt checks DROP INDEX statements-func (r *indexCreateConcurrentlyRule) handleDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is a DROP INDEX statement- if ctx.INDEX() != nil {- // Check if CONCURRENTLY is used- if ctx.CONCURRENTLY() == nil {+ case *ast.DropStmt:+ if n.RemoveType == int(ast.OBJECT_INDEX) && !n.Concurrent {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.DropIndexUnconcurrently.Int32(),- Title: r.title,+ Title: r.Title,Content: "Droping indexes will block writes on the table, unless use CONCURRENTLY",StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}+ default:}}diff --git a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go b/backend/plugin/advisor/pg/advisor_index_key_number_limit.goindex 2f8cbc3a0b..551458e63c 100644--- a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go@@ -6,16 +6,11 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -43,33 +38,18 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Con}rule := &indexKeyNumberLimitRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},max: int(numberPayload.Number),}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexKeyNumberLimitRule struct {- BaseRule+ OmniBaseRulemax int}@@ -78,190 +58,75 @@ func (*indexKeyNumberLimitRule) Name() string {return "index_key_number_limit"}-func (r *indexKeyNumberLimitRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Indexstmt":- r.handleIndexstmt(ctx)- case "Createstmt":- r.handleCreatestmt(ctx)- case "Altertablestmt":- r.handleAltertablestmt(ctx)+func (r *indexKeyNumberLimitRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.IndexStmt:+ r.handleIndexStmt(n)+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*indexKeyNumberLimitRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-// handleIndexstmt checks CREATE INDEX statements-func (r *indexKeyNumberLimitRule) handleIndexstmt(ctx antlr.ParserRuleContext) {- indexstmtCtx, ok := ctx.(*parser.IndexstmtContext)- if !ok {- return- }-- if !isTopLevel(indexstmtCtx.GetParent()) {- return- }-- // Count the number of index parameters- if indexstmtCtx.Index_params() != nil {- keyCount := r.countIndexKeys(indexstmtCtx.Index_params())- if r.max > 0 && keyCount > r.max {- indexName := ""- if indexstmtCtx.Name() != nil {- indexName = pg.NormalizePostgreSQLName(indexstmtCtx.Name())- }-- tableName := ""- if indexstmtCtx.Relation_expr() != nil && indexstmtCtx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(indexstmtCtx.Relation_expr().Qualified_name())- }-- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.IndexKeyNumberExceedsLimit.Int32(),- Title: r.title,- Content: fmt.Sprintf("The number of keys of index %q in table %q should be not greater than %d", indexName, tableName, r.max),- StartPosition: &storepb.Position{- Line: int32(indexstmtCtx.GetStart().GetLine()),- Column: 0,- },- })- }+func (r *indexKeyNumberLimitRule) handleIndexStmt(n *ast.IndexStmt) {+ keyCount := len(omniIndexColumns(n))+ if r.max > 0 && keyCount > r.max {+ indexName := n.Idxname+ tableName := omniTableName(n.Relation)+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.IndexKeyNumberExceedsLimit.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("The number of keys of index %q in table %q should be not greater than %d", indexName, tableName, r.max),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}}-// handleCreatestmt checks CREATE TABLE with inline constraints-func (r *indexKeyNumberLimitRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createstmtCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }-- if !isTopLevel(createstmtCtx.GetParent()) {- return- }-- qualifiedNames := createstmtCtx.AllQualified_name()- if len(qualifiedNames) == 0 {- return- }-- tableName := extractTableName(qualifiedNames[0])- if tableName == "" {- return- }-- // Check table-level constraints- if createstmtCtx.Opttableelementlist() != nil && createstmtCtx.Opttableelementlist().Tableelementlist() != nil {- allElements := createstmtCtx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.Tablelikeclause() != nil {- continue- }- if elem.Tableconstraint() != nil {- r.checkTableConstraint(elem.Tableconstraint(), tableName, createstmtCtx.GetStart().GetLine())- }- }+func (r *indexKeyNumberLimitRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ _, constraints := omniTableElements(n)+ for _, c := range constraints {+ r.checkConstraint(c, tableName)}}-// handleAltertablestmt checks ALTER TABLE ADD CONSTRAINT-func (r *indexKeyNumberLimitRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- altertablestmtCtx, ok := ctx.(*parser.AltertablestmtContext)- if !ok {- return- }-- if !isTopLevel(altertablestmtCtx.GetParent()) {- return- }-- if altertablestmtCtx.Relation_expr() == nil || altertablestmtCtx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := extractTableName(altertablestmtCtx.Relation_expr().Qualified_name())- if tableName == "" {- return- }-- // Check ALTER TABLE ADD CONSTRAINT- if altertablestmtCtx.Alter_table_cmds() != nil {- allCmds := altertablestmtCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD CONSTRAINT- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- r.checkTableConstraint(cmd.Tableconstraint(), tableName, altertablestmtCtx.GetStart().GetLine())+func (r *indexKeyNumberLimitRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)+ for _, cmd := range omniAlterTableCmds(n) {+ if cmd.Subtype == int(ast.AT_AddConstraint) {+ if c, ok := cmd.Def.(*ast.Constraint); ok {+ r.checkConstraint(c, tableName)}}}}-func (r *indexKeyNumberLimitRule) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {- if constraint == nil {- return- }-+func (r *indexKeyNumberLimitRule) checkConstraint(c *ast.Constraint, tableName string) {var keyCount int- var constraintName string-- // Get constraint name if present- if constraint.Name() != nil {- constraintName = pg.NormalizePostgreSQLName(constraint.Name())- }-- // Check different constraint types- if constraint.Constraintelem() != nil {- elem := constraint.Constraintelem()-- // PRIMARY KEY or UNIQUE- if (elem.PRIMARY() != nil && elem.KEY() != nil) || (elem.UNIQUE() != nil) {- if elem.Columnlist() != nil {- keyCount = r.countColumnList(elem.Columnlist())- }- }-- // FOREIGN KEY- if elem.FOREIGN() != nil && elem.KEY() != nil {- if elem.Columnlist() != nil {- keyCount = r.countColumnList(elem.Columnlist())- }- }+ switch c.Contype {+ case ast.CONSTR_PRIMARY, ast.CONSTR_UNIQUE:+ keyCount = len(omniConstraintColumns(c))+ case ast.CONSTR_FOREIGN:+ keyCount = len(omniListStrings(c.FkAttrs))+ default:+ return}-if r.max > 0 && keyCount > r.max {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.IndexKeyNumberExceedsLimit.Int32(),- Title: r.title,- Content: fmt.Sprintf("The number of keys of index %q in table %q should be not greater than %d", constraintName, tableName, r.max),+ Title: r.Title,+ Content: fmt.Sprintf("The number of keys of index %q in table %q should be not greater than %d", c.Conname, tableName, r.max),StartPosition: &storepb.Position{- Line: int32(line),+ Line: r.ContentStartLine(),Column: 0,},})}}--func (*indexKeyNumberLimitRule) countIndexKeys(params parser.IIndex_paramsContext) int {- if params == nil {- return 0- }-- allParams := params.AllIndex_elem()- return len(allParams)-}--func (*indexKeyNumberLimitRule) countColumnList(columnList parser.IColumnlistContext) int {- if columnList == nil {- return 0- }-- allColumns := columnList.AllColumnElem()- return len(allColumns)-}diff --git a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.goindex 6255196991..4aad7e79be 100644--- a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go+++ b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go@@ -4,16 +4,11 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -36,225 +31,98 @@ func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.}rule := &indexNoDuplicateColumnRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexNoDuplicateColumnRule struct {- BaseRule+ OmniBaseRule}func (*indexNoDuplicateColumnRule) Name() string {return "index_no_duplicate_column"}-func (r *indexNoDuplicateColumnRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Indexstmt":- r.handleIndexstmt(ctx)- case "Createstmt":- r.handleCreatestmt(ctx)- case "Altertablestmt":- r.handleAltertablestmt(ctx)+func (r *indexNoDuplicateColumnRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.IndexStmt:+ r.handleIndexStmt(n)+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil}-func (*indexNoDuplicateColumnRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *indexNoDuplicateColumnRule) handleIndexstmt(ctx antlr.ParserRuleContext) {- indexCtx, ok := ctx.(*parser.IndexstmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get index name- indexName := ""- if indexCtx.Name() != nil {- indexName = pg.NormalizePostgreSQLName(indexCtx.Name())- }-- // Get table name- tableName := ""- if indexCtx.Relation_expr() != nil && indexCtx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(indexCtx.Relation_expr().Qualified_name())- }-- // Check for duplicate columns in index parameters- if indexCtx.Index_params() != nil {- columns := r.extractIndexColumns(indexCtx.Index_params())- if dupCol := findDuplicate(columns); dupCol != "" {- r.addAdvice("INDEX", indexName, tableName, dupCol, indexCtx.GetStart().GetLine())- }+func (r *indexNoDuplicateColumnRule) handleIndexStmt(n *ast.IndexStmt) {+ indexName := n.Idxname+ tableName := omniTableName(n.Relation)+ columns := omniIndexColumns(n)+ if dupCol := findDuplicate(columns); dupCol != "" {+ r.addDuplicateAdvice("INDEX", indexName, tableName, dupCol, r.ContentStartLine())}}-func (r *indexNoDuplicateColumnRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- qualifiedNames := createCtx.AllQualified_name()- if len(qualifiedNames) == 0 {- return- }-- tableName := extractTableName(qualifiedNames[0])- if tableName == "" {- return- }-- // Check table-level constraints- if createCtx.Opttableelementlist() != nil && createCtx.Opttableelementlist().Tableelementlist() != nil {- allElements := createCtx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.Tableconstraint() != nil {- r.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())- }- }+func (r *indexNoDuplicateColumnRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ _, constraints := omniTableElements(n)+ for _, c := range constraints {+ r.checkConstraint(c, tableName)}}-func (r *indexNoDuplicateColumnRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- alterCtx, ok := ctx.(*parser.AltertablestmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- if alterCtx.Relation_expr() == nil || alterCtx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := extractTableName(alterCtx.Relation_expr().Qualified_name())- if tableName == "" {- return- }-- // Check ALTER TABLE ADD CONSTRAINT- if alterCtx.Alter_table_cmds() != nil {- allCmds := alterCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD CONSTRAINT- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- r.checkTableConstraint(cmd.Tableconstraint(), tableName, alterCtx.GetStart().GetLine())+func (r *indexNoDuplicateColumnRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)+ for _, cmd := range omniAlterTableCmds(n) {+ if cmd.Subtype == int(ast.AT_AddConstraint) {+ if c, ok := cmd.Def.(*ast.Constraint); ok {+ r.checkConstraint(c, tableName)}}}}-func (r *indexNoDuplicateColumnRule) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {- if constraint == nil {+func (r *indexNoDuplicateColumnRule) checkConstraint(c *ast.Constraint, tableName string) {+ var columns []string+ var constraintType, keyword string+ switch c.Contype {+ case ast.CONSTR_PRIMARY:+ constraintType = "PRIMARY KEY"+ keyword = "PRIMARY KEY"+ columns = omniConstraintColumns(c)+ case ast.CONSTR_UNIQUE:+ constraintType = "UNIQUE KEY"+ keyword = "UNIQUE"+ columns = omniConstraintColumns(c)+ case ast.CONSTR_FOREIGN:+ constraintType = "FOREIGN KEY"+ keyword = "FOREIGN KEY"+ columns = omniListStrings(c.FkAttrs)+ default:return}-- // Get constraint name- constraintName := ""- if constraint.Name() != nil {- constraintName = pg.NormalizePostgreSQLName(constraint.Name())- }-- // Check different constraint types- if constraint.Constraintelem() != nil {- elem := constraint.Constraintelem()-- // PRIMARY KEY- if elem.PRIMARY() != nil && elem.KEY() != nil {- if elem.Columnlist() != nil {- columns := r.extractColumnList(elem.Columnlist())- if dupCol := findDuplicate(columns); dupCol != "" {- r.addAdvice("PRIMARY KEY", constraintName, tableName, dupCol, line)- }- }- }-- // UNIQUE- if elem.UNIQUE() != nil {- if elem.Columnlist() != nil {- columns := r.extractColumnList(elem.Columnlist())- if dupCol := findDuplicate(columns); dupCol != "" {- r.addAdvice("UNIQUE KEY", constraintName, tableName, dupCol, line)- }- }- }-- // FOREIGN KEY- if elem.FOREIGN() != nil && elem.KEY() != nil {- if elem.Columnlist() != nil {- columns := r.extractColumnList(elem.Columnlist())- if dupCol := findDuplicate(columns); dupCol != "" {- r.addAdvice("FOREIGN KEY", constraintName, tableName, dupCol, line)- }- }- }- }-}--func (*indexNoDuplicateColumnRule) extractIndexColumns(params parser.IIndex_paramsContext) []string {- if params == nil {- return nil+ if dupCol := findDuplicate(columns); dupCol != "" {+ r.addDuplicateAdvice(constraintType, c.Conname, tableName, dupCol, r.FindLineByName(keyword))}-- var columns []string- allParams := params.AllIndex_elem()- for _, param := range allParams {- if param.Colid() != nil {- colName := pg.NormalizePostgreSQLColid(param.Colid())- columns = append(columns, colName)- }- }-- return columns}-func (*indexNoDuplicateColumnRule) extractColumnList(columnList parser.IColumnlistContext) []string {- if columnList == nil {- return nil- }-- var columns []string- allColumns := columnList.AllColumnElem()- for _, col := range allColumns {- if col.Colid() != nil {- colName := pg.NormalizePostgreSQLColid(col.Colid())- columns = append(columns, colName)- }- }-- return columns+func (r *indexNoDuplicateColumnRule) addDuplicateAdvice(constraintType, constraintName, tableName, duplicateColumn string, line int32) {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.DuplicateColumnInIndex.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("%s %q has duplicate column %q.%q", constraintType, constraintName, tableName, duplicateColumn),+ StartPosition: &storepb.Position{+ Line: line,+ Column: 0,+ },+ })}func findDuplicate(columns []string) string {@@ -267,16 +135,3 @@ func findDuplicate(columns []string) string {}return ""}--func (r *indexNoDuplicateColumnRule) addAdvice(constraintType, constraintName, tableName, duplicateColumn string, line int) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.DuplicateColumnInIndex.Int32(),- Title: r.title,- Content: fmt.Sprintf("%s %q has duplicate column %q.%q", constraintType, constraintName, tableName, duplicateColumn),- StartPosition: &storepb.Position{- Line: int32(line),- Column: 0,- },- })-}diff --git a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.goindex deb1ac3495..a4e9e6bb17 100644--- a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go@@ -4,16 +4,11 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -38,30 +33,18 @@ func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx adstringArrayPayload := checkCtx.Rule.GetStringArrayPayload()rule := &indexPrimaryKeyTypeAllowlistRule{- BaseRule: BaseRule{level: level, title: checkCtx.Rule.Type.String()},+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },allowlist: stringArrayPayload.List,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexPrimaryKeyTypeAllowlistRule struct {- BaseRule+ OmniBaseRuleallowlist []string}@@ -70,128 +53,56 @@ func (*indexPrimaryKeyTypeAllowlistRule) Name() string {return "index_primary_key_type_allowlist"}-func (r *indexPrimaryKeyTypeAllowlistRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))+func (r *indexPrimaryKeyTypeAllowlistRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)default:- // Do nothing for other node types}- return nil}-func (*indexPrimaryKeyTypeAllowlistRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}+func (r *indexPrimaryKeyTypeAllowlistRule) handleCreateStmt(n *ast.CreateStmt) {+ cols, constraints := omniTableElements(n)-// handleCreatestmt checks CREATE TABLE with inline PRIMARY KEY constraints-func (r *indexPrimaryKeyTypeAllowlistRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Build maps of column name to column type and line number+ // Build column name -> type mappingcolumnTypes := make(map[string]string)- columnLines := make(map[string]int)-- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.ColumnDef() != nil {- colDef := elem.ColumnDef()- if colDef.Colid() != nil && colDef.Typename() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- columnType := r.getTypeName(colDef.Typename())- columnTypes[columnName] = columnType- columnLines[columnName] = colDef.GetStart().GetLine()-- // Check if this column has PRIMARY KEY constraint- if r.hasColumnPrimaryKeyConstraint(colDef) {- if !r.isTypeAllowed(columnType) {- r.addAdvice(columnName, columnType, colDef.GetStart().GetLine())- }- }+ for _, col := range cols {+ typeName := normalizePostgreSQLType(omniTypeNameFull(col.TypeName))+ columnTypes[col.Colname] = typeName++ // Check column-level PRIMARY KEY constraint+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_PRIMARY {+ if !isTypeInList(typeName, r.allowlist) {+ r.addTypeAdvice(col.Colname, typeName, r.FindLineByName(col.Colname))}}}-- // Check table-level PRIMARY KEY constraints- for _, elem := range allElements {- if elem.Tableconstraint() != nil {- r.checkTablePrimaryKey(elem.Tableconstraint(), columnTypes, columnLines)- }- }- }-}--func (*indexPrimaryKeyTypeAllowlistRule) hasColumnPrimaryKeyConstraint(colDef parser.IColumnDefContext) bool {- if colDef.Colquallist() == nil {- return false}- allConstraints := colDef.Colquallist().AllColconstraint()- for _, constraint := range allConstraints {- if constraint.Colconstraintelem() != nil {- elem := constraint.Colconstraintelem()- if elem.PRIMARY() != nil && elem.KEY() != nil {- return true- }+ // Check table-level PRIMARY KEY constraints+ for _, c := range constraints {+ if c.Contype != ast.CONSTR_PRIMARY {+ continue}- }-- return false-}--func (r *indexPrimaryKeyTypeAllowlistRule) checkTablePrimaryKey(constraint parser.ITableconstraintContext, columnTypes map[string]string, columnLines map[string]int) {- if constraint == nil || constraint.Constraintelem() == nil {- return- }-- elem := constraint.Constraintelem()-- // Check if this is a PRIMARY KEY constraint- if elem.PRIMARY() != nil && elem.KEY() != nil {- if elem.Columnlist() != nil {- // Get all columns in the PRIMARY KEY- allColumns := elem.Columnlist().AllColumnElem()- for _, col := range allColumns {- if col.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(col.Colid())- if columnType, exists := columnTypes[columnName]; exists {- if !r.isTypeAllowed(columnType) {- // Use the column definition's line, not the constraint's line- line := columnLines[columnName]- r.addAdvice(columnName, columnType, line)- }- }+ for _, colName := range omniConstraintColumns(c) {+ if colType, ok := columnTypes[colName]; ok {+ if !isTypeInList(colType, r.allowlist) {+ r.addTypeAdvice(colName, colType, r.FindLineByName(colName))}}}}}-func (*indexPrimaryKeyTypeAllowlistRule) getTypeName(typename parser.ITypenameContext) string {- if typename == nil {- return ""- }-- // Get the type text and normalize it- return normalizePostgreSQLType(typename.GetText())-}--func (r *indexPrimaryKeyTypeAllowlistRule) isTypeAllowed(columnType string) bool {- // Check if the column type is equivalent to any type in the allowlist- return isTypeInList(columnType, r.allowlist)-}--func (r *indexPrimaryKeyTypeAllowlistRule) addAdvice(columnName, columnType string, line int) {+func (r *indexPrimaryKeyTypeAllowlistRule) addTypeAdvice(columnName, columnType string, line int32) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.IndexPKType.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("The column %q is one of the primary key, but its type %q is not in allowlist", columnName, columnType),StartPosition: &storepb.Position{- Line: int32(line),+ Line: line,Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go b/backend/plugin/advisor/pg/advisor_index_total_number_limit.goindex f0e5dbc452..c97b6e55b7 100644--- a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go@@ -7,15 +7,12 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -42,30 +39,26 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Creturn nil, errors.New("number_payload is required for this rule")}- rule := &indexTotalNumberLimitRule{- BaseRule: BaseRule{level: level, title: checkCtx.Rule.Type.String()},- max: int(numberPayload.Number),- finalMetadata: checkCtx.FinalMetadata,- tableLine: make(tableLineMap),- }-- checker := NewGenericChecker([]Rule{rule})+ maxCount := int(numberPayload.Number)+ finalMetadata := checkCtx.FinalMetadata+ tableLine := make(tableLineMap)for _, stmt := range checkCtx.ParsedStatements {if stmt.AST == nil {continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)+ node, ok := pgparser.GetOmniNode(stmt.AST)if !ok {continue}- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)+ baseLine := stmt.BaseLine()+ stmtText := stmt.Text+ handleIndexTotalStmt(node, baseLine, stmtText, tableLine)}- rule.generateAdvice()- return checker.GetAdviceList(), nil+ var adviceList []*storepb.Advice+ generateIndexTotalAdvice(tableLine, finalMetadata, maxCount, level, checkCtx.Rule.Type.String(), &adviceList)+ return adviceList, nil}type tableLine struct {@@ -87,39 +80,91 @@ func (m tableLineMap) set(schema string, table string, line int) {}}-type indexTotalNumberLimitRule struct {- BaseRule+func handleIndexTotalStmt(node ast.Node, baseLine int, stmtText string, tl tableLineMap) {+ // Helper to compute absolute end line (matching ANTLR GetStop().GetLine() behavior).+ absEndLine := func() int {+ endLine := int32(1)+ if stmtText != "" {+ for i := len(stmtText) - 1; i >= 0; i-- {+ c := stmtText[i]+ if c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != ';' {+ pos := pgparser.ByteOffsetToRunePosition(stmtText, i)+ endLine = pos.Line+ break+ }+ }+ }+ return baseLine + int(endLine)+ }- max int- finalMetadata *model.DatabaseMetadata- tableLine tableLineMap-}+ switch n := node.(type) {+ case *ast.CreateStmt:+ tableName := omniTableName(n.Relation)+ if tableName == "" {+ return+ }+ schemaName := omniSchemaName(n.Relation)+ cols, constraints := omniTableElements(n)+ // Check column-level constraints+ for _, col := range cols {+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_PRIMARY || c.Contype == ast.CONSTR_UNIQUE {+ tl.set(schemaName, tableName, absEndLine())+ return+ }+ }+ }+ // Check table-level constraints+ for _, c := range constraints {+ if c.Contype == ast.CONSTR_PRIMARY || c.Contype == ast.CONSTR_UNIQUE {+ tl.set(schemaName, tableName, absEndLine())+ return+ }+ }-func (*indexTotalNumberLimitRule) Name() string {- return "index_total_number_limit"-}+ case *ast.AlterTableStmt:+ tableName := omniTableName(n.Relation)+ if tableName == "" {+ return+ }+ schemaName := omniSchemaName(n.Relation)+ for _, cmd := range omniAlterTableCmds(n) {+ // ADD COLUMN with PK/UNIQUE constraint+ if cmd.Subtype == int(ast.AT_AddColumn) {+ if colDef, ok := cmd.Def.(*ast.ColumnDef); ok {+ for _, c := range omniColumnConstraints(colDef) {+ if c.Contype == ast.CONSTR_PRIMARY || c.Contype == ast.CONSTR_UNIQUE {+ tl.set(schemaName, tableName, absEndLine())+ return+ }+ }+ }+ }+ // ADD CONSTRAINT (PK or UNIQUE)+ if cmd.Subtype == int(ast.AT_AddConstraint) {+ if c, ok := cmd.Def.(*ast.Constraint); ok {+ if c.Contype == ast.CONSTR_PRIMARY || c.Contype == ast.CONSTR_UNIQUE {+ tl.set(schemaName, tableName, absEndLine())+ return+ }+ }+ }+ }-func (r *indexTotalNumberLimitRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- case "Indexstmt":- r.handleIndexstmt(ctx.(*parser.IndexstmtContext))+ case *ast.IndexStmt:+ tableName := omniTableName(n.Relation)+ if tableName == "" {+ return+ }+ schemaName := omniSchemaName(n.Relation)+ tl.set(schemaName, tableName, absEndLine())default:- // Do nothing for other node types}- return nil-}--func (*indexTotalNumberLimitRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-func (r *indexTotalNumberLimitRule) generateAdvice() {+func generateIndexTotalAdvice(tl tableLineMap, finalMetadata *model.DatabaseMetadata, maxCount int, level storepb.Advice_Status, title string, adviceList *[]*storepb.Advice) {var tableList []tableLine- for _, table := range r.tableLine {+ for _, table := range tl {tableList = append(tableList, table)}slices.SortFunc(tableList, func(i, j tableLine) int {@@ -133,7 +178,7 @@ func (r *indexTotalNumberLimitRule) generateAdvice() {})for _, table := range tableList {- schema := r.finalMetadata.GetSchemaMetadata(table.schema)+ schema := finalMetadata.GetSchemaMetadata(table.schema)if schema == nil {continue}@@ -141,15 +186,12 @@ func (r *indexTotalNumberLimitRule) generateAdvice() {if tableInfo == nil {continue}- if len(tableInfo.GetProto().Indexes) > r.max {- // Directly append to adviceList instead of using AddAdvice because- // table.line already stores absolute line numbers (baseLine + line at time of encounter).- // Using AddAdvice would incorrectly add the current baseLine again.- r.adviceList = append(r.adviceList, &storepb.Advice{- Status: r.level,+ if len(tableInfo.GetProto().Indexes) > maxCount {+ *adviceList = append(*adviceList, &storepb.Advice{+ Status: level,Code: code.IndexCountExceedsLimit.Int32(),- Title: r.title,- Content: fmt.Sprintf("The count of index in table %q.%q should be no more than %d, but found %d", table.schema, table.table, r.max, len(tableInfo.GetProto().Indexes)),+ Title: title,+ Content: fmt.Sprintf("The count of index in table %q.%q should be no more than %d, but found %d", table.schema, table.table, maxCount, len(tableInfo.GetProto().Indexes)),StartPosition: &storepb.Position{Line: int32(table.line),Column: 0,@@ -158,144 +200,3 @@ func (r *indexTotalNumberLimitRule) generateAdvice() {}}}--func (r *indexTotalNumberLimitRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- qualifiedNames := ctx.AllQualified_name()- if len(qualifiedNames) == 0 {- return- }-- tableName := extractTableName(qualifiedNames[0])- if tableName == "" {- return- }-- schemaName := extractSchemaName(qualifiedNames[0])-- // Check if this CREATE TABLE statement creates any indexes- // (PRIMARY KEY or UNIQUE constraints)- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- // Check column-level constraints- if elem.ColumnDef() != nil {- if hasIndexConstraint(elem.ColumnDef()) {- r.tableLine.set(schemaName, tableName, r.baseLine+ctx.GetStop().GetLine())- return- }- }-- // Check table-level constraints- if elem.Tableconstraint() != nil && hasTableIndexConstraint(elem.Tableconstraint()) {- r.tableLine.set(schemaName, tableName, r.baseLine+ctx.GetStop().GetLine())- return- }- }- }-}--func (r *indexTotalNumberLimitRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := extractTableName(ctx.Relation_expr().Qualified_name())- if tableName == "" {- return- }-- schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())-- // Check ALTER TABLE commands that create indexes- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD COLUMN with PRIMARY KEY or UNIQUE- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- if hasIndexConstraint(cmd.ColumnDef()) {- r.tableLine.set(schemaName, tableName, r.baseLine+ctx.GetStop().GetLine())- return- }- }-- // ADD CONSTRAINT (PRIMARY KEY or UNIQUE)- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- if hasTableIndexConstraint(cmd.Tableconstraint()) {- r.tableLine.set(schemaName, tableName, r.baseLine+ctx.GetStop().GetLine())- return- }- }- }- }-}--func (r *indexTotalNumberLimitRule) handleIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- tableName := extractTableName(ctx.Relation_expr().Qualified_name())- if tableName == "" {- return- }-- schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())- r.tableLine.set(schemaName, tableName, r.baseLine+ctx.GetStop().GetLine())-}--// hasIndexConstraint checks if a column definition has PRIMARY KEY or UNIQUE constraint-func hasIndexConstraint(colDef parser.IColumnDefContext) bool {- if colDef.Colquallist() == nil {- return false- }-- allConstraints := colDef.Colquallist().AllColconstraint()- for _, constraint := range allConstraints {- if constraint.Colconstraintelem() != nil {- elem := constraint.Colconstraintelem()- // PRIMARY KEY creates an index- if elem.PRIMARY() != nil && elem.KEY() != nil {- return true- }- // UNIQUE creates an index- if elem.UNIQUE() != nil {- return true- }- }- }-- return false-}--// hasTableIndexConstraint checks if a table constraint is PRIMARY KEY or UNIQUE-func hasTableIndexConstraint(constraint parser.ITableconstraintContext) bool {- if constraint == nil || constraint.Constraintelem() == nil {- return false- }-- elem := constraint.Constraintelem()-- // PRIMARY KEY creates an index- if elem.PRIMARY() != nil && elem.KEY() != nil {- return true- }-- // UNIQUE creates an index- if elem.UNIQUE() != nil {- return true- }-- return false-}diff --git a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.goindex ee1c0c83f1..ea7f90066d 100644--- a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go+++ b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go@@ -5,14 +5,11 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -34,148 +31,80 @@ func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advisreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &insertDisallowOrderByRandRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &insertDisallowOrderByRandRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertDisallowOrderByRandRule struct {- BaseRule-- tokens *antlr.CommonTokenStream+ OmniBaseRule}func (*insertDisallowOrderByRandRule) Name() string {- return "insert_disallow_order_by_rand"+ return string(storepb.SQLReviewRule_STATEMENT_INSERT_DISALLOW_ORDER_BY_RAND)}-func (r *insertDisallowOrderByRandRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Insertstmt":- r.handleInsertstmt(ctx)- default:- // Do nothing for other node types- }- return nil-}--func (*insertDisallowOrderByRandRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *insertDisallowOrderByRandRule) handleInsertstmt(ctx antlr.ParserRuleContext) {- insertstmtCtx, ok := ctx.(*parser.InsertstmtContext)+func (r *insertDisallowOrderByRandRule) OnStatement(node ast.Node) {+ ins, ok := node.(*ast.InsertStmt)if !ok {return}- if !isTopLevel(insertstmtCtx.GetParent()) {+ sel, ok := ins.SelectStmt.(*ast.SelectStmt)+ if !ok || sel == nil {return}- // Check if this is INSERT...SELECT- if insertstmtCtx.Insert_rest() == nil || insertstmtCtx.Insert_rest().Selectstmt() == nil {- return- }-- // Check for ORDER BY random() in the SELECT statement- if r.hasOrderByRandom(insertstmtCtx.Insert_rest().Selectstmt()) {+ if r.hasOrderByRandom(sel) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.InsertUseOrderByRand.Int32(),- Title: r.title,- Content: fmt.Sprintf("The INSERT statement uses ORDER BY random() or random_between(), related statement \"%s\"", getTextFromTokens(r.tokens, insertstmtCtx)),+ Title: r.Title,+ Content: fmt.Sprintf("The INSERT statement uses ORDER BY random() or random_between(), related statement \"%s\"", r.TrimmedStmtText()),StartPosition: &storepb.Position{- Line: int32(insertstmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}-// hasOrderByRandom checks if a SELECT statement has ORDER BY random() or random_between()-func (*insertDisallowOrderByRandRule) hasOrderByRandom(selectCtx parser.ISelectstmtContext) bool {- if selectCtx == nil {+func (r *insertDisallowOrderByRandRule) hasOrderByRandom(sel *ast.SelectStmt) bool {+ if sel == nil {return false}- // Check both Select_no_parens and Select_with_parens- if selectCtx.Select_no_parens() != nil {- if hasOrderByRandomInSelect(selectCtx.Select_no_parens()) {- return true- }- }-- if selectCtx.Select_with_parens() != nil {- // Select_with_parens might contain another Selectstmt- // We need to recursively check- return hasOrderByRandomInParens(selectCtx.Select_with_parens())+ // For set operations, recurse into children.+ if sel.Op != ast.SETOP_NONE {+ return r.hasOrderByRandom(sel.Larg) || r.hasOrderByRandom(sel.Rarg)}- return false-}--// hasOrderByRandomInSelect checks Select_no_parens for ORDER BY random()-func hasOrderByRandomInSelect(selectCtx parser.ISelect_no_parensContext) bool {- if selectCtx == nil {+ if sel.SortClause == nil {return false}- // Check Opt_sort_clause (ORDER BY clause)- if selectCtx.Opt_sort_clause() != nil && selectCtx.Opt_sort_clause().Sort_clause() != nil {- sortClause := selectCtx.Opt_sort_clause().Sort_clause()- // Get all sort by items via Sortby_list- if sortClause.Sortby_list() != nil {- allSortBy := sortClause.Sortby_list().AllSortby()- for _, sortBy := range allSortBy {- if sortBy.A_expr() != nil {- text := strings.ToLower(sortBy.A_expr().GetText())- if strings.Contains(text, "random()") || strings.Contains(text, "random_between()") {- return true- }- }+ for _, item := range sel.SortClause.Items {+ sb, ok := item.(*ast.SortBy)+ if !ok {+ continue+ }+ fc, ok := sb.Node.(*ast.FuncCall)+ if !ok {+ continue+ }+ funcName := omniListStrings(fc.Funcname)+ for _, name := range funcName {+ lower := strings.ToLower(name)+ if lower == "random" || lower == "random_between" {+ return true}}}return false}--// hasOrderByRandomInParens checks Select_with_parens recursively-func hasOrderByRandomInParens(selectCtx parser.ISelect_with_parensContext) bool {- if selectCtx == nil {- return false- }-- // Select_with_parens can contain Select_no_parens or another Select_with_parens- if selectCtx.Select_no_parens() != nil {- return hasOrderByRandomInSelect(selectCtx.Select_no_parens())- }-- if selectCtx.Select_with_parens() != nil {- return hasOrderByRandomInParens(selectCtx.Select_with_parens())- }-- return false-}diff --git a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.goindex d03f007235..573a31455b 100644--- a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go+++ b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go@@ -4,14 +4,11 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -33,84 +30,38 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisorreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &insertMustSpecifyColumnRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &insertMustSpecifyColumnRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertMustSpecifyColumnRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRule}func (*insertMustSpecifyColumnRule) Name() string {- return "insert_must_specify_column"-}--func (r *insertMustSpecifyColumnRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Insertstmt":- r.handleInsertstmt(ctx)- default:- // Do nothing for other node types- }- return nil-}--func (*insertMustSpecifyColumnRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil+ return string(storepb.SQLReviewRule_STATEMENT_INSERT_MUST_SPECIFY_COLUMN)}-func (r *insertMustSpecifyColumnRule) handleInsertstmt(ctx antlr.ParserRuleContext) {- insertstmtCtx, ok := ctx.(*parser.InsertstmtContext)+func (r *insertMustSpecifyColumnRule) OnStatement(node ast.Node) {+ ins, ok := node.(*ast.InsertStmt)if !ok {return}- if !isTopLevel(insertstmtCtx.GetParent()) {- return- }-- // Check if column list is specified- // In PostgreSQL, INSERT has an optional insert_column_list- // If insert_column_list is not specified or empty, we should report it- if insertstmtCtx.Insert_rest() == nil {- return- }-- // Check if there's an insert_column_list- // Insert_column_list exists, which means columns are specified- hasColumnList := insertstmtCtx.Insert_rest().Insert_column_list() != nil-- if !hasColumnList {+ if ins.Cols == nil || len(ins.Cols.Items) == 0 {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.InsertNotSpecifyColumn.Int32(),- Title: r.title,- Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", getTextFromTokens(r.tokens, insertstmtCtx)),+ Title: r.Title,+ Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", r.TrimmedStmtText()),StartPosition: &storepb.Position{- Line: int32(insertstmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_insert_row_limit.go b/backend/plugin/advisor/pg/advisor_insert_row_limit.goindex 67f6167ed9..ceb0dccbae 100644--- a/backend/plugin/advisor/pg/advisor_insert_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_insert_row_limit.go@@ -4,18 +4,15 @@ import ("context""database/sql""fmt"- "regexp"- "strconv"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql""github.com/pkg/errors"+ "github.com/bytebase/omni/pg/ast"+"github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"- "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -45,292 +42,116 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contexreturn nil, nil}- var adviceList []*storepb.Advice- var preExecutions []string- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &insertRowLimitRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- maxRow: int(numberPayload.Number),- driver: checkCtx.Driver,- ctx: ctx,- tokens: antlrAST.Tokens,- preExecutions: preExecutions,- TenantMode: checkCtx.TenantMode,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)- preExecutions = rule.preExecutions+ rule := &insertRowLimitRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },+ maxRow: int(numberPayload.Number),+ driver: checkCtx.Driver,+ ctx: ctx,+ TenantMode: checkCtx.TenantMode,}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertRowLimitRule struct {- BaseRule+ OmniBaseRulemaxRow intdriver *sql.DBctx context.Context- tokens *antlr.CommonTokenStreamexplainCount intpreExecutions []stringTenantMode bool}func (*insertRowLimitRule) Name() string {- return "insert_row_limit"+ return string(storepb.SQLReviewRule_STATEMENT_INSERT_ROW_LIMIT)}-func (r *insertRowLimitRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Variablesetstmt":- if c, ok := ctx.(*parser.VariablesetstmtContext); ok {- r.handleVariablesetstmt(c)- }- case "Insertstmt":- if c, ok := ctx.(*parser.InsertstmtContext); ok {- r.handleInsertstmt(c)+func (r *insertRowLimitRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.VariableSetStmt:+ if omniIsRoleOrSearchPathSet(n) {+ r.preExecutions = append(r.preExecutions, r.TrimmedStmtText())}+ case *ast.InsertStmt:+ r.checkInsert(n)default:- // Do nothing for other node types- }- return nil-}--func (*insertRowLimitRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *insertRowLimitRule) handleVariablesetstmt(ctx *parser.VariablesetstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return}-- r.preExecutions = appendSessionPreExecutionStatements(r.preExecutions, r.tokens, ctx)}-func (r *insertRowLimitRule) handleInsertstmt(ctx *parser.InsertstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-+func (r *insertRowLimitRule) checkInsert(ins *ast.InsertStmt) {code := advisorcode.Okrows := int64(0)- statementText := getTextFromTokens(r.tokens, ctx)-- // Check if this is INSERT ... VALUES or INSERT ... SELECT- if ctx.Insert_rest() != nil && ctx.Insert_rest().Selectstmt() != nil {- // Count the number of value lists if this is VALUES- rowCount := countValueLists(ctx.Insert_rest().Selectstmt())- if rowCount > 0 {- // This is INSERT ... VALUES- if rowCount > r.maxRow {- code = advisorcode.InsertTooManyRows- rows = int64(rowCount)- }- } else if r.driver != nil {- // For INSERT ... SELECT, use EXPLAIN- if r.explainCount >= common.MaximumLintExplainSize {- return- }- r.explainCount++-- res, err := advisor.Query(r.ctx, advisor.QueryContext{- TenantMode: r.TenantMode,- PreExecutions: r.preExecutions,- }, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", statementText))-- if err != nil {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: advisorcode.InsertTooManyRows.Int32(),- Title: r.title,- Content: fmt.Sprintf("\"%s\" dry runs failed: %s", statementText, err.Error()),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- return- }+ statementText := r.TrimmedStmtText()++ // Count VALUES rows if this is INSERT ... VALUES.+ if sel, ok := ins.SelectStmt.(*ast.SelectStmt); ok && sel.ValuesLists != nil {+ rowCount := len(sel.ValuesLists.Items)+ if rowCount > r.maxRow {+ code = advisorcode.InsertTooManyRows+ rows = int64(rowCount)+ }+ } else if ins.SelectStmt != nil && r.driver != nil {+ // For INSERT ... SELECT, use EXPLAIN.+ if r.explainCount >= common.MaximumLintExplainSize {+ return+ }+ r.explainCount++++ res, err := advisor.Query(r.ctx, advisor.QueryContext{+ TenantMode: r.TenantMode,+ PreExecutions: r.preExecutions,+ }, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", statementText))++ if err != nil {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: advisorcode.InsertTooManyRows.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("\"%s\" dry runs failed: %s", statementText, err.Error()),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+ return+ }- rowCount, err := getAffectedRows(res)- if err != nil {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: advisorcode.Internal.Int32(),- Title: r.title,- Content: fmt.Sprintf("failed to get row count for \"%s\": %s", statementText, err.Error()),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- return- }+ rowCount, err := getAffectedRows(res)+ if err != nil {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: advisorcode.Internal.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("failed to get row count for \"%s\": %s", statementText, err.Error()),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+ return+ }- if rowCount > int64(r.maxRow) {- code = advisorcode.InsertTooManyRows- rows = rowCount- }+ if rowCount > int64(r.maxRow) {+ code = advisorcode.InsertTooManyRows+ rows = rowCount}}if code != advisorcode.Ok {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("The statement \"%s\" inserts %d rows. The count exceeds %d.", statementText, rows, r.maxRow),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}--// countValueLists counts the number of value lists in an INSERT ... VALUES statement-// Returns 0 if this is not a VALUES statement (e.g., INSERT ... SELECT)-func countValueLists(selectStmt parser.ISelectstmtContext) int {- if selectStmt == nil {- return 0- }-- // Navigate to the values_clause- // SELECT can be select_no_parens or select_with_parens- if selectStmt.Select_no_parens() != nil {- return countValuesInSelectNoParens(selectStmt.Select_no_parens())- }-- if selectStmt.Select_with_parens() != nil {- return countValuesInSelectWithParens(selectStmt.Select_with_parens())- }-- return 0-}--// countValuesInSelectNoParens counts VALUES rows in a select_no_parens-func countValuesInSelectNoParens(selectCtx parser.ISelect_no_parensContext) int {- if selectCtx == nil || selectCtx.Select_clause() == nil {- return 0- }-- // Check if this is a values_clause- return countValuesInSelectClause(selectCtx.Select_clause())-}--// countValuesInSelectWithParens counts VALUES rows in a select_with_parens-func countValuesInSelectWithParens(selectCtx parser.ISelect_with_parensContext) int {- if selectCtx == nil {- return 0- }-- if selectCtx.Select_no_parens() != nil {- return countValuesInSelectNoParens(selectCtx.Select_no_parens())- }-- if selectCtx.Select_with_parens() != nil {- return countValuesInSelectWithParens(selectCtx.Select_with_parens())- }-- return 0-}--// countValuesInSelectClause counts VALUES rows in a select_clause-func countValuesInSelectClause(selectClause parser.ISelect_clauseContext) int {- if selectClause == nil {- return 0- }-- // select_clause has AllSimple_select_intersect- allIntersect := selectClause.AllSimple_select_intersect()- if len(allIntersect) == 0 {- return 0- }-- // Check the first one for values_clause- return countValuesInSimpleSelectIntersect(allIntersect[0])-}--// countValuesInSimpleSelectIntersect counts VALUES rows in simple_select_intersect-func countValuesInSimpleSelectIntersect(intersect parser.ISimple_select_intersectContext) int {- if intersect == nil {- return 0- }-- // Get all simple_select_pramary- allPrimary := intersect.AllSimple_select_pramary()- if len(allPrimary) == 0 {- return 0- }-- // Check the first one for values_clause- return countValuesInPrimary(allPrimary[0])-}--// countValuesInPrimary counts VALUES rows in simple_select_pramary-func countValuesInPrimary(primary parser.ISimple_select_pramaryContext) int {- if primary == nil || primary.Values_clause() == nil {- return 0- }-- // values_clause: VALUES (expr_list) (, (expr_list))*- // Count the number of COMMA tokens + 1- valuesClause := primary.Values_clause()- commaCount := len(valuesClause.AllCOMMA())- return commaCount + 1-}--func getAffectedRows(res []any) (int64, error) {- // the res struct is []any{columnName, columnTable, rowDataList}- if len(res) != 3 {- return 0, errors.Errorf("expected 3 but got %d", len(res))- }- rowList, ok := res[2].([]any)- if !ok {- return 0, errors.Errorf("expected []any but got %t", res[2])- }- // EXPLAIN output has at least 2 rows- if len(rowList) < 2 {- return 0, errors.Errorf("not found any data")- }- // We need row 2- rowTwo, ok := rowList[1].([]any)- if !ok {- return 0, errors.Errorf("expected []any but got %t", rowList[0])- }- // PostgreSQL EXPLAIN result has one column- if len(rowTwo) != 1 {- return 0, errors.Errorf("expected one but got %d", len(rowTwo))- }- // Get the string value- text, ok := rowTwo[0].(string)- if !ok {- return 0, errors.Errorf("expected string but got %t", rowTwo[0])- }-- rowsRegexp := regexp.MustCompile("rows=([0-9]+)")- matches := rowsRegexp.FindStringSubmatch(text)- if len(matches) != 2 {- return 0, errors.Errorf("failed to find rows in %q", text)- }- value, err := strconv.ParseInt(matches[1], 10, 64)- if err != nil {- return 0, errors.Errorf("failed to get integer from %q", matches[1])- }- return value, nil-}diff --git a/backend/plugin/advisor/pg/advisor_migration_compatibility.go b/backend/plugin/advisor/pg/advisor_migration_compatibility.goindex ca76ee56c2..82a50cacbb 100644--- a/backend/plugin/advisor/pg/advisor_migration_compatibility.go+++ b/backend/plugin/advisor/pg/advisor_migration_compatibility.go@@ -4,14 +4,11 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"- "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -33,42 +30,19 @@ func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context)return nil, err}- var adviceList []*storepb.Advice- lastCreateTable := ""-- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &compatibilityRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- lastCreateTable: lastCreateTable,- }-- checker := NewGenericChecker([]Rule{rule})- rule.SetBaseLine(stmtInfo.BaseLine())- checker.SetBaseLine(stmtInfo.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)-- adviceList = append(adviceList, checker.GetAdviceList()...)- lastCreateTable = rule.lastCreateTable+ rule := &compatibilityRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type compatibilityRule struct {- BaseRule+ OmniBaseRule- tokens *antlr.CommonTokenStreamlastCreateTable string}@@ -76,232 +50,143 @@ func (*compatibilityRule) Name() string {return "migration_compatibility"}-func (r *compatibilityRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx)- case "Dropdbstmt":- r.handleDropdbstmt(ctx)- case "Dropstmt":- r.handleDropstmt(ctx)- case "Renamestmt":- r.handleRenamestmt(ctx)- case "Altertablestmt":- r.handleAltertablestmt(ctx)- case "Indexstmt":- r.handleIndexstmt(ctx)+func (r *compatibilityRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.DropdbStmt:+ r.handleDropdbStmt()+ case *ast.DropStmt:+ r.handleDropStmt(n)+ case *ast.RenameStmt:+ r.handleRenameStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)+ case *ast.IndexStmt:+ r.handleIndexStmt(n)default:- // Do nothing for other node types}- return nil}-func (*compatibilityRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleCreatestmt tracks CREATE TABLE statements-func (r *compatibilityRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createstmtCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }-- if !isTopLevel(createstmtCtx.GetParent()) {- return- }-- qualifiedNames := createstmtCtx.AllQualified_name()- if len(qualifiedNames) > 0 {- r.lastCreateTable = extractTableName(qualifiedNames[0])+func (r *compatibilityRule) handleCreateStmt(n *ast.CreateStmt) {+ if n.Relation != nil {+ r.lastCreateTable = omniTableName(n.Relation)}}-// handleDropdbstmt handles DROP DATABASE-func (r *compatibilityRule) handleDropdbstmt(ctx antlr.ParserRuleContext) {- dropdbstmtCtx, ok := ctx.(*parser.DropdbstmtContext)- if !ok {- return- }-- if !isTopLevel(dropdbstmtCtx.GetParent()) {- return- }-+func (r *compatibilityRule) handleDropdbStmt() {+ stmtText := r.TrimmedStmtText()r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: advisorcode.CompatibilityDropDatabase.Int32(),- Title: r.title,- Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, getTextFromTokens(r.tokens, dropdbstmtCtx)),+ Title: r.Title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),StartPosition: &storepb.Position{- Line: int32(dropdbstmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}-// handleDropstmt handles DROP TABLE/MATERIALIZED VIEW-func (r *compatibilityRule) handleDropstmt(ctx antlr.ParserRuleContext) {- dropstmtCtx, ok := ctx.(*parser.DropstmtContext)- if !ok {- return- }-- if !isTopLevel(dropstmtCtx.GetParent()) {- return- }-- if dropstmtCtx.Object_type_any_name() == nil {- return- }- objType := dropstmtCtx.Object_type_any_name()-+func (r *compatibilityRule) handleDropStmt(n *ast.DropStmt) {+ removeType := ast.ObjectType(n.RemoveType)// Flag DROP TABLE and DROP MATERIALIZED VIEW (data loss risk).- // Skip non-materialized DROP VIEW — views hold no data.- isMaterializedView := objType.VIEW() != nil && objType.MATERIALIZED() != nil- if objType.TABLE() != nil || isMaterializedView {+ // Skip non-materialized DROP VIEW -- views hold no data.+ if removeType == ast.OBJECT_TABLE || removeType == ast.OBJECT_MATVIEW {+ stmtText := r.TrimmedStmtText()r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: advisorcode.CompatibilityDropTable.Int32(),- Title: r.title,- Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, getTextFromTokens(r.tokens, dropstmtCtx)),+ Title: r.Title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),StartPosition: &storepb.Position{- Line: int32(dropstmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}-// handleRenamestmt handles ALTER TABLE RENAME and RENAME COLUMN-func (r *compatibilityRule) handleRenamestmt(ctx antlr.ParserRuleContext) {- renamestmtCtx, ok := ctx.(*parser.RenamestmtContext)- if !ok {- return- }-- if !isTopLevel(renamestmtCtx.GetParent()) {- return- }-+func (r *compatibilityRule) handleRenameStmt(n *ast.RenameStmt) {code := advisorcode.Ok- // Check if this is a column rename- if renamestmtCtx.Opt_column() != nil && renamestmtCtx.Opt_column().COLUMN() != nil {+ switch n.RenameType {+ case ast.OBJECT_COLUMN:// RENAME COLUMN - check if not on last created table- if renamestmtCtx.Relation_expr() != nil && renamestmtCtx.Relation_expr().Qualified_name() != nil {- tableName := extractTableName(renamestmtCtx.Relation_expr().Qualified_name())+ if n.Relation != nil {+ tableName := omniTableName(n.Relation)if r.lastCreateTable != tableName {code = advisorcode.CompatibilityRenameColumn}}- } else {- // RENAME TABLE/VIEW+ default:+ // All non-column renames (TABLE, INDEX, CONSTRAINT, etc.) are potentially incompatible.code = advisorcode.CompatibilityRenameTable}if code != advisorcode.Ok {+ stmtText := r.TrimmedStmtText()r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Int32(),- Title: r.title,- Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, getTextFromTokens(r.tokens, renamestmtCtx)),+ Title: r.Title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),StartPosition: &storepb.Position{- Line: int32(renamestmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}-// handleAltertablestmt handles various ALTER TABLE commands-func (r *compatibilityRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- altertablestmtCtx, ok := ctx.(*parser.AltertablestmtContext)- if !ok {- return- }-- if !isTopLevel(altertablestmtCtx.GetParent()) {+func (r *compatibilityRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ if n.Relation == nil {return}-- if altertablestmtCtx.Relation_expr() == nil || altertablestmtCtx.Relation_expr().Qualified_name() == nil {- return- }- tableName := extractTableName(altertablestmtCtx.Relation_expr().Qualified_name())+ tableName := omniTableName(n.Relation)// Skip if this is the table we just createdif r.lastCreateTable == tableName {return}- if altertablestmtCtx.Alter_table_cmds() == nil {- return- }-- allCmds := altertablestmtCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {+ for _, cmd := range omniAlterTableCmds(n) {code := advisorcode.Ok- // DROP COLUMN- if cmd.DROP() != nil && cmd.COLUMN() != nil {+ switch ast.AlterTableType(cmd.Subtype) {+ case ast.AT_DropColumn:code = advisorcode.CompatibilityDropColumn- }-- // ALTER COLUMN TYPE- if cmd.ALTER() != nil && cmd.TYPE_P() != nil {+ case ast.AT_AlterColumnType:code = advisorcode.CompatibilityAlterColumn- }-- // ADD CONSTRAINT- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- constraint := cmd.Tableconstraint()- if constraint.Constraintelem() != nil {- elem := constraint.Constraintelem()-- // PRIMARY KEY- if elem.PRIMARY() != nil && elem.KEY() != nil {+ case ast.AT_AddConstraint:+ constraint, ok := cmd.Def.(*ast.Constraint)+ if ok {+ switch constraint.Contype {+ case ast.CONSTR_PRIMARY:code = advisorcode.CompatibilityAddPrimaryKey- }-- // UNIQUE- if elem.UNIQUE() != nil {+ case ast.CONSTR_UNIQUE:code = advisorcode.CompatibilityAddUniqueKey- }-- // FOREIGN KEY- if elem.FOREIGN() != nil && elem.KEY() != nil {+ case ast.CONSTR_FOREIGN:code = advisorcode.CompatibilityAddForeignKey- }-- // CHECK - only if NOT VALID is not present- if elem.CHECK() != nil {- // Check if NOT VALID is present in constraint attributes- hasNotValid := false- if elem.Constraintattributespec() != nil {- allAttrs := elem.Constraintattributespec().AllConstraintattributeElem()- for _, attr := range allAttrs {- if attr.NOT() != nil && attr.VALID() != nil {- hasNotValid = true- break- }- }- }- if !hasNotValid {+ case ast.CONSTR_CHECK:+ if !constraint.SkipValidation {code = advisorcode.CompatibilityAddCheck}+ default:}}+ default:}if code != advisorcode.Ok {+ stmtText := r.TrimmedStmtText()r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Int32(),- Title: r.title,- Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, getTextFromTokens(r.tokens, altertablestmtCtx)),+ Title: r.Title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),StartPosition: &storepb.Position{- Line: int32(altertablestmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})@@ -310,40 +195,31 @@ func (r *compatibilityRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {}}-// handleIndexstmt handles CREATE UNIQUE INDEX-func (r *compatibilityRule) handleIndexstmt(ctx antlr.ParserRuleContext) {- indexstmtCtx, ok := ctx.(*parser.IndexstmtContext)- if !ok {- return- }-- if !isTopLevel(indexstmtCtx.GetParent()) {- return- }-+func (r *compatibilityRule) handleIndexStmt(n *ast.IndexStmt) {// Check if this is CREATE UNIQUE INDEX- if indexstmtCtx.Opt_unique() == nil || indexstmtCtx.Opt_unique().UNIQUE() == nil {+ if !n.Unique {return}// Get table name- if indexstmtCtx.Relation_expr() == nil || indexstmtCtx.Relation_expr().Qualified_name() == nil {+ if n.Relation == nil {return}- tableName := extractTableName(indexstmtCtx.Relation_expr().Qualified_name())+ tableName := omniTableName(n.Relation)// Skip if this is the table we just createdif r.lastCreateTable == tableName {return}+ stmtText := r.TrimmedStmtText()r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: advisorcode.CompatibilityAddUniqueKey.Int32(),- Title: r.title,- Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, getTextFromTokens(r.tokens, indexstmtCtx)),+ Title: r.Title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),StartPosition: &storepb.Position{- Line: int32(indexstmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.goindex ce6fab88a9..0bdbfc53c1 100644--- a/backend/plugin/advisor/pg/advisor_naming_column.go+++ b/backend/plugin/advisor/pg/advisor_naming_column.go@@ -7,15 +7,11 @@ import ("github.com/pkg/errors"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- "github.com/bytebase/bytebase/backend/plugin/parser/pg")var (@@ -53,34 +49,19 @@ func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.}rule := &namingColumnConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},format: format,maxLength: maxLength,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingColumnConventionRule struct {- BaseRule+ OmniBaseRuleformat *regexp.RegexpmaxLength int@@ -90,134 +71,55 @@ func (*namingColumnConventionRule) Name() string {return "naming_column_convention"}-func (r *namingColumnConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx)- case "Altertablestmt":- r.handleAltertablestmt(ctx)- case "Renamestmt":- r.handleRenamestmt(ctx)+func (r *namingColumnConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)+ case *ast.RenameStmt:+ r.handleRenameStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*namingColumnConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-func (r *namingColumnConventionRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get table name- qualifiedNames := createCtx.AllQualified_name()- if len(qualifiedNames) == 0 {- return- }- tableName := extractTableName(qualifiedNames[0])-- // Get OptTableElementList which contains column definitions- if createCtx.Opttableelementlist() == nil || createCtx.Opttableelementlist().Tableelementlist() == nil {- return- }-- // Iterate through all table elements- allElements := createCtx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- // Check if this is a column definition- if elem.ColumnDef() != nil {- colDef := elem.ColumnDef()- if colDef.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- r.checkColumnName(tableName, columnName, colDef.GetStart().GetLine())- }- }+func (r *namingColumnConventionRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ cols, _ := omniTableElements(n)+ for _, col := range cols {+ r.checkColumnName(tableName, col.Colname)}}-func (r *namingColumnConventionRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- alterCtx, ok := ctx.(*parser.AltertablestmtContext)- if !ok {- return- }- if !isTopLevel(ctx.GetParent()) {- return- }-- // Get table name- if alterCtx.Relation_expr() == nil || alterCtx.Relation_expr().Qualified_name() == nil {- return- }- tableName := extractTableName(alterCtx.Relation_expr().Qualified_name())-- // Get ALTER TABLE commands- if alterCtx.Alter_table_cmds() == nil {- return- }-- allCmds := alterCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // Check for ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- colDef := cmd.ColumnDef()- if colDef.Colid() != nil {- columnName := pg.NormalizePostgreSQLColid(colDef.Colid())- r.checkColumnName(tableName, columnName, colDef.GetStart().GetLine())+func (r *namingColumnConventionRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AddColumn {+ if colDef, ok := cmd.Def.(*ast.ColumnDef); ok {+ r.checkColumnName(tableName, colDef.Colname)}}}}-func (r *namingColumnConventionRule) handleRenamestmt(ctx antlr.ParserRuleContext) {- renameCtx, ok := ctx.(*parser.RenamestmtContext)- if !ok {- return+func (r *namingColumnConventionRule) handleRenameStmt(n *ast.RenameStmt) {+ if n.RenameType == ast.OBJECT_COLUMN {+ tableName := omniTableName(n.Relation)+ r.checkColumnName(tableName, n.Newname)}- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is RENAME COLUMN- if renameCtx.Opt_column() == nil || renameCtx.Opt_column().COLUMN() == nil {- return- }-- // Get table name- var tableName string- if renameCtx.Relation_expr() != nil && renameCtx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(renameCtx.Relation_expr().Qualified_name())- }- if tableName == "" {- return- }-- // Get new column name- allNames := renameCtx.AllName()- if len(allNames) < 2 {- return- }-- newColumnName := pg.NormalizePostgreSQLName(allNames[1])- r.checkColumnName(tableName, newColumnName, renameCtx.GetStart().GetLine())}-func (r *namingColumnConventionRule) checkColumnName(tableName, columnName string, line int) {+func (r *namingColumnConventionRule) checkColumnName(tableName, columnName string) {+ line := r.FindLineByName(columnName)+if !r.format.MatchString(columnName) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingColumnConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, naming format should be %q", tableName, columnName, r.format),StartPosition: &storepb.Position{- Line: int32(line),+ Line: line,Column: 0,},})@@ -225,12 +127,12 @@ func (r *namingColumnConventionRule) checkColumnName(tableName, columnName strinif r.maxLength > 0 && len(columnName) > r.maxLength {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingColumnConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, its length should be within %d characters", tableName, columnName, r.maxLength),StartPosition: &storepb.Position{- Line: int32(line),+ Line: line,Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.goindex 9c46374e08..e021031c81 100644--- a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go@@ -3,20 +3,15 @@ package pgimport ("context""fmt"- "regexp""strings""github.com/pkg/errors"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")var (@@ -58,35 +53,20 @@ func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont}rule := &namingFKConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},format: format,maxLength: maxLength,templateList: templateList,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingFKConventionRule struct {- BaseRule+ OmniBaseRuleformat stringmaxLength int@@ -96,7 +76,6 @@ type namingFKConventionRule struct {type fkMetaData struct {indexName stringtableName string- line intmetaData map[string]string}@@ -104,146 +83,92 @@ func (*namingFKConventionRule) Name() string {return "naming.table.fk"}-func (r *namingFKConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))+func (r *namingFKConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*namingFKConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-func (r *namingFKConventionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }+func (r *namingFKConventionRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ cols, constraints := omniTableElements(n)- if ctx.Opttableelementlist() == nil {- return- }-- allQualifiedNames := ctx.AllQualified_name()- if len(allQualifiedNames) == 0 {- return+ // Check table-level FK constraints+ for _, c := range constraints {+ if md := r.extractFKMetaData(c, tableName); md != nil {+ r.checkFKMetadata(md)+ }}- tableName := extractTableName(allQualifiedNames[0])-- // Check table-level and column-level constraints- if ctx.Opttableelementlist().Tableelementlist() != nil {- for _, element := range ctx.Opttableelementlist().Tableelementlist().AllTableelement() {- // Check table-level constraints- if element.Tableconstraint() != nil {- metadata := r.extractFKMetadata(element.Tableconstraint(), tableName, ctx.GetStart().GetLine())- if metadata != nil {- r.checkFKMetadata(metadata)- }- }-- // Check column-level constraints- if element.ColumnDef() != nil {- columnDef := element.ColumnDef()- if columnDef.Colquallist() != nil {- allQuals := columnDef.Colquallist().AllColconstraint()- for _, qual := range allQuals {- metadata := r.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())- if metadata != nil {- r.checkFKMetadata(metadata)- }- }- }+ // Check column-level FK constraints+ for _, col := range cols {+ for _, c := range omniColumnConstraints(col) {+ if md := r.extractColumnFKMetaData(c, tableName, col.Colname); md != nil {+ r.checkFKMetadata(md)}}}}-func (r *namingFKConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil {- return- }-- tableName := extractTableName(ctx.Relation_expr().Qualified_name())-- if ctx.Alter_table_cmds() == nil {- return- }+func (r *namingFKConventionRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // Check for ADD + Tableconstraint- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- metadata := r.extractFKMetadata(cmd.Tableconstraint(), tableName, cmd.GetStart().GetLine())- if metadata != nil {- r.checkFKMetadata(metadata)+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AddConstraint {+ c, ok := cmd.Def.(*ast.Constraint)+ if !ok {+ continue+ }+ if md := r.extractFKMetaData(c, tableName); md != nil {+ r.checkFKMetadata(md)}}- // Check for ADD COLUMN with inline foreign key constraint- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- columnDef := cmd.ColumnDef()- if columnDef.Colquallist() != nil {- allQuals := columnDef.Colquallist().AllColconstraint()- for _, qual := range allQuals {- metadata := r.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())- if metadata != nil {- r.checkFKMetadata(metadata)- }+ // ADD COLUMN with inline FK constraint+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AddColumn {+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok {+ continue+ }+ for _, c := range omniColumnConstraints(colDef) {+ if md := r.extractColumnFKMetaData(c, tableName, colDef.Colname); md != nil {+ r.checkFKMetadata(md)}}}}}-func (*namingFKConventionRule) extractFKMetadata(constraint parser.ITableconstraintContext, tableName string, line int) *fkMetaData {- if constraint.Constraintelem() == nil {- return nil- }-- elem := constraint.Constraintelem()-- // Check if this is a FOREIGN KEY constraint- if elem.FOREIGN() == nil || elem.KEY() == nil {+func (*namingFKConventionRule) extractFKMetaData(c *ast.Constraint, tableName string) *fkMetaData {+ if c.Contype != ast.CONSTR_FOREIGN {return nil}- // Extract constraint name- constraintName := ""- if constraint.Name() != nil {- constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())- }+ constraintName := c.Conname- // Extract referencing columns+ // Extract referencing columns from FkAttrsvar referencingColumns []string- if elem.Columnlist() != nil {- for _, colElem := range elem.Columnlist().AllColumnElem() {- if colElem.Colid() != nil {- referencingColumns = append(referencingColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))+ if c.FkAttrs != nil {+ for _, item := range c.FkAttrs.Items {+ if s, ok := item.(*ast.String); ok {+ referencingColumns = append(referencingColumns, s.Str)}}}- // Extract referenced table and columns- var referencedTable string- var referencedColumns []string- if elem.Qualified_name() != nil {- referencedTable = extractTableName(elem.Qualified_name())- }+ // Extract referenced table+ referencedTable := omniTableName(c.Pktable)- if elem.Opt_column_list() != nil && elem.Opt_column_list().Columnlist() != nil {- for _, colElem := range elem.Opt_column_list().Columnlist().AllColumnElem() {- if colElem.Colid() != nil {- referencedColumns = append(referencedColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))+ // Extract referenced columns from PkAttrs+ var referencedColumns []string+ if c.PkAttrs != nil {+ for _, item := range c.PkAttrs.Items {+ if s, ok := item.(*ast.String); ok {+ referencedColumns = append(referencedColumns, s.Str)}}}@@ -258,53 +183,31 @@ func (*namingFKConventionRule) extractFKMetadata(constraint parser.ITableconstrareturn &fkMetaData{indexName: constraintName,tableName: tableName,- line: line,metaData: metaData,}}-func (*namingFKConventionRule) extractColumnFKMetadata(qual parser.IColconstraintContext, tableName string, columnDef parser.IColumnDefContext, line int) *fkMetaData {- if qual.Colconstraintelem() == nil {+func (*namingFKConventionRule) extractColumnFKMetaData(c *ast.Constraint, tableName, colName string) *fkMetaData {+ if c.Contype != ast.CONSTR_FOREIGN {return nil}- elem := qual.Colconstraintelem()+ constraintName := c.Conname+ referencedTable := omniTableName(c.Pktable)- // Check if this is a REFERENCES constraint (inline foreign key)- if elem.REFERENCES() == nil {- return nil- }-- // Extract constraint name- constraintName := ""- if qual.Name() != nil {- constraintName = pgparser.NormalizePostgreSQLName(qual.Name())- }-- // Extract referencing column (the column being defined)- var referencingColumn string- if columnDef.Colid() != nil {- referencingColumn = pgparser.NormalizePostgreSQLColid(columnDef.Colid())- }-- // Extract referenced table and columns- var referencedTable string+ // Extract referenced columns from PkAttrsvar referencedColumns []string- if elem.Qualified_name() != nil {- referencedTable = extractTableName(elem.Qualified_name())- }-- if elem.Opt_column_list() != nil && elem.Opt_column_list().Columnlist() != nil {- for _, colElem := range elem.Opt_column_list().Columnlist().AllColumnElem() {- if colElem.Colid() != nil {- referencedColumns = append(referencedColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))+ if c.PkAttrs != nil {+ for _, item := range c.PkAttrs.Items {+ if s, ok := item.(*ast.String); ok {+ referencedColumns = append(referencedColumns, s.Str)}}}metaData := map[string]string{advisor.ReferencingTableNameTemplateToken: tableName,- advisor.ReferencingColumnNameTemplateToken: referencingColumn,+ advisor.ReferencingColumnNameTemplateToken: colName,advisor.ReferencedTableNameTemplateToken: referencedTable,advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumns, "_"),}@@ -312,21 +215,22 @@ func (*namingFKConventionRule) extractColumnFKMetadata(qual parser.IColconstrainreturn &fkMetaData{indexName: constraintName,tableName: tableName,- line: line,metaData: metaData,}}func (r *namingFKConventionRule) checkFKMetadata(fkData *fkMetaData) {- regex, err := r.getTemplateRegexp(fkData.metaData)+ line := r.FindLineByName(fkData.indexName)++ regex, err := getTemplateRegexp(r.format, r.templateList, fkData.metaData)if err != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Internal.Int32(),Title: "Internal error for foreign key naming convention rule",Content: fmt.Sprintf("Failed to compile regex: %s", err.Error()),StartPosition: &storepb.Position{- Line: int32(fkData.line),+ Line: line,Column: 0,},})@@ -335,12 +239,12 @@ func (r *namingFKConventionRule) checkFKMetadata(fkData *fkMetaData) {if !regex.MatchString(fkData.indexName) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingFKConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf(`Foreign key in table "%s" mismatches the naming convention, expect %q but found "%s"`, fkData.tableName, regex, fkData.indexName),StartPosition: &storepb.Position{- Line: int32(fkData.line),+ Line: line,Column: 0,},})@@ -348,25 +252,14 @@ func (r *namingFKConventionRule) checkFKMetadata(fkData *fkMetaData) {if r.maxLength > 0 && len(fkData.indexName) > r.maxLength {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingFKConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf(`Foreign key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, fkData.indexName, fkData.tableName, r.maxLength),StartPosition: &storepb.Position{- Line: int32(fkData.line),+ Line: line,Column: 0,},})}}--func (r *namingFKConventionRule) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {- template := r.format- for _, key := range r.templateList {- if token, ok := tokens[key]; ok {- template = strings.ReplaceAll(template, key, token)- }- }-- return regexp.Compile(template)-}diff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.goindex 9a98a58442..a9af61ee65 100644--- a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go+++ b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go@@ -3,17 +3,13 @@ package pgimport ("context""fmt"- "regexp""strings"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")var (@@ -35,341 +31,120 @@ func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx advisoreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &fullyQualifiedObjectNameRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- dbMetadata: checkCtx.DBSchema,- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &fullyQualifiedObjectNameRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },+ dbMetadata: checkCtx.DBSchema,}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type fullyQualifiedObjectNameRule struct {- BaseRule+ OmniBaseRuledbMetadata *storepb.DatabaseSchemaMetadata- tokens *antlr.CommonTokenStream}func (*fullyQualifiedObjectNameRule) Name() string {return "naming_fully_qualified"}-func (r *fullyQualifiedObjectNameRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- if c, ok := ctx.(*parser.CreatestmtContext); ok {- r.handleCreatestmt(c)- }- case "Createseqstmt":- if c, ok := ctx.(*parser.CreateseqstmtContext); ok {- r.handleCreateseqstmt(c)- }- case "Createtrigstmt":- if c, ok := ctx.(*parser.CreatetrigstmtContext); ok {- r.handleCreatetrigstmt(c)- }- case "Indexstmt":- if c, ok := ctx.(*parser.IndexstmtContext); ok {- r.handleIndexstmt(c)- }- case "Dropstmt":- if c, ok := ctx.(*parser.DropstmtContext); ok {- r.handleDropstmt(c)- }- case "Altertablestmt":- if c, ok := ctx.(*parser.AltertablestmtContext); ok {- r.handleAltertablestmt(c)- }- case "Alterseqstmt":- if c, ok := ctx.(*parser.AlterseqstmtContext); ok {- r.handleAlterseqstmt(c)- }- case "Renamestmt":- if c, ok := ctx.(*parser.RenamestmtContext); ok {- r.handleRenamestmt(c)- }- case "Insertstmt":- if c, ok := ctx.(*parser.InsertstmtContext); ok {- r.handleInsertstmt(c)- }- case "Updatestmt":- if c, ok := ctx.(*parser.UpdatestmtContext); ok {- r.handleUpdatestmt(c)- }- case "Selectstmt":- if c, ok := ctx.(*parser.SelectstmtContext); ok {- r.handleSelectstmt(c)- }+func (r *fullyQualifiedObjectNameRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.checkRangeVar(n.Relation)+ case *ast.CreateSeqStmt:+ r.checkRangeVar(n.Sequence)+ case *ast.CreateTrigStmt:+ r.checkRangeVar(n.Relation)+ case *ast.IndexStmt:+ r.checkRangeVar(n.Relation)+ case *ast.DropStmt:+ r.handleDropStmt(n)+ case *ast.AlterTableStmt:+ r.checkRangeVar(n.Relation)+ case *ast.AlterSeqStmt:+ r.checkRangeVar(n.Sequence)+ case *ast.RenameStmt:+ r.checkRangeVar(n.Relation)+ case *ast.InsertStmt:+ r.checkRangeVar(n.Relation)+ case *ast.UpdateStmt:+ r.checkRangeVar(n.Relation)+ case *ast.SelectStmt:+ r.handleSelectStmt(n)default:- // Do nothing for other node types- }- return nil-}--func (*fullyQualifiedObjectNameRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleCreatestmt handles CREATE TABLE-func (r *fullyQualifiedObjectNameRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- allQualifiedNames := ctx.AllQualified_name()- if len(allQualifiedNames) > 0 {- r.checkQualifiedName(allQualifiedNames[0], ctx.GetStop().GetLine())- }-}--// handleCreateseqstmt handles CREATE SEQUENCE-func (r *fullyQualifiedObjectNameRule) handleCreateseqstmt(ctx *parser.CreateseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Qualified_name() != nil {- r.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())- }-}--// handleCreatetrigstmt handles CREATE TRIGGER-func (r *fullyQualifiedObjectNameRule) handleCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check the table name in the ON clause- if ctx.Qualified_name() != nil {- r.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())- }-}--// handleIndexstmt handles CREATE INDEX-func (r *fullyQualifiedObjectNameRule) handleIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check the table name in the ON clause- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- r.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())- }-}--// handleDropstmt handles DROP TABLE, DROP SEQUENCE, DROP INDEX-func (r *fullyQualifiedObjectNameRule) handleDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check all qualified names in the drop statement- if ctx.Any_name_list() != nil {- for _, anyName := range ctx.Any_name_list().AllAny_name() {- r.checkAnyName(anyName, ctx.GetStop().GetLine())- }- }-}--// handleAltertablestmt handles ALTER TABLE-func (r *fullyQualifiedObjectNameRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- r.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())- }-}--// handleAlterseqstmt handles ALTER SEQUENCE-func (r *fullyQualifiedObjectNameRule) handleAlterseqstmt(ctx *parser.AlterseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Qualified_name() != nil {- r.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())- }-}--// handleRenamestmt handles ALTER TABLE RENAME-func (r *fullyQualifiedObjectNameRule) handleRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- r.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())- }-}--// handleInsertstmt handles INSERT-func (r *fullyQualifiedObjectNameRule) handleInsertstmt(ctx *parser.InsertstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Insert_target() != nil && ctx.Insert_target().Qualified_name() != nil {- r.checkQualifiedName(ctx.Insert_target().Qualified_name(), ctx.GetStop().GetLine())}}-// handleUpdatestmt handles UPDATE-func (r *fullyQualifiedObjectNameRule) handleUpdatestmt(ctx *parser.UpdatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr_opt_alias() != nil && ctx.Relation_expr_opt_alias().Relation_expr() != nil {- if ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name() != nil {- r.checkQualifiedName(ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name(), ctx.GetStop().GetLine())+func (r *fullyQualifiedObjectNameRule) handleDropStmt(n *ast.DropStmt) {+ for _, nameParts := range omniDropObjectNames(n) {+ objName := strings.Join(nameParts, ".")+ if !isFullyQualifiedName(objName) {+ r.addUnqualifiedAdvice(objName)}}}-// handleSelectstmt handles SELECT-func (r *fullyQualifiedObjectNameRule) handleSelectstmt(ctx *parser.SelectstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // For SELECT statements, we need to extract tables from the query- // and check them against the database schema+func (r *fullyQualifiedObjectNameRule) handleSelectStmt(n *ast.SelectStmt) {if r.dbMetadata == nil {return}- statementText := getTextFromTokens(r.tokens, ctx)+ schemaNameMap := r.getSchemaNameMapFromPublic()- // Find all table references in the SELECT statement- for _, tableName := range r.findAllTablesInSelect(statementText) {- objName := tableName.String()- if !r.isFullyQualified(objName) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: int32(code.NamingNotFullyQualifiedName),- Title: r.title,- Content: fmt.Sprintf("unqualified object name: '%s'", objName),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStop().GetLine()),- Column: 0,- },- })+ for _, rv := range omniCollectFromClauseRangeVars(n.FromClause) {+ tableName := rv.Relname+ // Only check tables that exist in the schema+ if schemaNameMap == nil || schemaNameMap[tableName] {+ if rv.Schemaname == "" {+ r.addUnqualifiedAdvice(tableName)+ }}}}-// checkQualifiedName checks if a qualified name is fully qualified-func (r *fullyQualifiedObjectNameRule) checkQualifiedName(ctx parser.IQualified_nameContext, line int) {- if ctx == nil {+func (r *fullyQualifiedObjectNameRule) checkRangeVar(rv *ast.RangeVar) {+ if rv == nil {return}-- parts := pgparser.NormalizePostgreSQLQualifiedName(ctx)- objName := strings.Join(parts, ".")-- if !r.isFullyQualified(objName) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: int32(code.NamingNotFullyQualifiedName),- Title: r.title,- Content: fmt.Sprintf("unqualified object name: '%s'", objName),- StartPosition: &storepb.Position{- Line: int32(line),- Column: 0,- },- })+ var objName string+ if rv.Schemaname != "" {+ objName = rv.Schemaname + "." + rv.Relname+ } else {+ objName = rv.Relname}-}--// checkAnyName checks if an any_name is fully qualified-func (r *fullyQualifiedObjectNameRule) checkAnyName(ctx parser.IAny_nameContext, line int) {- if ctx == nil {- return- }-- // Extract parts from any_name (schema.object or object)- parts := pgparser.NormalizePostgreSQLAnyName(ctx)- objName := strings.Join(parts, ".")-- if !r.isFullyQualified(objName) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: int32(code.NamingNotFullyQualifiedName),- Title: r.title,- Content: fmt.Sprintf("unqualified object name: '%s'", objName),- StartPosition: &storepb.Position{- Line: int32(line),- Column: 0,- },- })+ if !isFullyQualifiedName(objName) {+ r.addUnqualifiedAdvice(objName)}}-// isFullyQualified checks if an object name is fully qualified (contains a dot)-func (*fullyQualifiedObjectNameRule) isFullyQualified(objName string) bool {- if objName == "" {- return true- }- re := regexp.MustCompile(`.+\..+`)- return re.MatchString(objName)+func (r *fullyQualifiedObjectNameRule) addUnqualifiedAdvice(objName string) {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: int32(code.NamingNotFullyQualifiedName),+ Title: r.Title,+ Content: fmt.Sprintf("unqualified object name: '%s'", objName),+ StartPosition: &storepb.Position{+ Line: r.ContentEndLine(),+ Column: 0,+ },+ })}-// findAllTablesInSelect finds all table references in a SELECT statement-func (r *fullyQualifiedObjectNameRule) findAllTablesInSelect(statement string) []base.ColumnResource {- // Parse the statement to extract table references- parsedStatements, err := pgparser.ParsePostgreSQL(statement)- if err != nil {- return nil- }-- // Use a visitor to find all table references- collector := &tableReferenceCollector{- schemaNameMap: r.getSchemaNameMapFromPublic(),- }-- for _, antlrAST := range parsedStatements {- if antlrAST != nil && antlrAST.Tree != nil {- antlr.ParseTreeWalkerDefault.Walk(collector, antlrAST.Tree)- }- }-- return collector.tables-}--// getSchemaNameMapFromPublic creates a map of table names from the database schema+// getSchemaNameMapFromPublic creates a map of table names from the database schema.func (r *fullyQualifiedObjectNameRule) getSchemaNameMapFromPublic() map[string]bool {if r.dbMetadata == nil || r.dbMetadata.Schemas == nil {return nil}-filterMap := map[string]bool{}for _, schema := range r.dbMetadata.Schemas {- // Tablesfor _, tbl := range schema.Tables {filterMap[tbl.Name] = true}- // External Tablesfor _, tbl := range schema.ExternalTables {filterMap[tbl.Name] = true}@@ -377,31 +152,10 @@ func (r *fullyQualifiedObjectNameRule) getSchemaNameMapFromPublic() map[string]breturn filterMap}-// tableReferenceCollector collects table references from a SELECT statement-type tableReferenceCollector struct {- *parser.BasePostgreSQLParserListener-- tables []base.ColumnResource- schemaNameMap map[string]bool-}--// EnterTable_ref collects table references-func (c *tableReferenceCollector) EnterTable_ref(ctx *parser.Table_refContext) {- // Look for relation_expr in the table_ref- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Relation_expr().Qualified_name())-- resource := base.ColumnResource{}- if len(parts) == 2 {- resource.Schema = parts[0]- resource.Table = parts[1]- } else if len(parts) == 1 {- resource.Table = parts[0]- }-- // Only add if the table exists in the schema- if c.schemaNameMap == nil || c.schemaNameMap[resource.Table] {- c.tables = append(c.tables, resource)- }+// isFullyQualifiedName checks if an object name is fully qualified (contains a dot).+func isFullyQualifiedName(objName string) bool {+ if objName == "" {+ return true}+ return strings.Contains(objName, ".")}diff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.goindex 55844f2eed..7839088a99 100644--- a/backend/plugin/advisor/pg/advisor_naming_index_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_index_convention.go@@ -5,15 +5,13 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql""github.com/pkg/errors"+ "github.com/bytebase/omni/pg/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"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -56,9 +54,9 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.C}rule := &namingIndexConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},format: format,maxLength: maxLength,@@ -66,26 +64,11 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.CoriginalMetadata: checkCtx.OriginalMetadata,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingIndexConventionRule struct {- BaseRule+ OmniBaseRuleformat stringmaxLength int@@ -98,115 +81,55 @@ func (*namingIndexConventionRule) Name() string {return "naming-index-convention"}-// OnEnter handles entering a parse tree node.-func (r *namingIndexConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Indexstmt":- r.handleIndexstmt(ctx)- case "Renamestmt":- r.handleRenamestmt(ctx)+func (r *namingIndexConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.IndexStmt:+ r.handleIndexStmt(n)+ case *ast.RenameStmt:+ r.handleRenameStmt(n)default:- // Ignore other node types}- return nil-}--// OnExit handles exiting a parse tree node.-func (*namingIndexConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-// handleIndexstmt checks CREATE INDEX statements-func (r *namingIndexConventionRule) handleIndexstmt(ctx antlr.ParserRuleContext) {- indexstmtCtx, ok := ctx.(*parser.IndexstmtContext)- if !ok {- return- }- if !isTopLevel(indexstmtCtx.GetParent()) {+func (r *namingIndexConventionRule) handleIndexStmt(n *ast.IndexStmt) {+ // Skip UNIQUE indexes - they are handled by the UK naming rule+ if n.Unique {return}- // Check if this is a UNIQUE index - if so, skip it- if indexstmtCtx.Opt_unique() != nil && indexstmtCtx.Opt_unique().UNIQUE() != nil {- return- }-- // Get index name- indexName := ""- if indexstmtCtx.Name() != nil {- indexName = pgparser.NormalizePostgreSQLName(indexstmtCtx.Name())- }+ indexName := n.Idxnameif indexName == "" {return}- // Get table name- tableName := ""- if indexstmtCtx.Relation_expr() != nil && indexstmtCtx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(indexstmtCtx.Relation_expr().Qualified_name())- }+ tableName := omniTableName(n.Relation)if tableName == "" {return}- // Get column list- var columnList []string- if indexstmtCtx.Index_params() != nil {- allParams := indexstmtCtx.Index_params().AllIndex_elem()- for _, param := range allParams {- if param.Colid() != nil {- colName := pgparser.NormalizePostgreSQLColid(param.Colid())- columnList = append(columnList, colName)- }- }- }-- r.checkIndexName(indexName, tableName, columnList, indexstmtCtx.GetStart().GetLine())+ columnList := omniIndexColumns(n)+ r.checkIndexName(indexName, tableName, columnList)}-// handleRenamestmt checks ALTER INDEX ... RENAME TO statements-func (r *namingIndexConventionRule) handleRenamestmt(ctx antlr.ParserRuleContext) {- renamestmtCtx, ok := ctx.(*parser.RenamestmtContext)- if !ok {- return- }- if !isTopLevel(renamestmtCtx.GetParent()) {- return- }-- // Check for ALTER INDEX ... RENAME TO- if renamestmtCtx.INDEX() != nil && renamestmtCtx.TO() != nil {- allNames := renamestmtCtx.AllName()- if len(allNames) < 1 {- return+func (r *namingIndexConventionRule) handleRenameStmt(n *ast.RenameStmt) {+ // ALTER INDEX ... RENAME TO+ if n.RenameType == ast.OBJECT_INDEX {+ oldIndexName := ""+ if n.Relation != nil {+ oldIndexName = n.Relation.Relname}+ newIndexName := n.Newname- // Get old index name from qualified_name- var oldIndexName string- if renamestmtCtx.Qualified_name() != nil {- parts := pgparser.NormalizePostgreSQLQualifiedName(renamestmtCtx.Qualified_name())- if len(parts) > 0 {- oldIndexName = parts[len(parts)-1]- }- }-- // Get new index name from the name after TO- newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])-- // Look up the index in catalog to determine if it's a regular index (not unique, not PK)if r.originalMetadata != nil && oldIndexName != "" {tableName, index := r.findIndex("", "", oldIndexName)- if index != nil {- // Only check if it's a regular index (not unique, not primary)- if !index.GetProto().GetUnique() && !index.GetProto().GetPrimary() {- r.checkIndexName(newIndexName, tableName, index.GetProto().GetExpressions(), renamestmtCtx.GetStart().GetLine())- }+ if index != nil && !index.GetProto().GetUnique() && !index.GetProto().GetPrimary() {+ r.checkIndexName(newIndexName, tableName, index.GetProto().GetExpressions())}}}}-func (r *namingIndexConventionRule) checkIndexName(indexName, tableName string, columnList []string, line int) {+func (r *namingIndexConventionRule) checkIndexName(indexName, tableName string, columnList []string) {metaData := map[string]string{advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),advisor.TableNameTemplateToken: tableName,@@ -215,12 +138,12 @@ func (r *namingIndexConventionRule) checkIndexName(indexName, tableName string,regex, err := getTemplateRegexp(r.format, r.templateList, metaData)if err != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Internal.Int32(),Title: "Internal error for index naming convention rule",Content: fmt.Sprintf("Failed to compile regex: %v", err),StartPosition: &storepb.Position{- Line: int32(line),+ Line: r.ContentStartLine(),Column: 0,},})@@ -229,12 +152,12 @@ func (r *namingIndexConventionRule) checkIndexName(indexName, tableName string,if !regex.MatchString(indexName) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingIndexConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Index in table %q mismatches the naming convention, expect %q but found %q", tableName, regex, indexName),StartPosition: &storepb.Position{- Line: int32(line),+ Line: r.ContentStartLine(),Column: 0,},})@@ -242,12 +165,12 @@ func (r *namingIndexConventionRule) checkIndexName(indexName, tableName string,if r.maxLength > 0 && len(indexName) > r.maxLength {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingIndexConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Index %q in table %q mismatches the naming convention, its length should be within %d characters", indexName, tableName, r.maxLength),StartPosition: &storepb.Position{- Line: int32(line),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.goindex a20b4fd6a2..7946b0a0c8 100644--- a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go@@ -5,15 +5,13 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql""github.com/pkg/errors"+ "github.com/bytebase/omni/pg/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"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -55,38 +53,22 @@ func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.ContmaxLength = advisor.DefaultNameLengthLimit}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &namingPKConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- format: format,- maxLength: maxLength,- templateList: templateList,- originalMetadata: checkCtx.OriginalMetadata,- }-- checker := NewGenericChecker([]Rule{rule})- rule.SetBaseLine(stmtInfo.BaseLine())- checker.SetBaseLine(stmtInfo.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &namingPKConventionRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },+ format: format,+ maxLength: maxLength,+ templateList: templateList,+ originalMetadata: checkCtx.OriginalMetadata,}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingPKConventionRule struct {- BaseRule+ OmniBaseRuleformat stringmaxLength int@@ -95,293 +77,183 @@ type namingPKConventionRule struct {}type pkMetaData struct {- pkName string- tableName string- schemaName string- line int- metaData map[string]string+ pkName string+ tableName string+ metaData map[string]string}func (*namingPKConventionRule) Name() string {return "naming_primary_key_convention"}-func (r *namingPKConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- case "Renamestmt":- r.handleRenamestmt(ctx.(*parser.RenamestmtContext))+func (r *namingPKConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)+ case *ast.RenameStmt:+ r.handleRenameStmt(n)default:- // Do nothing for other node types}- return nil-}--func (*namingPKConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-// handleCreatestmt handles CREATE TABLE with PRIMARY KEY constraints-func (r *namingPKConventionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- var tableName, schemaName string- allQualifiedNames := ctx.AllQualified_name()- if len(allQualifiedNames) > 0 {- tableName = extractTableName(allQualifiedNames[0])- schemaName = extractSchemaName(allQualifiedNames[0])- if schemaName == "" {- schemaName = "public"+func (r *namingPKConventionRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ schemaName := omniSchemaName(n.Relation)++ _, constraints := omniTableElements(n)+ for _, c := range constraints {+ if c.Contype == ast.CONSTR_PRIMARY && c.Conname != "" {+ columnList := omniConstraintColumns(c)+ r.checkPKName(&pkMetaData{+ pkName: c.Conname,+ tableName: tableName,+ metaData: map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ },+ })}}- // Check table-level constraints- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- // Check table-level PRIMARY KEY constraint- if elem.Tableconstraint() != nil {- constraint := elem.Tableconstraint()- if pkData := r.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {- r.checkPKName(pkData)- }- }-- // Check column-level PRIMARY KEY constraint - commented out for now- // Column-level constraints typically don't have explicit names in the test cases+ // Check PRIMARY KEY USING INDEX in table constraints+ for _, c := range constraints {+ if c.Contype == ast.CONSTR_PRIMARY && c.Conname != "" && c.Indexname != "" {+ columnList := r.lookupIndexColumns(schemaName, tableName, c.Indexname)+ r.checkPKName(&pkMetaData{+ pkName: c.Conname,+ tableName: tableName,+ metaData: map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ },+ })}}}-// handleAltertablestmt handles ALTER TABLE ADD CONSTRAINT PRIMARY KEY-func (r *namingPKConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- var tableName, schemaName string- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(ctx.Relation_expr().Qualified_name())- schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())- if schemaName == "" {- schemaName = "public"- }- }+func (r *namingPKConventionRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)+ schemaName := omniSchemaName(n.Relation)- // Check all alter table commands- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD CONSTRAINT- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- constraint := cmd.Tableconstraint()- if pkData := r.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {- r.checkPKName(pkData)- }+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AddConstraint {+ c, ok := cmd.Def.(*ast.Constraint)+ if !ok || c.Contype != ast.CONSTR_PRIMARY {+ continue+ }+ pkName := c.Conname+ if pkName == "" {+ continue}- }- }-}-// handleRenamestmt handles ALTER TABLE RENAME CONSTRAINT and ALTER INDEX RENAME TO-func (r *namingPKConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }+ columnList := omniConstraintColumns(c)- allNames := ctx.AllName()+ // PRIMARY KEY USING INDEX+ if c.Indexname != "" {+ columnList = r.lookupIndexColumns(schemaName, tableName, c.Indexname)+ }- // Check for ALTER TABLE ... RENAME CONSTRAINT old_name TO new_name- // Example: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO new_pk- if ctx.TABLE() != nil && ctx.CONSTRAINT() != nil && ctx.TO() != nil {- var tableName, schemaName string- // Get table name from Relation_expr()- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(ctx.Relation_expr().Qualified_name())- schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())+ r.checkPKName(&pkMetaData{+ pkName: pkName,+ tableName: tableName,+ metaData: map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ },+ })}+ }+}- if len(allNames) >= 2 {- oldName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-2])- newName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])-- // Check if old constraint is a primary key using catalog- if r.originalMetadata != nil {- normalizedSchema := schemaName- if normalizedSchema == "" {- normalizedSchema = "public"- }- index := r.originalMetadata.GetSchemaMetadata(normalizedSchema).GetTable(tableName).GetIndex(oldName)- if index != nil && index.GetProto().GetPrimary() {- metaData := map[string]string{+func (r *namingPKConventionRule) handleRenameStmt(n *ast.RenameStmt) {+ // ALTER TABLE ... RENAME CONSTRAINT+ if n.RenameType == ast.OBJECT_TABCONSTRAINT {+ tableName := omniTableName(n.Relation)+ schemaName := omniSchemaName(n.Relation)+ oldName := n.Subname+ newName := n.Newname++ if r.originalMetadata != nil && oldName != "" {+ normalizedSchema := normalizeSchemaName(schemaName)+ index := r.originalMetadata.GetSchemaMetadata(normalizedSchema).GetTable(tableName).GetIndex(oldName)+ if index != nil && index.GetProto().GetPrimary() {+ r.checkPKName(&pkMetaData{+ pkName: newName,+ tableName: tableName,+ metaData: map[string]string{advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),advisor.TableNameTemplateToken: tableName,- }- pkData := &pkMetaData{- pkName: newName,- tableName: tableName,- schemaName: schemaName,- line: ctx.GetStart().GetLine(),- metaData: metaData,- }- r.checkPKName(pkData)- }+ },+ })}}}- // Check for ALTER INDEX ... RENAME TO new_name- // Example: ALTER INDEX old_pk RENAME TO new_pk- if ctx.INDEX() != nil && ctx.TO() != nil {- var oldIndexName, schemaName string-- // Try Qualified_name first (direct qualified name)- if ctx.Qualified_name() != nil {- oldIndexName = extractTableName(ctx.Qualified_name())- schemaName = extractSchemaName(ctx.Qualified_name())- } else if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- // Fall back to Relation_expr- oldIndexName = extractTableName(ctx.Relation_expr().Qualified_name())- schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())+ // ALTER INDEX ... RENAME TO+ if n.RenameType == ast.OBJECT_INDEX {+ oldIndexName := ""+ schemaName := ""+ if n.Relation != nil {+ oldIndexName = n.Relation.Relname+ schemaName = n.Relation.Schemaname}+ newIndexName := n.Newname- if oldIndexName != "" && len(allNames) > 0 {- newIndexName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])-- // Check if this index is a primary key using catalog- if r.originalMetadata != nil {- normalizedSchema := schemaName- if normalizedSchema == "" {- normalizedSchema = "public"- }- // "ALTER INDEX name RENAME TO new_name" doesn't specify table name- // Empty table name for ALTER INDEX- schema := r.originalMetadata.GetSchemaMetadata(normalizedSchema)- var tableName string- var index *model.IndexMetadata- if schema != nil {- index = schema.GetIndex(oldIndexName)- if index != nil {- tableName = index.GetTableProto().Name- }- }+ if r.originalMetadata != nil && oldIndexName != "" {+ normalizedSchema := normalizeSchemaName(schemaName)+ schema := r.originalMetadata.GetSchemaMetadata(normalizedSchema)+ if schema != nil {+ index := schema.GetIndex(oldIndexName)if index != nil && index.GetProto().GetPrimary() {- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),- advisor.TableNameTemplateToken: tableName,- }- pkData := &pkMetaData{- pkName: newIndexName,- tableName: tableName,- schemaName: normalizedSchema,- line: ctx.GetStart().GetLine(),- metaData: metaData,- }- r.checkPKName(pkData)+ tableName := index.GetTableProto().Name+ r.checkPKName(&pkMetaData{+ pkName: newIndexName,+ tableName: tableName,+ metaData: map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),+ advisor.TableNameTemplateToken: tableName,+ },+ })}}}}}-func (r *namingPKConventionRule) getPKMetaDataFromTableConstraint(constraint parser.ITableconstraintContext, tableName, schemaName string, line int) *pkMetaData {- if constraint == nil || constraint.Constraintelem() == nil {+func (r *namingPKConventionRule) lookupIndexColumns(schemaName, tableName, indexName string) []string {+ if r.originalMetadata == nil || indexName == "" {return nil}-- elem := constraint.Constraintelem()-- // Check if this is a PRIMARY KEY constraint- if elem.PRIMARY() != nil && elem.KEY() != nil {- var pkName string- var columnList []string-- // Try to get constraint name using GetText() on constraint itself and parsing it- // Format is usually: CONSTRAINT name PRIMARY KEY (columns) or just PRIMARY KEY (columns)- constraintText := constraint.GetText()- // Check if it starts with CONSTRAINT keyword- if strings.HasPrefix(strings.ToUpper(constraintText), "CONSTRAINT") {- // Extract the name between CONSTRAINT and PRIMARY- parts := strings.Split(constraintText, "PRIMARY")- if len(parts) > 0 {- // Remove "CONSTRAINT" prefix- namePart := strings.TrimPrefix(strings.ToUpper(parts[0]), "CONSTRAINT")- namePart = strings.TrimSpace(strings.ToLower(namePart))- // The name is before the keyword PRIMARY- // This is a simplified extraction- if namePart != "" && !strings.Contains(namePart, "(") {- pkName = namePart- }- }- }-- // Get column list- if elem.Columnlist() != nil {- allColumns := elem.Columnlist().AllColumnElem()- for _, col := range allColumns {- if col.Colid() != nil {- columnList = append(columnList, pgparser.NormalizePostgreSQLColid(col.Colid()))- }- }- }-- // PRIMARY KEY USING INDEX- if elem.Existingindex() != nil && elem.Existingindex().Name() != nil {- // Extract index name properly- indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())- // Find the index in catalog to get column list- if r.originalMetadata != nil && indexName != "" {- normalizedSchema := schemaName- if normalizedSchema == "" {- normalizedSchema = "public"- }- schema := r.originalMetadata.GetSchemaMetadata(normalizedSchema)- var index *model.IndexMetadata- if schema != nil {- table := schema.GetTable(tableName)- if table != nil {- index = table.GetIndex(indexName)- }- }- if index != nil {- columnList = index.GetProto().GetExpressions()- }- }- }-- if pkName != "" {- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: tableName,- }- return &pkMetaData{- pkName: pkName,- tableName: tableName,- schemaName: schemaName,- line: line,- metaData: metaData,- }- }+ normalizedSchema := normalizeSchemaName(schemaName)+ schema := r.originalMetadata.GetSchemaMetadata(normalizedSchema)+ if schema == nil {+ return nil+ }+ table := schema.GetTable(tableName)+ if table == nil {+ return nil+ }+ index := table.GetIndex(indexName)+ if index != nil {+ return index.GetProto().GetExpressions()}-return nil}func (r *namingPKConventionRule) checkPKName(pkData *pkMetaData) {+ line := r.FindLineByName(pkData.pkName)+regex, err := getTemplateRegexp(r.format, r.templateList, pkData.metaData)if err != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Internal.Int32(),Title: "Internal error for primary key naming convention rule",Content: fmt.Sprintf("Failed to compile regex: %v", err),StartPosition: &storepb.Position{- Line: int32(pkData.line),+ Line: line,Column: 0,},})@@ -390,12 +262,12 @@ func (r *namingPKConventionRule) checkPKName(pkData *pkMetaData) {if !regex.MatchString(pkData.pkName) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingPKConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf(`Primary key in table "%s" mismatches the naming convention, expect %q but found "%s"`, pkData.tableName, regex, pkData.pkName),StartPosition: &storepb.Position{- Line: int32(pkData.line),+ Line: line,Column: 0,},})@@ -403,12 +275,12 @@ func (r *namingPKConventionRule) checkPKName(pkData *pkMetaData) {if r.maxLength > 0 && len(pkData.pkName) > r.maxLength {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingPKConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf(`Primary key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, pkData.pkName, pkData.tableName, r.maxLength),StartPosition: &storepb.Position{- Line: int32(pkData.line),+ Line: line,Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_naming_table.go b/backend/plugin/advisor/pg/advisor_naming_table.goindex d19b1b40c5..67f0d47c60 100644--- a/backend/plugin/advisor/pg/advisor_naming_table.go+++ b/backend/plugin/advisor/pg/advisor_naming_table.go@@ -5,16 +5,13 @@ import ("fmt""regexp"- "github.com/antlr4-go/antlr/v4""github.com/pkg/errors"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")var (@@ -52,34 +49,19 @@ func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.C}rule := &namingTableConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},format: format,maxLength: maxLength,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingTableConventionRule struct {- BaseRule+ OmniBaseRuleformat *regexp.RegexpmaxLength int@@ -89,72 +71,41 @@ func (*namingTableConventionRule) Name() string {return string(storepb.SQLReviewRule_NAMING_TABLE)}-func (r *namingTableConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Renamestmt":- r.handleRenamestmt(ctx.(*parser.RenamestmtContext))- default:- }- return nil-}--func (*namingTableConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleCreatestmt handles CREATE TABLE-func (r *namingTableConventionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- allQualifiedNames := ctx.AllQualified_name()- if len(allQualifiedNames) > 0 {- tableName := extractTableName(allQualifiedNames[0])- r.checkTableName(tableName, ctx)- }-}--// handleRenamestmt handles ALTER TABLE RENAME TO-func (r *namingTableConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check for ALTER TABLE ... RENAME TO new_name- if ctx.TABLE() != nil && ctx.TO() != nil {- allNames := ctx.AllName()- if len(allNames) > 0 {- // The new table name is the last Name() in RENAME TO new_name- newTableName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])- r.checkTableName(newTableName, ctx)+func (r *namingTableConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ if n.Relation != nil {+ r.checkTableName(n.Relation.Relname)}+ case *ast.RenameStmt:+ if n.RenameType == ast.OBJECT_TABLE {+ r.checkTableName(n.Newname)+ }+ default:}}-func (r *namingTableConventionRule) checkTableName(tableName string, ctx antlr.ParserRuleContext) {+func (r *namingTableConventionRule) checkTableName(tableName string) {if !r.format.MatchString(tableName) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingTableConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, r.format),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}if r.maxLength > 0 && len(tableName) > r.maxLength {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingTableConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.goindex e308238072..f57f5e6659 100644--- a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go@@ -3,18 +3,15 @@ package pgimport ("context""fmt"- "regexp""strings"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql""github.com/pkg/errors"+ "github.com/bytebase/omni/pg/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"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -57,9 +54,9 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont}rule := &namingUKConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},format: format,maxLength: maxLength,@@ -67,26 +64,11 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.ContoriginalMetadata: checkCtx.OriginalMetadata,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingUKConventionRule struct {- BaseRule+ OmniBaseRuleformat stringmaxLength int@@ -98,291 +80,185 @@ func (*namingUKConventionRule) Name() string {return "naming-unique-key-convention"}-func (r *namingUKConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Indexstmt":- r.handleIndexstmt(ctx.(*parser.IndexstmtContext))- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- case "Renamestmt":- r.handleRenamestmt(ctx.(*parser.RenamestmtContext))+func (r *namingUKConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.IndexStmt:+ r.handleIndexStmt(n)+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)+ case *ast.RenameStmt:+ r.handleRenameStmt(n)default:- // Do nothing for other node types}- return nil}-func (*namingUKConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleIndexstmt handles CREATE UNIQUE INDEX statements-func (r *namingUKConventionRule) handleIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-+func (r *namingUKConventionRule) handleIndexStmt(n *ast.IndexStmt) {// Only check UNIQUE indexes- if ctx.Opt_unique() == nil || ctx.Opt_unique().UNIQUE() == nil {+ if !n.Unique {return}- indexName := ""- if ctx.Name() != nil {- indexName = pgparser.NormalizePostgreSQLName(ctx.Name())- }-- tableName := ""- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(ctx.Relation_expr().Qualified_name())- }-- // Extract column list- var columnList []string- if ctx.Index_params() != nil {- allParams := ctx.Index_params().AllIndex_elem()- for _, param := range allParams {- if param.Colid() != nil {- colName := pgparser.NormalizePostgreSQLColid(param.Colid())- columnList = append(columnList, colName)- }- }- }+ indexName := n.Idxname+ tableName := omniTableName(n.Relation)+ columnList := omniIndexColumns(n)metaData := map[string]string{advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),advisor.TableNameTemplateToken: tableName,}-- r.checkUniqueKeyName(indexName, tableName, metaData, ctx.GetStart().GetLine())+ r.checkUniqueKeyName(indexName, tableName, metaData)}-// handleCreatestmt handles CREATE TABLE with UNIQUE constraints-func (r *namingUKConventionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- qualifiedNames := ctx.AllQualified_name()- if len(qualifiedNames) == 0 {- return- }+func (r *namingUKConventionRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ cols, constraints := omniTableElements(n)- tableName := extractTableName(qualifiedNames[0])- if tableName == "" {- return- }+ // Check table-level UNIQUE constraints+ for _, c := range constraints {+ if c.Contype == ast.CONSTR_UNIQUE && c.Conname != "" {+ columnList := omniConstraintColumns(c)- // Check table-level constraints- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- if elem.Tableconstraint() != nil {- r.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())+ // UNIQUE USING INDEX+ if c.Indexname != "" {+ columnList = r.lookupIndexColumns("", tableName, c.Indexname)}- // Check column-level constraints- if elem.ColumnDef() != nil {- r.checkColumnDef(elem.ColumnDef(), tableName)++ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,}+ r.checkUniqueKeyName(c.Conname, tableName, metaData)}}-}-// handleAltertablestmt handles ALTER TABLE statements-func (r *namingUKConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return+ // Check column-level UNIQUE constraints+ for _, col := range cols {+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_UNIQUE && c.Conname != "" {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: col.Colname,+ advisor.TableNameTemplateToken: tableName,+ }+ r.checkUniqueKeyName(c.Conname, tableName, metaData)+ }+ }}+}- tableName := extractTableName(ctx.Relation_expr().Qualified_name())- if tableName == "" {- return- }+func (r *namingUKConventionRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // ADD CONSTRAINT- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- r.checkTableConstraint(cmd.Tableconstraint(), tableName, ctx.GetStart().GetLine())+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AddConstraint {+ c, ok := cmd.Def.(*ast.Constraint)+ if !ok || c.Contype != ast.CONSTR_UNIQUE {+ continue}- // ADD COLUMN with constraints- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- r.checkColumnDef(cmd.ColumnDef(), tableName)+ if c.Conname == "" {+ continue}- }- }+ columnList := omniConstraintColumns(c)- // Note: ALTER TABLE ... RENAME CONSTRAINT is handled in handleRenamestmt- // because PostgreSQL parser treats "ALTER TABLE t RENAME CONSTRAINT old TO new"- // as a rename statement, not as an alter_table_cmd-}--// handleRenamestmt handles ALTER INDEX ... RENAME TO and ALTER TABLE ... RENAME CONSTRAINT statements-func (r *namingUKConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }+ // UNIQUE USING INDEX+ if c.Indexname != "" {+ columnList = r.lookupIndexColumns("", tableName, c.Indexname)+ }- // Check for ALTER INDEX ... RENAME TO- if ctx.INDEX() != nil && ctx.TO() != nil {- allNames := ctx.AllName()- if len(allNames) < 1 {- return+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ r.checkUniqueKeyName(c.Conname, tableName, metaData)}- // Get old index name from qualified_name- var oldIndexName string- if ctx.Qualified_name() != nil {- parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Qualified_name())- if len(parts) > 0 {- oldIndexName = parts[len(parts)-1]+ // ADD COLUMN with inline UNIQUE constraint+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AddColumn {+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok {+ continue+ }+ for _, c := range omniColumnConstraints(colDef) {+ if c.Contype == ast.CONSTR_UNIQUE && c.Conname != "" {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: colDef.Colname,+ advisor.TableNameTemplateToken: tableName,+ }+ r.checkUniqueKeyName(c.Conname, tableName, metaData)+ }}}+ }+}- // Get new index name from the name after TO- newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])+func (r *namingUKConventionRule) handleRenameStmt(n *ast.RenameStmt) {+ // ALTER INDEX ... RENAME TO+ if n.RenameType == ast.OBJECT_INDEX {+ oldIndexName := ""+ if n.Relation != nil {+ oldIndexName = n.Relation.Relname+ }+ newIndexName := n.Newname- // Look up the index in catalog to determine if it's a unique keyif r.originalMetadata != nil && oldIndexName != "" {tableName, index := r.findIndex("", "", oldIndexName)if index != nil && index.GetProto().GetUnique() && !index.GetProto().GetPrimary() {r.checkUniqueKeyName(newIndexName, tableName, map[string]string{advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),advisor.TableNameTemplateToken: tableName,- }, ctx.GetStart().GetLine())+ })}}}- // Check for ALTER TABLE ... RENAME CONSTRAINT- if ctx.CONSTRAINT() != nil && ctx.TO() != nil && r.originalMetadata != nil {- allNames := ctx.AllName()- if len(allNames) >= 2 {- oldConstraintName := pgparser.NormalizePostgreSQLName(allNames[0])- newConstraintName := pgparser.NormalizePostgreSQLName(allNames[1])-- // Get table name from the statement- var tableName, schemaName string- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(ctx.Relation_expr().Qualified_name())- schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())- }-- // Check if this is a unique key constraint in catalog- foundTableName, index := r.findIndex(schemaName, tableName, oldConstraintName)- if index != nil && index.GetProto().GetUnique() && !index.GetProto().GetPrimary() {- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),- advisor.TableNameTemplateToken: foundTableName,- }- r.checkUniqueKeyName(newConstraintName, foundTableName, metaData, ctx.GetStart().GetLine())- }+ // ALTER TABLE ... RENAME CONSTRAINT+ if n.RenameType == ast.OBJECT_TABCONSTRAINT && r.originalMetadata != nil {+ tableName := omniTableName(n.Relation)+ schemaName := ""+ if n.Relation != nil {+ schemaName = n.Relation.Schemaname}- }-}--func (r *namingUKConventionRule) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {- if constraint == nil {- return- }-- constraintName := ""- if constraint.Name() != nil {- constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())- }-- if constraint.Constraintelem() != nil {- elem := constraint.Constraintelem()-- // UNIQUE constraint- if elem.UNIQUE() != nil {- var columnList []string- if elem.Columnlist() != nil {- allColumns := elem.Columnlist().AllColumnElem()- for _, col := range allColumns {- if col.Colid() != nil {- colName := pgparser.NormalizePostgreSQLColid(col.Colid())- columnList = append(columnList, colName)- }- }- } else if elem.Existingindex() != nil && elem.Existingindex().Name() != nil {- // Handle UNIQUE USING INDEX - the column list is in the existing index- indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())- schema := r.originalMetadata.GetSchemaMetadata(normalizeSchemaName(""))- var index *model.IndexMetadata- if schema != nil {- table := schema.GetTable(tableName)- if table != nil {- index = table.GetIndex(indexName)- }- }- if index != nil {- columnList = index.GetProto().GetExpressions()- }- }-- // Only check if we have a constraint name (unnamed constraints are auto-generated)- if constraintName != "" {- metaData := map[string]string{- advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),- advisor.TableNameTemplateToken: tableName,- }- r.checkUniqueKeyName(constraintName, tableName, metaData, line)+ oldConstraintName := n.Subname+ newConstraintName := n.Newname++ foundTableName, index := r.findIndex(schemaName, tableName, oldConstraintName)+ if index != nil && index.GetProto().GetUnique() && !index.GetProto().GetPrimary() {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.GetProto().GetExpressions(), "_"),+ advisor.TableNameTemplateToken: foundTableName,}+ r.checkUniqueKeyName(newConstraintName, foundTableName, metaData)}}}-func (r *namingUKConventionRule) checkColumnDef(columndef parser.IColumnDefContext, tableName string) {- if columndef == nil {- return+func (r *namingUKConventionRule) lookupIndexColumns(schemaName, tableName, indexName string) []string {+ if r.originalMetadata == nil || indexName == "" {+ return nil}-- colName := ""- if columndef.Colid() != nil {- colName = pgparser.NormalizePostgreSQLColid(columndef.Colid())+ schema := r.originalMetadata.GetSchemaMetadata(normalizeSchemaName(schemaName))+ if schema == nil {+ return nil}-- // Check column-level constraints- if columndef.Colquallist() != nil {- allQuals := columndef.Colquallist().AllColconstraint()- for _, qual := range allQuals {- if qual.Colconstraintelem() != nil {- elem := qual.Colconstraintelem()- // Check for UNIQUE constraint- if elem.UNIQUE() != nil {- // Column-level unique constraints with names- constraintName := ""- if qual.Name() != nil {- constraintName = pgparser.NormalizePostgreSQLName(qual.Name())- }-- // Only check if we have a constraint name- if constraintName != "" {- metaData := map[string]string{- advisor.ColumnListTemplateToken: colName,- advisor.TableNameTemplateToken: tableName,- }- r.checkUniqueKeyName(constraintName, tableName, metaData, qual.GetStart().GetLine())- }- }- }- }+ table := schema.GetTable(tableName)+ if table == nil {+ return nil+ }+ index := table.GetIndex(indexName)+ if index != nil {+ return index.GetProto().GetExpressions()}+ return nil}-func (r *namingUKConventionRule) checkUniqueKeyName(indexName, tableName string, metaData map[string]string, line int) {- regex, err := r.getTemplateRegexp(metaData)+func (r *namingUKConventionRule) checkUniqueKeyName(indexName, tableName string, metaData map[string]string) {+ line := r.FindLineByName(indexName)++ regex, err := getTemplateRegexp(r.format, r.templateList, metaData)if err != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Internal.Int32(),Title: "Internal error for unique key naming convention rule",Content: fmt.Sprintf("Failed to compile regex for unique key naming convention: %v", err),@@ -392,12 +268,12 @@ func (r *namingUKConventionRule) checkUniqueKeyName(indexName, tableName string,if !regex.MatchString(indexName) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingUKConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf(`Unique key in table "%s" mismatches the naming convention, expect %q but found "%s"`, tableName, regex, indexName),StartPosition: &storepb.Position{- Line: int32(line),+ Line: line,Column: 0,},})@@ -405,28 +281,18 @@ func (r *namingUKConventionRule) checkUniqueKeyName(indexName, tableName string,if r.maxLength > 0 && len(indexName) > r.maxLength {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.NamingUKConventionMismatch.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf(`Unique key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, indexName, tableName, r.maxLength),StartPosition: &storepb.Position{- Line: int32(line),+ Line: line,Column: 0,},})}}-func (r *namingUKConventionRule) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {- template := r.format- for _, key := range r.templateList {- if token, ok := tokens[key]; ok {- template = strings.ReplaceAll(template, key, token)- }- }- return regexp.Compile(template)-}-// findIndex returns index found in catalogs, nil if not found.func (r *namingUKConventionRule) findIndex(schemaName string, tableName string, indexName string) (string, *model.IndexMetadata) {if r.originalMetadata == nil {diff --git a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.goindex 8ce421a1ba..3d446e496f 100644--- a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go+++ b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go@@ -3,14 +3,11 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -33,157 +30,48 @@ func (*StatementAddCheckNotValidAdvisor) Check(_ context.Context, checkCtx advis}rule := &statementAddCheckNotValidRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementAddCheckNotValidRule struct {- BaseRule+ OmniBaseRule}func (*statementAddCheckNotValidRule) Name() string {return "statement_add_check_not_valid"}-func (r *statementAddCheckNotValidRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Colconstraint":- r.handleColconstraint(ctx)- case "Tableconstraint":- r.handleTableconstraint(ctx)- default:- }- return nil-}--func (*statementAddCheckNotValidRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleColconstraint handles column-level constraints in ALTER TABLE ADD CONSTRAINT ... CHECK-// This handles the case where CHECK constraint is parsed as a column-level constraint-func (r *statementAddCheckNotValidRule) handleColconstraint(ctx antlr.ParserRuleContext) {- colCtx, ok := ctx.(*parser.ColconstraintContext)+func (r *statementAddCheckNotValidRule) OnStatement(node ast.Node) {+ alter, ok := node.(*ast.AlterTableStmt)if !ok {return}- // Check if this is within an ALTER TABLE statement- parent := colCtx.GetParent()- var alterTableCtx *parser.AltertablestmtContext- for parent != nil {- if altCtx, ok := parent.(*parser.AltertablestmtContext); ok {- alterTableCtx = altCtx- if !isTopLevel(alterTableCtx.GetParent()) {- return- }- break+ for _, cmd := range omniAlterTableCmds(alter) {+ if ast.AlterTableType(cmd.Subtype) != ast.AT_AddConstraint {+ continue}- parent = parent.GetParent()- }-- // Only process if we're within an ALTER TABLE- if alterTableCtx == nil {- return- }-- // Check if this is a CHECK constraint- if colCtx.Colconstraintelem() != nil {- constraintElem := colCtx.Colconstraintelem()- if constraintElem.CHECK() != nil {- // For column-level constraints, NOT VALID would be in Constraintattr- // But since this is parsed as a column constraint, it won't have NOT VALID- // (when NOT VALID is present, it's parsed as a table constraint)+ constraint, ok := cmd.Def.(*ast.Constraint)+ if !ok || constraint.Contype != ast.CONSTR_CHECK {+ continue+ }+ if !constraint.SkipValidation {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementAddCheckWithValidation.Int32(),- Title: r.title,+ Title: r.Title,Content: "Adding check constraints with validation will block reads and writes. You can add check constraints not valid and then validate separately",StartPosition: &storepb.Position{- Line: int32(alterTableCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}}--// handleTableconstraint handles table-level constraints in ALTER TABLE ADD CONSTRAINT ... CHECK-// This handles the case where CHECK constraint is parsed as a table-level constraint (e.g., with NOT VALID)-func (r *statementAddCheckNotValidRule) handleTableconstraint(ctx antlr.ParserRuleContext) {- tableCtx, ok := ctx.(*parser.TableconstraintContext)- if !ok {- return- }-- // Check if this is within an ALTER TABLE statement- parent := tableCtx.GetParent()- var alterTableCtx *parser.AltertablestmtContext- for parent != nil {- if altCtx, ok := parent.(*parser.AltertablestmtContext); ok {- alterTableCtx = altCtx- if !isTopLevel(alterTableCtx.GetParent()) {- return- }- break- }- parent = parent.GetParent()- }-- // Only process if we're within an ALTER TABLE- if alterTableCtx == nil {- return- }-- // Check if this is a CHECK constraint- if tableCtx.Constraintelem() != nil {- constraintElem := tableCtx.Constraintelem()- if constraintElem.CHECK() != nil {- // Check if NOT VALID is specified- hasNotValid := false- if constraintElem.Constraintattributespec() != nil {- allAttrs := constraintElem.Constraintattributespec().AllConstraintattributeElem()- for _, attr := range allAttrs {- // Check for NOT VALID- if attr.NOT() != nil && attr.VALID() != nil {- hasNotValid = true- break- }- }- }-- if !hasNotValid {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementAddCheckWithValidation.Int32(),- Title: r.title,- Content: "Adding check constraints with validation will block reads and writes. You can add check constraints not valid and then validate separately",- StartPosition: &storepb.Position{- Line: int32(alterTableCtx.GetStart().GetLine()),- Column: 0,- },- })- }- }- }-}diff --git a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.goindex e27c89e855..6e517fc82e 100644--- a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go+++ b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go@@ -3,14 +3,11 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -33,111 +30,45 @@ func (*StatementAddFKNotValidAdvisor) Check(_ context.Context, checkCtx advisor.}rule := &statementAddFKNotValidRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementAddFKNotValidRule struct {- BaseRule+ OmniBaseRule}func (*statementAddFKNotValidRule) Name() string {return "statement_add_fk_not_valid"}-func (r *statementAddFKNotValidRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Altertablestmt":- r.handleAltertablestmt(ctx)- default:- // Do nothing for other node types- }- return nil-}--func (*statementAddFKNotValidRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementAddFKNotValidRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- altertablestmtCtx, ok := ctx.(*parser.AltertablestmtContext)+func (r *statementAddFKNotValidRule) OnStatement(node ast.Node) {+ alter, ok := node.(*ast.AlterTableStmt)if !ok {return}- if !isTopLevel(altertablestmtCtx.GetParent()) {- return- }-- if altertablestmtCtx.Alter_table_cmds() == nil {- return- }-- allCmds := altertablestmtCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // Check for ADD + something- if cmd.ADD_P() == nil {+ for _, cmd := range omniAlterTableCmds(alter) {+ if ast.AlterTableType(cmd.Subtype) != ast.AT_AddConstraint {continue}-- // Check for Tableconstraint- if cmd.Tableconstraint() == nil {- continue- }-- constraint := cmd.Tableconstraint()- if constraint.Constraintelem() == nil {+ constraint, ok := cmd.Def.(*ast.Constraint)+ if !ok || constraint.Contype != ast.CONSTR_FOREIGN {continue}-- elem := constraint.Constraintelem()-- // Check if this is a FOREIGN KEY constraint- if elem.FOREIGN() == nil || elem.KEY() == nil {- continue- }-- // Check if NOT VALID is present- hasNotValid := false- if elem.Constraintattributespec() != nil {- allAttrs := elem.Constraintattributespec().AllConstraintattributeElem()- for _, attr := range allAttrs {- if attr.NOT() != nil && attr.VALID() != nil {- hasNotValid = true- break- }- }- }-- // If NOT VALID is not present, this is a problem- if !hasNotValid {+ if !constraint.SkipValidation {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementAddFKWithValidation.Int32(),- Title: r.title,+ Title: r.Title,Content: "Adding foreign keys with validation will block reads and writes. You can add check foreign keys not valid and then validate separately",StartPosition: &storepb.Position{- Line: int32(altertablestmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.goindex a7aca38260..87d4f47cdb 100644--- a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go@@ -5,15 +5,14 @@ import ("database/sql""fmt"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql""github.com/pkg/errors"+ "github.com/bytebase/omni/pg/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"- "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -44,114 +43,55 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advreturn nil, nil}- var adviceList []*storepb.Advice- var preExecutions []string- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &statementAffectedRowLimitRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- maxRow: int(numberPayload.Number),- ctx: ctx,- driver: checkCtx.Driver,- tenantMode: checkCtx.TenantMode,- preExecutions: preExecutions,- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)- preExecutions = rule.preExecutions+ rule := &statementAffectedRowLimitRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },+ maxRow: int(numberPayload.Number),+ ctx: ctx,+ driver: checkCtx.Driver,+ tenantMode: checkCtx.TenantMode,}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementAffectedRowLimitRule struct {- BaseRule+ OmniBaseRulemaxRow intdriver *sql.DBctx context.ContextexplainCount intpreExecutions []stringtenantMode bool- tokens *antlr.CommonTokenStream}func (*statementAffectedRowLimitRule) Name() string {- return "statement_affected_row_limit"+ return string(storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT)}-func (r *statementAffectedRowLimitRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Variablesetstmt":- if c, ok := ctx.(*parser.VariablesetstmtContext); ok {- r.handleVariablesetstmt(c)- }- case "Updatestmt":- if c, ok := ctx.(*parser.UpdatestmtContext); ok {- r.handleUpdatestmt(c)- }- case "Deletestmt":- if c, ok := ctx.(*parser.DeletestmtContext); ok {- r.handleDeletestmt(c)+func (r *statementAffectedRowLimitRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.VariableSetStmt:+ if omniIsRoleOrSearchPathSet(n) {+ r.preExecutions = append(r.preExecutions, r.TrimmedStmtText())}+ case *ast.UpdateStmt, *ast.DeleteStmt:+ r.checkAffectedRows()default:- // Do nothing for other node types}- return nil-}--func (*statementAffectedRowLimitRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementAffectedRowLimitRule) handleVariablesetstmt(ctx *parser.VariablesetstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- r.preExecutions = appendSessionPreExecutionStatements(r.preExecutions, r.tokens, ctx)-}--func (r *statementAffectedRowLimitRule) handleUpdatestmt(ctx *parser.UpdatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- r.checkAffectedRows(ctx)-}--func (r *statementAffectedRowLimitRule) handleDeletestmt(ctx *parser.DeletestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- r.checkAffectedRows(ctx)}-func (r *statementAffectedRowLimitRule) checkAffectedRows(ctx antlr.ParserRuleContext) {- // Check if we've hit the maximum number of EXPLAIN queries+func (r *statementAffectedRowLimitRule) checkAffectedRows() {if r.explainCount >= common.MaximumLintExplainSize {return}r.explainCount++- // Get the statement text- statementText := getTextFromTokens(r.tokens, ctx)+ statementText := r.TrimmedStmtText()- // Run EXPLAIN to get estimated row countres, err := advisor.Query(r.ctx, advisor.QueryContext{TenantMode: r.tenantMode,PreExecutions: r.preExecutions,@@ -159,12 +99,12 @@ func (r *statementAffectedRowLimitRule) checkAffectedRows(ctx antlr.ParserRuleCoif err != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.InsertTooManyRows.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("\"%s\" dry runs failed: %s", statementText, err.Error()),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})@@ -174,12 +114,12 @@ func (r *statementAffectedRowLimitRule) checkAffectedRows(ctx antlr.ParserRuleCorowCount, err := getAffectedRows(res)if err != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.Internal.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("failed to get row count for \"%s\": %s", statementText, err.Error()),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})@@ -188,12 +128,12 @@ func (r *statementAffectedRowLimitRule) checkAffectedRows(ctx antlr.ParserRuleCoif rowCount > int64(r.maxRow) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementAffectedRowExceedsLimit.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("The statement \"%s\" affected %d rows (estimated). The count exceeds %d.", statementText, rowCount, r.maxRow),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.goindex 54ac6fcbed..6063b872f2 100644--- a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go+++ b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go@@ -3,14 +3,11 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -30,112 +27,47 @@ func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.return nil, err}- rule := &StatementCheckSetRoleVariableRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ rule := &statementCheckSetRoleVariableRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }+ advice := RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})if !rule.hasSetRole {- rule.AddAdvice(&storepb.Advice{+ advice = append(advice, &storepb.Advice{Status: level,Code: code.StatementCheckSetRoleVariable.Int32(),- Title: rule.title,+ Title: rule.Title,Content: "No SET ROLE statement found.",StartPosition: nil,})}- return checker.GetAdviceList(), nil+ return advice, nil}-type StatementCheckSetRoleVariableRule struct {- BaseRule+type statementCheckSetRoleVariableRule struct {+ OmniBaseRulehasSetRole boolfoundNonSetStmt bool}-// Name returns the rule name.-func (*StatementCheckSetRoleVariableRule) Name() string {+func (*statementCheckSetRoleVariableRule) Name() string {return "statement.check-set-role-variable"}-// OnEnter is called when entering a parse tree node.-func (r *StatementCheckSetRoleVariableRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Variablesetstmt":- r.handleVariablesetstmt(ctx.(*parser.VariablesetstmtContext))- default:- r.handleEveryRule(ctx)- }- return nil-}--// OnExit is called when exiting a parse tree node.-func (*StatementCheckSetRoleVariableRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleVariablesetstmt handles SET statements-func (r *StatementCheckSetRoleVariableRule) handleVariablesetstmt(ctx *parser.VariablesetstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // If we already found a non-SET statement, skip this- if r.foundNonSetStmt {- return- }-- // Check if this is a SET ROLE statement- setRest := ctx.Set_rest()- if setRest != nil {- setRestMore := setRest.Set_rest_more()- if setRestMore != nil && setRestMore.ROLE() != nil {+func (r *statementCheckSetRoleVariableRule) OnStatement(node ast.Node) {+ if setStmt, ok := node.(*ast.VariableSetStmt); ok {+ if !r.foundNonSetStmt && omniIsRoleOrSearchPathSet(setStmt) {r.hasSetRole = true}- }-}--// handleEveryRule is called for every rule entry to detect non-SET statements-func (r *StatementCheckSetRoleVariableRule) handleEveryRule(ctx antlr.ParserRuleContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // If we already found a non-SET statement, no need to continue checking- if r.foundNonSetStmt {return}- // Check if this is a non-SET statement at the top level- // We only care about statements that are not VariablesetstmtContext- if _, isSetStmt := ctx.(*parser.VariablesetstmtContext); !isSetStmt {- // Check if this is a statement node (not structural nodes like Stmt, Root, etc.)- switch ctx.(type) {- case *parser.RootContext, *parser.StmtblockContext, *parser.StmtmultiContext, *parser.StmtContext:- // These are structural nodes, not actual statements- return- default:- // This is a non-SET statement- r.foundNonSetStmt = true- }- }+ // Any non-SET statement marks that SET ROLE must have already appeared.+ r.foundNonSetStmt = true}diff --git a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.goindex c50b4caad8..91b9f3615c 100644--- a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go+++ b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go@@ -3,14 +3,11 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -31,77 +28,42 @@ func (*StatementCreateSpecifySchema) Check(_ context.Context, checkCtx advisor.C}rule := &statementCreateSpecifySchemaRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementCreateSpecifySchemaRule struct {- BaseRule+ OmniBaseRule}func (*statementCreateSpecifySchemaRule) Name() string {return "statement_create_specify_schema"}-func (r *statementCreateSpecifySchemaRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx)+func (r *statementCreateSpecifySchemaRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ if n.Relation != nil && n.Relation.Schemaname == "" {+ r.addMissingSchemaAdvice("Table")+ }default:- // Do nothing for other node types}- return nil-}--func (*statementCreateSpecifySchemaRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-// handleCreatestmt handles CREATE TABLE-func (r *statementCreateSpecifySchemaRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createstmtCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }-- if !isTopLevel(createstmtCtx.GetParent()) {- return- }-- allQualifiedNames := createstmtCtx.AllQualified_name()- if len(allQualifiedNames) > 0 {- schemaName := extractSchemaName(allQualifiedNames[0])- if schemaName == "" {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementCreateWithoutSchemaName.Int32(),- Title: r.title,- Content: "Table schema should be specified.",- StartPosition: &storepb.Position{- Line: int32(createstmtCtx.GetStart().GetLine()),- Column: 0,- },- })- }- }+func (r *statementCreateSpecifySchemaRule) addMissingSchemaAdvice(objectType string) {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementCreateWithoutSchemaName.Int32(),+ Title: r.Title,+ Content: objectType + " schema should be specified.",+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.goindex a0f6ebc9c4..718ea86d1c 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go@@ -3,14 +3,11 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -33,91 +30,59 @@ func (*StatementDisallowAddColumnWithDefaultAdvisor) Check(_ context.Context, ch}rule := &statementDisallowAddColumnWithDefaultRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowAddColumnWithDefaultRule struct {- BaseRule+ OmniBaseRule}-// Name returns the rule name.func (*statementDisallowAddColumnWithDefaultRule) Name() string {return "statement.disallow-add-column-with-default"}-// OnEnter is called when the parser enters a rule context.-func (r *statementDisallowAddColumnWithDefaultRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- default:- // Do nothing for other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*statementDisallowAddColumnWithDefaultRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementDisallowAddColumnWithDefaultRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {+func (r *statementDisallowAddColumnWithDefaultRule) OnStatement(node ast.Node) {+ alter, ok := node.(*ast.AlterTableStmt)+ if !ok {return}- // Check all alter table commands- if ctx.Alter_table_cmds() != nil {- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // Check for ADD COLUMN- if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {- columnDef := cmd.ColumnDef()- // Check if the column has a DEFAULT constraint- if columnDef.Colquallist() != nil {- allConstraints := columnDef.Colquallist().AllColconstraint()- for _, constraint := range allConstraints {- if constraint.Colconstraintelem() != nil {- constraintElem := constraint.Colconstraintelem()- // Check for DEFAULT constraint- if constraintElem.DEFAULT() != nil {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementAddColumnWithDefault.Int32(),- Title: r.title,- Content: "Adding column with DEFAULT will locked the whole table and rewriting each rows",- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- return- }- }- }- }+ for _, cmd := range omniAlterTableCmds(alter) {+ if ast.AlterTableType(cmd.Subtype) != ast.AT_AddColumn {+ continue+ }+ colDef, ok := cmd.Def.(*ast.ColumnDef)+ if !ok {+ continue+ }+ if colDef.RawDefault != nil {+ r.addAdvice()+ return+ }+ for _, c := range omniColumnConstraints(colDef) {+ if c.Contype == ast.CONSTR_DEFAULT {+ r.addAdvice()+ return}}}}++func (r *statementDisallowAddColumnWithDefaultRule) addAdvice() {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementAddColumnWithDefault.Int32(),+ Title: r.Title,+ Content: "Adding column with DEFAULT will locked the whole table and rewriting each rows",+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.goindex 6c4a0638be..de9944977c 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go@@ -4,15 +4,11 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")var (@@ -35,85 +31,43 @@ func (*StatementDisallowAddNotNullAdvisor) Check(_ context.Context, checkCtx adv}rule := &statementDisallowAddNotNullRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowAddNotNullRule struct {- BaseRule+ OmniBaseRule}func (*statementDisallowAddNotNullRule) Name() string {return "statement_disallow_add_not_null"}-func (r *statementDisallowAddNotNullRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Altertablestmt":- r.handleAltertablestmt(ctx)- default:- // Do nothing for other node types- }- return nil-}--func (*statementDisallowAddNotNullRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// handleAltertablestmt handles ALTER TABLE ALTER COLUMN SET NOT NULL-func (r *statementDisallowAddNotNullRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- altertablestmtCtx, ok := ctx.(*parser.AltertablestmtContext)+func (r *statementDisallowAddNotNullRule) OnStatement(node ast.Node) {+ alter, ok := node.(*ast.AlterTableStmt)if !ok {return}- if !isTopLevel(altertablestmtCtx.GetParent()) {- return- }-- // Check all alter table commands- if altertablestmtCtx.Alter_table_cmds() != nil {- allCmds := altertablestmtCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- // Check for ALTER COLUMN ... SET NOT NULL- if cmd.ALTER() != nil && cmd.SET() != nil && cmd.NOT() != nil && cmd.NULL_P() != nil {- // Get the column name- allColIDs := cmd.AllColid()- if len(allColIDs) > 0 {- columnName := pgparser.NormalizePostgreSQLColid(allColIDs[0])- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementAddNotNull.Int32(),- Title: r.title,- Content: fmt.Sprintf("Setting NOT NULL will block reads and writes. You can use CHECK (%q IS NOT NULL) instead", columnName),- StartPosition: &storepb.Position{- Line: int32(altertablestmtCtx.GetStart().GetLine()),- Column: 0,- },- })- }- }+ for _, cmd := range omniAlterTableCmds(alter) {+ if ast.AlterTableType(cmd.Subtype) != ast.AT_SetNotNull {+ continue}+ columnName := cmd.Name+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementAddNotNull.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Setting NOT NULL will block reads and writes. You can use CHECK (%q IS NOT NULL) instead", columnName),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.goindex b2f5769d6c..94da383c79 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go@@ -4,14 +4,11 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -33,78 +30,46 @@ func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisorreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &statementDisallowCommitRule{- BaseRule: BaseRule{level: level, title: checkCtx.Rule.Type.String()},- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &statementDisallowCommitRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowCommitRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRule}-// Name returns the rule name for logging/debugging.func (*statementDisallowCommitRule) Name() string {return "statement_disallow_commit"}-// OnEnter is called when entering a parse tree node.-func (r *statementDisallowCommitRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType != "Transactionstmt" {- return nil- }-- transactionCtx, ok := ctx.(*parser.TransactionstmtContext)+func (r *statementDisallowCommitRule) OnStatement(node ast.Node) {+ txn, ok := node.(*ast.TransactionStmt)if !ok {- return nil+ return}- if !isTopLevel(transactionCtx.GetParent()) {- return nil+ if txn.Kind != ast.TRANS_STMT_COMMIT {+ return}- // Check if this is a COMMIT statement- if transactionCtx.COMMIT() == nil {- return nil- }-- stmtText := getTextFromTokens(r.tokens, transactionCtx)+ stmtText := r.TrimmedStmtText()if stmtText == "" {stmtText = "<unknown statement>"}r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementDisallowCommit.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("Commit is not allowed, related statement: \"%s\"", stmtText),StartPosition: &storepb.Position{- Line: int32(transactionCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})-- return nil-}--// OnExit is called when exiting a parse tree node.-func (*statementDisallowCommitRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go b/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.goindex fba3ea4c71..10b1b46f94 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go@@ -3,15 +3,11 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"+ "github.com/bytebase/omni/pg/ast"- parser "github.com/bytebase/parser/postgresql"-- "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"- "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -33,101 +29,79 @@ func (*StatementDisallowOnDelCascadeAdvisor) Check(_ context.Context, checkCtx areturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &statementDisallowOnDelCascadeRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }-- checker := NewGenericChecker([]Rule{rule})- rule.SetBaseLine(stmtInfo.BaseLine())- checker.SetBaseLine(stmtInfo.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)-- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &statementDisallowOnDelCascadeRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowOnDelCascadeRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRule}-// Name returns the rule name.func (*statementDisallowOnDelCascadeRule) Name() string {return "statement.disallow-on-delete-cascade"}-// OnEnter is called when the parser enters a rule context.-func (r *statementDisallowOnDelCascadeRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Key_delete":- r.handleKeyDelete(ctx.(*parser.Key_deleteContext))+func (r *statementDisallowOnDelCascadeRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.checkCreateStmt(n)+ case *ast.AlterTableStmt:+ r.checkAlterTableStmt(n)default:- // Do nothing for other node types}- return nil}-// OnExit is called when the parser exits a rule context.-func (*statementDisallowOnDelCascadeRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementDisallowOnDelCascadeRule) handleKeyDelete(ctx *parser.Key_deleteContext) {- // Check if this has CASCADE as the key_action- if ctx.Key_action() != nil {- keyAction := ctx.Key_action()- // Check if this is CASCADE- if keyAction.CASCADE() != nil {- // Find the top-level statement context- var stmtCtx antlr.ParserRuleContext- current := ctx.GetParent()- for current != nil {- if isTopLevel(current) {- if prc, ok := current.(antlr.ParserRuleContext); ok {- stmtCtx = prc- }- break- }- current = current.GetParent()+func (r *statementDisallowOnDelCascadeRule) checkCreateStmt(create *ast.CreateStmt) {+ _, constraints := omniTableElements(create)+ for _, c := range constraints {+ if c.Contype == ast.CONSTR_FOREIGN && c.FkDelaction == 'c' {+ r.addCascadeAdvice()+ return+ }+ }+ // Also check column-level FK constraints.+ cols, _ := omniTableElements(create)+ for _, col := range cols {+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_FOREIGN && c.FkDelaction == 'c' {+ r.addCascadeAdvice()+ return}+ }+ }+}- if stmtCtx != nil {- // Note: To match legacy pg-query behavior, we need to use GetLine() - 1- // The legacy advisor uses pg_query's stmt_location which points to the position- // right before the statement (often a newline), while ANTLR's GetLine() points- // to the actual line where the statement starts. This creates an off-by-one- // when there are statements before the CREATE TABLE.- line := stmtCtx.GetStart().GetLine() - 1- if line < 1 {- line = 1- }- statementText := getTextFromTokens(r.tokens, stmtCtx)- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementDisallowCascade.Int32(),- Title: r.title,- Content: "The CASCADE option is not permitted for ON DELETE clauses",- StartPosition: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{- Line: int32(line),- Column: 0,- }, statementText),- })- }+func (r *statementDisallowOnDelCascadeRule) checkAlterTableStmt(alter *ast.AlterTableStmt) {+ for _, cmd := range omniAlterTableCmds(alter) {+ if ast.AlterTableType(cmd.Subtype) != ast.AT_AddConstraint {+ continue+ }+ constraint, ok := cmd.Def.(*ast.Constraint)+ if !ok {+ continue+ }+ if constraint.Contype == ast.CONSTR_FOREIGN && constraint.FkDelaction == 'c' {+ r.addCascadeAdvice()+ return}}}++func (r *statementDisallowOnDelCascadeRule) addCascadeAdvice() {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementDisallowCascade.Int32(),+ Title: r.Title,+ Content: "The CASCADE option is not permitted for ON DELETE clauses",+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go b/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.goindex 2b45a73976..6fe8034095 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go@@ -3,14 +3,11 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -33,106 +30,46 @@ func (*StatementDisallowRemoveTblCascadeAdvisor) Check(_ context.Context, checkC}rule := &statementDisallowRemoveTblCascadeRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowRemoveTblCascadeRule struct {- BaseRule+ OmniBaseRule}-// Name returns the rule name.func (*statementDisallowRemoveTblCascadeRule) Name() string {return "statement.disallow-remove-table-cascade"}-// OnEnter is called when the parser enters a rule context.-func (r *statementDisallowRemoveTblCascadeRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Dropstmt":- r.handleDropstmt(ctx.(*parser.DropstmtContext))- case "Truncatestmt":- r.handleTruncatestmt(ctx.(*parser.TruncatestmtContext))+func (r *statementDisallowRemoveTblCascadeRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.DropStmt:+ if n.RemoveType == int(ast.OBJECT_TABLE) && ast.DropBehavior(n.Behavior) == ast.DROP_CASCADE {+ r.addCascadeAdvice()+ }+ case *ast.TruncateStmt:+ if n.Behavior == ast.DROP_CASCADE {+ r.addCascadeAdvice()+ }default:- // Do nothing for other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*statementDisallowRemoveTblCascadeRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementDisallowRemoveTblCascadeRule) handleDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is a DROP TABLE statement- if ctx.Object_type_any_name() == nil || ctx.Object_type_any_name().TABLE() == nil {- return- }-- // Check for CASCADE option- if r.hasCascadeOption(ctx.Opt_drop_behavior()) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementDisallowCascade.Int32(),- Title: r.title,- Content: "The use of CASCADE is not permitted when removing a table",- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- }-}--func (r *statementDisallowRemoveTblCascadeRule) handleTruncatestmt(ctx *parser.TruncatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check for CASCADE option- if r.hasCascadeOption(ctx.Opt_drop_behavior()) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementDisallowCascade.Int32(),- Title: r.title,- Content: "The use of CASCADE is not permitted when removing a table",- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })}}-// hasCascadeOption checks if the drop behavior is CASCADE-func (*statementDisallowRemoveTblCascadeRule) hasCascadeOption(ctx parser.IOpt_drop_behaviorContext) bool {- if ctx == nil {- return false- }- return ctx.CASCADE() != nil+func (r *statementDisallowRemoveTblCascadeRule) addCascadeAdvice() {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementDisallowCascade.Int32(),+ Title: r.Title,+ Content: "The use of CASCADE is not permitted when removing a table",+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}diff --git a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.goindex d8baa43d49..315a85e785 100644--- a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go+++ b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go@@ -5,14 +5,12 @@ import ("database/sql""fmt"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"- "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -45,46 +43,26 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Coreturn nil, nil}- var adviceList []*storepb.Advice- var preExecutions []string- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &statementDMLDryRunRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- ctx: ctx,- driver: checkCtx.Driver,- tenantMode: checkCtx.TenantMode,- preExecutions: preExecutions,- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)- preExecutions = rule.preExecutions+ rule := &statementDMLDryRunRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },+ ctx: ctx,+ driver: checkCtx.Driver,+ tenantMode: checkCtx.TenantMode,}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDMLDryRunRule struct {- BaseRule+ OmniBaseRuledriver *sql.DBctx context.ContextexplainCount intpreExecutions []stringtenantMode bool- tokens *antlr.CommonTokenStream}// Name returns the rule name.@@ -92,61 +70,19 @@ func (*statementDMLDryRunRule) Name() string {return "statement.dml-dry-run"}-// OnEnter is called when the parser enters a rule context.-func (r *statementDMLDryRunRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Variablesetstmt":- r.handleVariablesetstmt(ctx.(*parser.VariablesetstmtContext))- case "Insertstmt":- r.handleInsertstmt(ctx.(*parser.InsertstmtContext))- case "Updatestmt":- r.handleUpdatestmt(ctx.(*parser.UpdatestmtContext))- case "Deletestmt":- r.handleDeletestmt(ctx.(*parser.DeletestmtContext))+func (r *statementDMLDryRunRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.VariableSetStmt:+ if omniIsRoleOrSearchPathSet(n) {+ r.preExecutions = append(r.preExecutions, r.TrimmedStmtText())+ }+ case *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt:+ r.checkDMLDryRun()default:- // Do nothing for other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*statementDMLDryRunRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementDMLDryRunRule) handleVariablesetstmt(ctx *parser.VariablesetstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- r.preExecutions = appendSessionPreExecutionStatements(r.preExecutions, r.tokens, ctx)-}--func (r *statementDMLDryRunRule) handleInsertstmt(ctx *parser.InsertstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- r.checkDMLDryRun(ctx)-}--func (r *statementDMLDryRunRule) handleUpdatestmt(ctx *parser.UpdatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return}-- r.checkDMLDryRun(ctx)-}--func (r *statementDMLDryRunRule) handleDeletestmt(ctx *parser.DeletestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- r.checkDMLDryRun(ctx)}-func (r *statementDMLDryRunRule) checkDMLDryRun(ctx antlr.ParserRuleContext) {+func (r *statementDMLDryRunRule) checkDMLDryRun() {// Check if we've hit the maximum number of EXPLAIN queriesif r.explainCount >= common.MaximumLintExplainSize {return@@ -154,7 +90,7 @@ func (r *statementDMLDryRunRule) checkDMLDryRun(ctx antlr.ParserRuleContext) {r.explainCount++- statementText := getTextFromTokens(r.tokens, ctx)+ statementText := r.TrimmedStmtText()// Run EXPLAIN to perform dry run_, err := advisor.Query(r.ctx, advisor.QueryContext{@@ -164,12 +100,12 @@ func (r *statementDMLDryRunRule) checkDMLDryRun(ctx antlr.ParserRuleContext) {if err != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementDMLDryRunFailed.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("\"%s\" dry runs failed: %s", statementText, err.Error()),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.goindex 660705c40f..0d89a26226 100644--- a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go+++ b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go@@ -3,18 +3,14 @@ package pgimport ("context""fmt"- "strconv"- "strings""github.com/pkg/errors"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -41,224 +37,73 @@ func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advi}rule := &statementMaximumLimitValueRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},limitMaxValue: int(numberPayload.Number),}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementMaximumLimitValueRule struct {- BaseRule+ OmniBaseRulelimitMaxValue int}-// Name returns the rule name.func (*statementMaximumLimitValueRule) Name() string {- return "statement_maximum_limit_value"+ return string(storepb.SQLReviewRule_STATEMENT_MAXIMUM_LIMIT_VALUE)}-// OnEnter handles node entry events.-func (r *statementMaximumLimitValueRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType != "Selectstmt" {- return nil+func (r *statementMaximumLimitValueRule) OnStatement(node ast.Node) {+ sel, ok := node.(*ast.SelectStmt)+ if !ok {+ return}+ r.checkSelectStmt(sel)+}- selectstmtCtx, ok := ctx.(*parser.SelectstmtContext)- if !ok {- return nil+func (r *statementMaximumLimitValueRule) checkSelectStmt(sel *ast.SelectStmt) {+ if sel == nil {+ return}- if !isTopLevel(selectstmtCtx.GetParent()) {- return nil+ // For set operations, recurse into children.+ if sel.Op != ast.SETOP_NONE {+ r.checkSelectStmt(sel.Larg)+ r.checkSelectStmt(sel.Rarg)+ return}- // Check for LIMIT clause in the SELECT statement- limitValue := r.extractLimitValue(selectstmtCtx)+ limitValue := r.extractLimitValue(sel.LimitCount)if limitValue > 0 && limitValue > r.limitMaxValue {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementExceedMaximumLimitValue.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("The limit value %d exceeds the maximum allowed value %d", limitValue, r.limitMaxValue),StartPosition: &storepb.Position{- Line: int32(selectstmtCtx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}-- return nil-}--// OnExit handles node exit events.-func (*statementMaximumLimitValueRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--// extractLimitValue extracts the LIMIT value from a SELECT statement.-// Returns 0 if no LIMIT clause is found or if LIMIT is not a simple integer.-func (r *statementMaximumLimitValueRule) extractLimitValue(ctx *parser.SelectstmtContext) int {- if ctx == nil {- return 0- }-- // Try select_no_parens- if ctx.Select_no_parens() != nil {- return r.extractLimitFromSelectNoParens(ctx.Select_no_parens())- }-- // Try select_with_parens- if ctx.Select_with_parens() != nil {- return r.extractLimitFromSelectWithParens(ctx.Select_with_parens())- }-- return 0-}--// extractLimitFromSelectNoParens extracts LIMIT value from select_no_parens.-func (r *statementMaximumLimitValueRule) extractLimitFromSelectNoParens(ctx parser.ISelect_no_parensContext) int {- if ctx == nil {- return 0- }-- var selectLimit parser.ISelect_limitContext- if ctx.Select_limit() != nil {- selectLimit = ctx.Select_limit()- }- if ctx.Opt_select_limit() != nil {- selectLimit = ctx.Opt_select_limit().Select_limit()- }-- // Check for select_limit directly in select_no_parens- if selectLimit != nil {- return r.extractLimitFromSelectLimit(selectLimit)- }-- return 0-}--// extractLimitFromSelectWithParens extracts LIMIT value from select_with_parens.-func (r *statementMaximumLimitValueRule) extractLimitFromSelectWithParens(ctx parser.ISelect_with_parensContext) int {- if ctx == nil {- return 0- }-- // Recursively check inner select statements- if ctx.Select_no_parens() != nil {- return r.extractLimitFromSelectNoParens(ctx.Select_no_parens())- }-- if ctx.Select_with_parens() != nil {- return r.extractLimitFromSelectWithParens(ctx.Select_with_parens())- }-- return 0}-// extractLimitFromSelectLimit extracts LIMIT value from select_limit clause.-func (r *statementMaximumLimitValueRule) extractLimitFromSelectLimit(ctx parser.ISelect_limitContext) int {- if ctx == nil {+// extractLimitValue extracts the integer limit value from a LimitCount node.+func (*statementMaximumLimitValueRule) extractLimitValue(node ast.Node) int {+ if node == nil {return 0}-- // PostgreSQL supports several LIMIT formats:- // 1. LIMIT count- // 2. LIMIT count OFFSET start- // 3. OFFSET start (without LIMIT)- // 4. LIMIT ALL-- // Check for limit_clause- if ctx.Limit_clause() != nil {- limitClause := ctx.Limit_clause()- // Get the select_limit_value- if limitClause.Select_limit_value() != nil {- return r.extractLimitValueFromLimitValue(limitClause.Select_limit_value())- }- }-- // Check for offset_clause (which may have FETCH FIRST/NEXT)- if ctx.Offset_clause() != nil {- offsetClause := ctx.Offset_clause()- // Check for FETCH FIRST/NEXT syntax- if offsetClause.Select_fetch_first_value() != nil {- return r.extractLimitValueFromFetchFirst(offsetClause.Select_fetch_first_value())+ switch n := node.(type) {+ case *ast.Integer:+ return int(n.Ival)+ case *ast.A_Const:+ if iv, ok := n.Val.(*ast.Integer); ok {+ return int(iv.Ival)}+ default:}-- return 0-}--// extractLimitValueFromLimitValue extracts integer value from select_limit_value.-func (r *statementMaximumLimitValueRule) extractLimitValueFromLimitValue(ctx parser.ISelect_limit_valueContext) int {- if ctx == nil {- return 0- }-- // Check for ALL keyword (means no limit)- if ctx.ALL() != nil {- return 0- }-- // Check for a_expr which contains the actual value- if ctx.A_expr() != nil {- return r.extractIntFromAExpr(ctx.A_expr())- }-return 0}--// extractLimitValueFromFetchFirst extracts integer value from FETCH FIRST/NEXT clause.-func (r *statementMaximumLimitValueRule) extractLimitValueFromFetchFirst(ctx parser.ISelect_fetch_first_valueContext) int {- if ctx == nil {- return 0- }-- // Try to extract the numeric value from the text- text := ctx.GetText()- return r.parseIntFromText(text)-}--// extractIntFromAExpr attempts to extract an integer constant from an a_expr.-func (r *statementMaximumLimitValueRule) extractIntFromAExpr(ctx parser.IA_exprContext) int {- if ctx == nil {- return 0- }-- // Try to parse the text directly - this handles simple numeric literals- text := ctx.GetText()- return r.parseIntFromText(text)-}--// parseIntFromText attempts to parse an integer from text.-// This handles simple numeric literals and returns 0 if parsing fails.-func (*statementMaximumLimitValueRule) parseIntFromText(text string) int {- // Clean up the text (remove whitespace)- text = strings.TrimSpace(text)-- // Try to parse as integer- val, err := strconv.Atoi(text)- if err != nil {- return 0- }-- return val-}diff --git a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.goindex 0e570d474f..0244b8ec43 100644--- a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go+++ b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go@@ -5,13 +5,11 @@ import ("fmt""slices"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -34,33 +32,20 @@ func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx adviso}rule := &statementMergeAlterTableRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},tableMap: make(tableMap),}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }+ RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})return rule.generateAdvice(), nil}type statementMergeAlterTableRule struct {- BaseRule+ OmniBaseRuletableMap tableMap}@@ -95,79 +80,30 @@ func (t tableStatement) key() string {return fmt.Sprintf("%s.%s", t.schema, t.name)}-// Name returns the rule name.func (*statementMergeAlterTableRule) Name() string {- return "statement.merge-alter-table"+ return string(storepb.SQLReviewRule_STATEMENT_MERGE_ALTER_TABLE)}-// OnEnter is called when the parser enters a rule context.-func (r *statementMergeAlterTableRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))+func (r *statementMergeAlterTableRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ if n.Relation != nil {+ tableName := omniTableName(n.Relation)+ schema := omniSchemaName(n.Relation)+ if tableName != "" {+ r.tableMap.set(schema, tableName, int(r.ContentEndLine()))+ }+ }+ case *ast.AlterTableStmt:+ if n.Relation != nil {+ tableName := omniTableName(n.Relation)+ schema := omniSchemaName(n.Relation)+ if tableName != "" {+ r.tableMap.add(schema, tableName, int(r.ContentEndLine()))+ }+ }default:- // Do nothing for other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*statementMergeAlterTableRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementMergeAlterTableRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- allQualifiedNames := ctx.AllQualified_name()- if len(allQualifiedNames) == 0 {- return- }-- qualifiedName := allQualifiedNames[0]- tableName := extractTableName(qualifiedName)- schema := extractSchemaName(qualifiedName)- if schema == "" {- schema = "public"}-- if tableName == "" {- return- }-- r.tableMap.set(schema, tableName, ctx.GetStop().GetLine())-}--func (r *statementMergeAlterTableRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- relationExpr := ctx.Relation_expr()- if relationExpr == nil {- return- }-- qualifiedName := relationExpr.Qualified_name()- if qualifiedName == nil {- return- }-- tableName := extractTableName(qualifiedName)- schema := extractSchemaName(qualifiedName)- if schema == "" {- schema = "public"- }-- if tableName == "" {- return- }-- r.tableMap.add(schema, tableName, ctx.GetStop().GetLine())}func (r *statementMergeAlterTableRule) generateAdvice() []*storepb.Advice {@@ -188,9 +124,9 @@ func (r *statementMergeAlterTableRule) generateAdvice() []*storepb.Advice {for _, table := range tableList {if table.count > 1 {adviceList = append(adviceList, &storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementRedundantAlterTable.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("There are %d statements to modify table `%s`", table.count, table.name),StartPosition: &storepb.Position{Line: int32(table.line),diff --git a/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go b/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.goindex 9f0fc9658f..a25d062f80 100644--- a/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go@@ -5,17 +5,13 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")-// Note: strings import is still needed for pattern checking (HasPrefix)-var (_ advisor.Advisor = (*StatementNoLeadingWildcardLikeAdvisor)(nil))@@ -35,165 +31,56 @@ func (*StatementNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtxreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &statementNoLeadingWildcardLikeRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- reportedStatements: make(map[antlr.ParserRuleContext]bool),- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &statementNoLeadingWildcardLikeRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementNoLeadingWildcardLikeRule struct {- BaseRule- tokens *antlr.CommonTokenStream- reportedStatements map[antlr.ParserRuleContext]bool+ OmniBaseRule}-// Name returns the rule name.func (*statementNoLeadingWildcardLikeRule) Name() string {- return "statement.no-leading-wildcard-like"-}--// OnEnter is called when the parser enters a rule context.-func (r *statementNoLeadingWildcardLikeRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "A_expr_like":- r.handleAExprLike(ctx.(*parser.A_expr_likeContext))- default:- // Do nothing for other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*statementNoLeadingWildcardLikeRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil+ return string(storepb.SQLReviewRule_STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE)}-func (r *statementNoLeadingWildcardLikeRule) handleAExprLike(ctx *parser.A_expr_likeContext) {- // Check if this is a LIKE or ILIKE expression (not SIMILAR TO)- if ctx.LIKE() == nil && ctx.ILIKE() == nil {- return- }-- // Get the pattern (second A_expr_qual_op)- qualOps := ctx.AllA_expr_qual_op()- if len(qualOps) < 2 {- return- }-- pattern := qualOps[1]- patternStr := extractPatternString(pattern)-- // Check if pattern starts with wildcard- if patternStr != "" && (strings.HasPrefix(patternStr, "%") || strings.HasPrefix(patternStr, "_")) {- // Find the top-level statement for reporting- stmtCtx := findTopLevelStatement(ctx)- if stmtCtx == nil {- return- }-- // Only report once per statement- if r.reportedStatements[stmtCtx] {- return- }- r.reportedStatements[stmtCtx] = true-- stmtText := getTextFromTokens(r.tokens, stmtCtx)- if stmtText == "" {- stmtText = "<unknown statement>"+func (r *statementNoLeadingWildcardLikeRule) OnStatement(node ast.Node) {+ found := false+ ast.Inspect(node, func(n ast.Node) bool {+ if found {+ return false}- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementLeadingWildcardLike.Int32(),- Title: r.title,- Content: fmt.Sprintf("\"%s\" uses leading wildcard LIKE", stmtText),- StartPosition: &storepb.Position{- Line: int32(stmtCtx.GetStart().GetLine()),- Column: 0,- },- })- }-}--// extractPatternString extracts the string literal from a LIKE pattern expression-func extractPatternString(ctx parser.IA_expr_qual_opContext) string {- if ctx == nil {- return ""- }-- // Walk down the expression tree to find the string constant- // The structure is: A_expr_qual_op -> ... -> Aexprconst -> Sconst -> Anysconst -> Terminal- var findSconst func(antlr.Tree) parser.ISconstContext- findSconst = func(node antlr.Tree) parser.ISconstContext {- if node == nil {- return nil+ expr, ok := n.(*ast.A_Expr)+ if !ok {+ return true}-- // Check if this is a Sconst context- if sconst, ok := node.(parser.ISconstContext); ok {- return sconst+ if expr.Kind != ast.AEXPR_LIKE && expr.Kind != ast.AEXPR_ILIKE {+ return true}-- // Recursively check children- if prCtx, ok := node.(antlr.ParserRuleContext); ok {- for i := 0; i < prCtx.GetChildCount(); i++ {- if result := findSconst(prCtx.GetChild(i)); result != nil {- return result+ // Check if right operand is a string constant starting with '%' or '_'.+ if ac, ok := expr.Rexpr.(*ast.A_Const); ok {+ if sv, ok := ac.Val.(*ast.String); ok {+ if strings.HasPrefix(sv.Str, "%") || strings.HasPrefix(sv.Str, "_") {+ found = true+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementLeadingWildcardLike.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("\"%s\" uses leading wildcard LIKE", r.TrimmedStmtText()),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+ return false}}}-- return nil- }-- sconstCtx := findSconst(ctx)- if sconstCtx == nil {- return ""- }-- // Extract the string value from the Sconst context- // The text includes quotes, so we need to remove them- text := sconstCtx.GetText()- if len(text) >= 2 && text[0] == '\'' && text[len(text)-1] == '\'' {- return text[1 : len(text)-1]- }-- return text-}--// findTopLevelStatement finds the top-level statement containing the given context-func findTopLevelStatement(ctx antlr.ParserRuleContext) antlr.ParserRuleContext {- current := ctx- for current != nil {- parent := current.GetParent()- if isTopLevel(parent) {- return current- }- if prCtx, ok := parent.(antlr.ParserRuleContext); ok {- current = prCtx- } else {- break- }- }- return current+ return true+ })}diff --git a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go b/backend/plugin/advisor/pg/advisor_statement_no_select_all.goindex 1319d68760..1ceded02c2 100644--- a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go+++ b/backend/plugin/advisor/pg/advisor_statement_no_select_all.go@@ -3,15 +3,13 @@ package pgimport ("context""fmt"+ "strings"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -33,88 +31,162 @@ func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([return nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &noSelectAllRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &noSelectAllRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type noSelectAllRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRule}-// Name returns the rule name.func (*noSelectAllRule) Name() string {- return "statement.no-select-all"+ return string(storepb.SQLReviewRule_STATEMENT_SELECT_NO_SELECT_ALL)}-// OnEnter is called when the parser enters a rule context.-func (r *noSelectAllRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Simple_select_pramary":- r.handleSimpleSelectPramary(ctx.(*parser.Simple_select_pramaryContext))+func (r *noSelectAllRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.SelectStmt:+ r.checkSelectStmt(n, true)+ case *ast.InsertStmt:+ if sel, ok := n.SelectStmt.(*ast.SelectStmt); ok {+ r.checkSelectStmt(sel, false)+ }default:- // Do nothing for other node types}- return nil}-// OnExit is called when the parser exits a rule context.-func (*noSelectAllRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}+func (r *noSelectAllRule) checkSelectStmt(sel *ast.SelectStmt, isTopLevel bool) {+ if sel == nil {+ return+ }-func (r *noSelectAllRule) handleSimpleSelectPramary(ctx *parser.Simple_select_pramaryContext) {- // Check if this is a SELECT statement with target list- if ctx.SELECT() == nil {+ // For set operations (UNION/INTERSECT/EXCEPT), recurse into children.+ if sel.Op != ast.SETOP_NONE {+ r.checkSelectStmt(sel.Larg, false)+ r.checkSelectStmt(sel.Rarg, false)return}- // Check the target list for * (asterisk)- if ctx.Opt_target_list() != nil && ctx.Opt_target_list().Target_list() != nil {- targetList := ctx.Opt_target_list().Target_list()- allTargets := targetList.AllTarget_el()-- for _, target := range allTargets {- // Check if target is a Target_star (SELECT *)- if _, ok := target.(*parser.Target_starContext); ok {- stmtText := getTextFromTokens(r.tokens, ctx)- if stmtText == "" {- stmtText = "<unknown statement>"+ // Walk subqueries first.+ r.walkSelectSubqueries(sel)++ // Check target list for SELECT *.+ if sel.TargetList != nil {+ for _, item := range sel.TargetList.Items {+ rt, ok := item.(*ast.ResTarget)+ if !ok {+ continue+ }+ cr, ok := rt.Val.(*ast.ColumnRef)+ if !ok {+ continue+ }+ if cr.Fields != nil {+ for _, field := range cr.Fields.Items {+ if _, ok := field.(*ast.A_Star); ok {+ stmtText := r.extractSelectText(sel, isTopLevel)+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementSelectAll.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("\"%s\" uses SELECT all", stmtText),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+ return+ }}- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementSelectAll.Int32(),- Title: r.title,- Content: fmt.Sprintf("\"%s\" uses SELECT all", stmtText),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- return}}}}++// extractSelectText returns the text representation of a SelectStmt.+func (r *noSelectAllRule) extractSelectText(sel *ast.SelectStmt, isTopLevel bool) string {+ if isTopLevel {+ return r.TrimmedStmtText()+ }+ // For nested subqueries, extract from StmtText using Loc byte offsets.+ loc := sel.Loc+ if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(r.StmtText) {+ return strings.TrimSpace(r.StmtText[loc.Start:loc.End])+ }+ return r.TrimmedStmtText()+}++func (r *noSelectAllRule) walkSelectSubqueries(sel *ast.SelectStmt) {+ if sel == nil {+ return+ }+ r.walkNodeListForSelectAll(sel.FromClause)+ r.walkNodeForSelectAll(sel.WhereClause)+ r.walkNodeForSelectAll(sel.HavingClause)+ r.walkNodeListForSelectAll(sel.GroupClause)+ r.walkNodeListForSelectAll(sel.SortClause)+ r.walkNodeForSelectAll(sel.LimitCount)+ r.walkNodeForSelectAll(sel.LimitOffset)+}++func (r *noSelectAllRule) walkNodeListForSelectAll(list *ast.List) {+ if list == nil {+ return+ }+ for _, item := range list.Items {+ r.walkNodeForSelectAll(item)+ }+}++func (r *noSelectAllRule) walkNodeForSelectAll(node ast.Node) {+ if node == nil {+ return+ }+ switch n := node.(type) {+ case *ast.SubLink:+ if sub, ok := n.Subselect.(*ast.SelectStmt); ok {+ r.checkSelectStmt(sub, false)+ }+ case *ast.RangeSubselect:+ if sub, ok := n.Subquery.(*ast.SelectStmt); ok {+ r.checkSelectStmt(sub, false)+ }+ case *ast.List:+ r.walkNodeListForSelectAll(n)+ case *ast.ResTarget:+ r.walkNodeForSelectAll(n.Val)+ case *ast.FuncCall:+ r.walkNodeListForSelectAll(n.Args)+ case *ast.A_Expr:+ r.walkNodeForSelectAll(n.Lexpr)+ r.walkNodeForSelectAll(n.Rexpr)+ case *ast.BoolExpr:+ r.walkNodeListForSelectAll(n.Args)+ case *ast.CoalesceExpr:+ r.walkNodeListForSelectAll(n.Args)+ case *ast.CaseExpr:+ r.walkNodeForSelectAll(n.Arg)+ r.walkNodeListForSelectAll(n.Args)+ r.walkNodeForSelectAll(n.Defresult)+ case *ast.CaseWhen:+ r.walkNodeForSelectAll(n.Expr)+ r.walkNodeForSelectAll(n.Result)+ case *ast.NullTest:+ r.walkNodeForSelectAll(n.Arg)+ case *ast.TypeCast:+ r.walkNodeForSelectAll(n.Arg)+ case *ast.JoinExpr:+ r.walkNodeForSelectAll(n.Larg)+ r.walkNodeForSelectAll(n.Rarg)+ r.walkNodeForSelectAll(n.Quals)+ case *ast.SortBy:+ r.walkNodeForSelectAll(n.Node)+ default:+ }+}diff --git a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go b/backend/plugin/advisor/pg/advisor_statement_non_transactional.goindex a13105415b..755270140d 100644--- a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go+++ b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go@@ -3,15 +3,12 @@ package pgimport ("context"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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/db/pg"- "github.com/bytebase/bytebase/backend/plugin/parser/base")var (@@ -33,95 +30,40 @@ func (*NonTransactionalAdvisor) Check(_ context.Context, checkCtx advisor.Contexreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &nonTransactionalRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }- checker := NewGenericChecker([]Rule{rule})- rule.SetBaseLine(stmtInfo.BaseLine())- checker.SetBaseLine(stmtInfo.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &nonTransactionalRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type nonTransactionalRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRule}-// Name returns the rule name.func (*nonTransactionalRule) Name() string {return "statement.non-transactional"}-// OnEnter is called when the parser enters a rule context.-func (r *nonTransactionalRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Dropdbstmt":- r.handleDropdbstmt(ctx.(*parser.DropdbstmtContext))- case "Indexstmt":- r.handleIndexstmt(ctx.(*parser.IndexstmtContext))- case "Dropstmt":- r.handleDropstmt(ctx.(*parser.DropstmtContext))- case "Vacuumstmt":- r.handleVacuumstmt(ctx.(*parser.VacuumstmtContext))+func (r *nonTransactionalRule) OnStatement(node ast.Node) {+ switch node.(type) {+ case *ast.DropdbStmt, *ast.IndexStmt, *ast.DropStmt, *ast.VacuumStmt:default:- // Do nothing for other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*nonTransactionalRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *nonTransactionalRule) handleDropdbstmt(ctx *parser.DropdbstmtContext) {- r.checkStatement(ctx)-}--func (r *nonTransactionalRule) handleIndexstmt(ctx *parser.IndexstmtContext) {- r.checkStatement(ctx)-}--func (r *nonTransactionalRule) handleDropstmt(ctx *parser.DropstmtContext) {- r.checkStatement(ctx)-}--func (r *nonTransactionalRule) handleVacuumstmt(ctx *parser.VacuumstmtContext) {- r.checkStatement(ctx)-}--// checkStatement checks if a statement is non-transactional-func (r *nonTransactionalRule) checkStatement(ctx antlr.ParserRuleContext) {- if !isTopLevel(ctx.GetParent()) {return}- statementText := getTextFromTokens(r.tokens, ctx)- if pg.IsNonTransactionStatement(statementText) {+ stmtText := r.TrimmedStmtText()+ if pg.IsNonTransactionStatement(stmtText) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementNonTransactional.Int32(),- Title: r.title,+ Title: r.Title,Content: "This statement is non-transactional",StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.goindex dd501a1eda..142dafedcd 100644--- a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go+++ b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go@@ -6,15 +6,12 @@ import ("fmt""log/slog"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast""github.com/bytebase/bytebase/backend/common/log"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"- "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -50,34 +47,19 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx adv}rule := &statementObjectOwnerCheckRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},dbMetadata: dbMetadata,currentRole: currentRole,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementObjectOwnerCheckRule struct {- BaseRule+ OmniBaseRuledbMetadata *model.DatabaseMetadatacurrentRole string}@@ -87,65 +69,130 @@ func (*statementObjectOwnerCheckRule) Name() string {return "statement.object-owner-check"}-// OnEnter is called when the parser enters a rule context.-func (r *statementObjectOwnerCheckRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Variablesetstmt":- r.handleVariablesetstmt(ctx.(*parser.VariablesetstmtContext))- case "Alterseqstmt":- r.handleAlterseqstmt(ctx.(*parser.AlterseqstmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- case "Altertypestmt":- r.handleAltertypestmt(ctx.(*parser.AltertypestmtContext))- case "Createextensionstmt":- r.handleCreateextensionstmt(ctx.(*parser.CreateextensionstmtContext))- case "Createfunctionstmt":- r.handleCreatefunctionstmt(ctx.(*parser.CreatefunctionstmtContext))- case "Indexstmt":- r.handleIndexstmt(ctx.(*parser.IndexstmtContext))- case "Createschemastmt":- r.handleCreateschemastmt(ctx.(*parser.CreateschemastmtContext))- case "Createseqstmt":- r.handleCreateseqstmt(ctx.(*parser.CreateseqstmtContext))- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Createtrigstmt":- r.handleCreatetrigstmt(ctx.(*parser.CreatetrigstmtContext))- case "Definestmt":- r.handleDefinestmt(ctx.(*parser.DefinestmtContext))- case "Creatematviewstmt":- r.handleCreatematviewstmt(ctx.(*parser.CreatematviewstmtContext))- case "Removefuncstmt":- r.handleRemovefuncstmt(ctx.(*parser.RemovefuncstmtContext))- case "Dropstmt":- r.handleDropstmt(ctx.(*parser.DropstmtContext))- case "Renamestmt":- r.handleRenamestmt(ctx.(*parser.RenamestmtContext))+func (r *statementObjectOwnerCheckRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.VariableSetStmt:+ // SET ROLE handling - no-op for now (same as ANTLR version)+ case *ast.AlterSeqStmt:+ if n.Sequence != nil {+ r.checkSchemaOwnership(omniSchemaName(n.Sequence))+ }+ case *ast.AlterTableStmt:+ if n.Relation != nil {+ schemaName := omniSchemaName(n.Relation)+ tableName := omniTableName(n.Relation)+ r.checkTableOwnership(schemaName, tableName)+ }+ case *ast.AlterTypeStmt:+ parts := omniListStrings(n.TypeName)+ var schemaName string+ if len(parts) >= 2 {+ schemaName = parts[0]+ }+ r.checkSchemaOwnership(schemaName)+ case *ast.CreateExtensionStmt:+ schemaName := defaultSchema+ if n.Options != nil {+ for _, item := range n.Options.Items {+ if elem, ok := item.(*ast.DefElem); ok && elem.Defname == "schema" {+ if s, ok := elem.Arg.(*ast.String); ok {+ schemaName = s.Str+ }+ }+ }+ }+ r.checkSchemaOwnership(schemaName)+ case *ast.CreateFunctionStmt:+ schemaName := omniExtractSchemaFromFuncname(n.Funcname)+ r.checkSchemaOwnership(schemaName)+ case *ast.IndexStmt:+ if n.Relation != nil {+ r.checkSchemaOwnership(omniSchemaName(n.Relation))+ }+ case *ast.CreateSchemaStmt:+ owner := r.dbMetadata.GetProto().GetOwner()+ if owner != r.currentRole {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Title: r.Title,+ Content: fmt.Sprintf("Database \"%s\" is owned by \"%s\", but the current role is \"%s\".", r.dbMetadata.GetProto().GetName(), owner, r.currentRole),+ Code: code.StatementObjectOwnerCheck.Int32(),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+ }+ case *ast.CreateSeqStmt:+ if n.Sequence != nil {+ r.checkSchemaOwnership(omniSchemaName(n.Sequence))+ }+ case *ast.CreateStmt:+ if n.Relation != nil {+ r.checkSchemaOwnership(omniSchemaName(n.Relation))+ }+ case *ast.CreateTrigStmt:+ if n.Relation != nil {+ r.checkSchemaOwnership(omniSchemaName(n.Relation))+ }+ case *ast.DefineStmt:+ if n.Kind == ast.OBJECT_TYPE {+ parts := omniListStrings(n.Defnames)+ var schemaName string+ if len(parts) >= 2 {+ schemaName = parts[0]+ }+ r.checkSchemaOwnership(schemaName)+ }+ case *ast.CreateTableAsStmt:+ // Handles CREATE MATERIALIZED VIEW+ if n.Objtype == ast.OBJECT_MATVIEW && n.Into != nil && n.Into.Rel != nil {+ r.checkSchemaOwnership(omniSchemaName(n.Into.Rel))+ }+ case *ast.AlterFunctionStmt:+ // DROP FUNCTION is handled by DropStmt in omni AST+ // AlterFunctionStmt handles ALTER FUNCTION+ if n.Func != nil {+ schemaName := omniExtractSchemaFromObjectWithArgs(n.Func)+ r.checkSchemaOwnership(schemaName)+ }+ case *ast.DropStmt:+ r.handleDropStmt(n)+ case *ast.RenameStmt:+ r.handleRenameStmt(n)default:- // Do nothing for other node types}- return nil}-// OnExit is called when the parser exits a rule context.-func (*statementObjectOwnerCheckRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil+func (r *statementObjectOwnerCheckRule) handleDropStmt(n *ast.DropStmt) {+ // For DROP INDEX, DROP TYPE, etc., check schema ownership via object names+ names := omniDropObjectNames(n)+ for _, parts := range names {+ var schemaName string+ if len(parts) >= 2 {+ schemaName = parts[0]+ }+ r.checkSchemaOwnership(schemaName)+ }}-// handleVariablesetstmt handles SET ROLE statements-func (*statementObjectOwnerCheckRule) handleVariablesetstmt(ctx *parser.VariablesetstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return+func (r *statementObjectOwnerCheckRule) handleRenameStmt(n *ast.RenameStmt) {+ switch n.RenameType {+ case ast.OBJECT_SCHEMA:+ // ALTER SCHEMA RENAME+ if n.Subname != "" {+ r.checkSchemaOwnership(n.Subname)+ }+ case ast.OBJECT_INDEX:+ // ALTER INDEX RENAME+ if n.Relation != nil {+ r.checkSchemaOwnership(omniSchemaName(n.Relation))+ }+ default:}-- // Check if this is SET ROLE- // Note: This is a simplified version that doesn't extract and update the role- // The actual role name extraction would require parsing the var_list- // For now, we skip updating currentRole from SET ROLE to keep it simple}-func (r *statementObjectOwnerCheckRule) checkSchemaOwnership(schemaName string, line int) {+func (r *statementObjectOwnerCheckRule) checkSchemaOwnership(schemaName string) {if schemaName == "" {schemaName = defaultSchema}@@ -161,19 +208,19 @@ func (r *statementObjectOwnerCheckRule) checkSchemaOwnership(schemaName string,}if owner != r.currentRole {r.AddAdvice(&storepb.Advice{- Status: r.level,- Title: r.title,+ Status: r.Level,+ Title: r.Title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, r.currentRole),Code: code.StatementObjectOwnerCheck.Int32(),StartPosition: &storepb.Position{- Line: int32(line),+ Line: r.ContentStartLine(),Column: 0,},})}}-func (r *statementObjectOwnerCheckRule) checkTableOwnership(schemaName, tableName string, line int) {+func (r *statementObjectOwnerCheckRule) checkTableOwnership(schemaName, tableName string) {if schemaName == "" {schemaName = defaultSchema}@@ -194,340 +241,35 @@ func (r *statementObjectOwnerCheckRule) checkTableOwnership(schemaName, tableNam}if owner != r.currentRole {r.AddAdvice(&storepb.Advice{- Status: r.level,- Title: r.title,+ Status: r.Level,+ Title: r.Title,Content: fmt.Sprintf("Table \"%s\" is owned by \"%s\", but the current role is \"%s\".", tableName, owner, r.currentRole),Code: code.StatementObjectOwnerCheck.Int32(),StartPosition: &storepb.Position{- Line: int32(line),- Column: 0,- },- })- }-}--// handleAlterseqstmt handles ALTER SEQUENCE statements-func (r *statementObjectOwnerCheckRule) handleAlterseqstmt(ctx *parser.AlterseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- qualName := ctx.Qualified_name()- if qualName == nil {- return- }-- schemaName := extractSchemaName(qualName)- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleAltertablestmt handles ALTER TABLE statements-func (r *statementObjectOwnerCheckRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- qualName := ctx.Relation_expr().Qualified_name()- schemaName := extractSchemaName(qualName)- tableName := extractTableName(qualName)-- r.checkTableOwnership(schemaName, tableName, ctx.GetStart().GetLine())-}--// handleAltertypestmt handles ALTER TYPE statements-func (r *statementObjectOwnerCheckRule) handleAltertypestmt(ctx *parser.AltertypestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Any_name() == nil {- return- }-- anyName := ctx.Any_name()- parts := pg.NormalizePostgreSQLAnyName(anyName)-- var schemaName string- if len(parts) >= 2 {- schemaName = parts[0]- }-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleCreateextensionstmt handles CREATE EXTENSION statements-func (r *statementObjectOwnerCheckRule) handleCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Extract schema name from create_extension_opt_list- schemaName := defaultSchema- if optList := ctx.Create_extension_opt_list(); optList != nil {- for _, opt := range optList.AllCreate_extension_opt_item() {- if opt.SCHEMA() != nil && opt.Name() != nil {- schemaName = opt.Name().GetText()- break- }- }- }-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleCreatefunctionstmt handles CREATE FUNCTION statements-func (r *statementObjectOwnerCheckRule) handleCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Func_name() == nil {- return- }-- schemaName := r.extractSchemaFromFuncName(ctx.Func_name())- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleIndexstmt handles CREATE INDEX statements-func (r *statementObjectOwnerCheckRule) handleIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {- return- }-- qualName := ctx.Relation_expr().Qualified_name()- schemaName := extractSchemaName(qualName)-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleCreateschemastmt handles CREATE SCHEMA statements-func (r *statementObjectOwnerCheckRule) handleCreateschemastmt(ctx *parser.CreateschemastmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- owner := r.dbMetadata.GetProto().GetOwner()- if owner != r.currentRole {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Title: r.title,- Content: fmt.Sprintf("Database \"%s\" is owned by \"%s\", but the current role is \"%s\".", r.dbMetadata.GetProto().GetName(), owner, r.currentRole),- Code: code.StatementObjectOwnerCheck.Int32(),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}-// handleCreateseqstmt handles CREATE SEQUENCE statements-func (r *statementObjectOwnerCheckRule) handleCreateseqstmt(ctx *parser.CreateseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Qualified_name() == nil {- return- }-- qualName := ctx.Qualified_name()- schemaName := extractSchemaName(qualName)-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleCreatestmt handles CREATE TABLE statements-func (r *statementObjectOwnerCheckRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- allQualNames := ctx.AllQualified_name()- if len(allQualNames) == 0 {- return- }-- qualName := allQualNames[0]- schemaName := extractSchemaName(qualName)-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleCreatetrigstmt handles CREATE TRIGGER statements-func (r *statementObjectOwnerCheckRule) handleCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Qualified_name() == nil {- return- }-- qualName := ctx.Qualified_name()- schemaName := extractSchemaName(qualName)-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleDefinestmt handles CREATE TYPE statements (via DEFINE)-func (r *statementObjectOwnerCheckRule) handleDefinestmt(ctx *parser.DefinestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is a CREATE TYPE statement- if ctx.TYPE_P() == nil {- return- }-- // Any_name(0) gets the first any_name- if ctx.Any_name(0) == nil {- return- }-- anyName := ctx.Any_name(0)- parts := pg.NormalizePostgreSQLAnyName(anyName)-- var schemaName string+// omniExtractSchemaFromFuncname extracts the schema name from a function's qualified name list.+func omniExtractSchemaFromFuncname(funcname *ast.List) string {+ parts := omniListStrings(funcname)if len(parts) >= 2 {- schemaName = parts[0]- }-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleCreatematviewstmt handles CREATE VIEW / MATERIALIZED VIEW statements-func (r *statementObjectOwnerCheckRule) handleCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Create_mv_target() == nil || ctx.Create_mv_target().Qualified_name() == nil {- return- }-- qualName := ctx.Create_mv_target().Qualified_name()- schemaName := extractSchemaName(qualName)-- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())-}--// handleRemovefuncstmt handles DROP FUNCTION statements-func (r *statementObjectOwnerCheckRule) handleRemovefuncstmt(ctx *parser.RemovefuncstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- if ctx.Function_with_argtypes_list() == nil {- return- }-- for _, funcWithArgs := range ctx.Function_with_argtypes_list().AllFunction_with_argtypes() {- if funcWithArgs.Func_name() == nil {- continue- }-- schemaName := r.extractSchemaFromFuncName(funcWithArgs.Func_name())- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())- }-}--// handleDropstmt handles various DROP statements-// Note: PostgreSQL DROP statements don't easily expose the object type in ANTLR,-// so we do a best-effort check by examining the any_name_list-func (r *statementObjectOwnerCheckRule) handleDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // For DROP INDEX, check schema ownership- if ctx.INDEX() != nil {- r.handleDropWithAnyNameList(ctx, false)- return- }-- // For other DROP statements, check schema ownership- if ctx.Any_name_list() != nil {- r.handleDropWithAnyNameList(ctx, false)- }-}--func (r *statementObjectOwnerCheckRule) handleDropWithAnyNameList(ctx *parser.DropstmtContext, checkTable bool) {- if ctx.Any_name_list() == nil {- return- }-- for _, anyName := range ctx.Any_name_list().AllAny_name() {- parts := pg.NormalizePostgreSQLAnyName(anyName)- if len(parts) == 0 {- continue- }-- var schemaName, objectName string- if len(parts) == 1 {- schemaName = ""- objectName = parts[0]- } else {- schemaName = parts[0]- objectName = parts[1]- }-- if checkTable && objectName != "" {- r.checkTableOwnership(schemaName, objectName, ctx.GetStart().GetLine())- } else {- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())- }- }-}--// handleRenamestmt handles RENAME statements (including ALTER INDEX RENAME)-func (r *statementObjectOwnerCheckRule) handleRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is an ALTER SCHEMA RENAME- if ctx.SCHEMA() != nil && ctx.Name(0) != nil {- schemaName := ctx.Name(0).GetText()- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())- } else if ctx.INDEX() != nil && ctx.Qualified_name() != nil {- // ALTER INDEX RENAME- qualName := ctx.Qualified_name()- schemaName := extractSchemaName(qualName)- r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())+ return parts[0]}+ return ""}-// Helper method to extract schema name from function name-func (*statementObjectOwnerCheckRule) extractSchemaFromFuncName(funcName parser.IFunc_nameContext) string {- if funcName.Type_function_name() != nil {- // Simple function name without schema+// omniExtractSchemaFromObjectWithArgs extracts the schema from an ObjectWithArgs node.+func omniExtractSchemaFromObjectWithArgs(obj *ast.ObjectWithArgs) string {+ if obj == nil || obj.Objname == nil {return ""}- if funcName.Indirection() != nil {- // Qualified function name with schema- parts := []string{}- if funcName.Colid() != nil {- parts = append(parts, pg.NormalizePostgreSQLColid(funcName.Colid()))- }- for _, attr := range funcName.Indirection().AllIndirection_el() {- if attr.Attr_name() != nil {- parts = append(parts, attr.Attr_name().GetText())- }- }- if len(parts) >= 2 {- return parts[0]- }+ parts := omniListStrings(obj.Objname)+ if len(parts) >= 2 {+ return parts[0]}return ""}diff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go b/backend/plugin/advisor/pg/advisor_statement_where_required_select.goindex 628e1b7d6a..a511e25666 100644--- a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_select.go@@ -3,14 +3,13 @@ package pgimport ("context""fmt"+ "strings"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -32,182 +31,164 @@ func (*StatementWhereRequiredSelectAdvisor) Check(_ context.Context, checkCtx adreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &statementWhereRequiredSelectRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &statementWhereRequiredSelectRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementWhereRequiredSelectRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRule}-// Name returns the rule name.func (*statementWhereRequiredSelectRule) Name() string {- return "statement.where-required-select"+ return string(storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_SELECT)}-// OnEnter is called when the parser enters a rule context.-func (r *statementWhereRequiredSelectRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Selectstmt":- r.handleSelectstmt(ctx.(*parser.SelectstmtContext))- case "Select_with_parens":- r.handleSelectWithParens(ctx.(*parser.Select_with_parensContext))- default:- // Do nothing for other node types+func (r *statementWhereRequiredSelectRule) OnStatement(node ast.Node) {+ sel, ok := node.(*ast.SelectStmt)+ if !ok {+ return}- return nil+ r.checkSelectStmt(sel, true)}-// OnExit is called when the parser exits a rule context.-func (*statementWhereRequiredSelectRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *statementWhereRequiredSelectRule) handleSelectstmt(ctx *parser.SelectstmtContext) {- r.checkSelect(ctx, func() (bool, bool) {- return r.checkSelectClauses(ctx)- })-}--func (r *statementWhereRequiredSelectRule) handleSelectWithParens(ctx *parser.Select_with_parensContext) {- // Skip if this is the top-level statement (already handled by handleSelectstmt)- if isTopLevel(ctx.GetParent()) {+// checkSelectStmt recursively checks a SelectStmt for WHERE clause requirement.+// isTopLevel indicates whether this is the top-level statement (for text extraction).+func (r *statementWhereRequiredSelectRule) checkSelectStmt(sel *ast.SelectStmt, isTopLevel bool) {+ if sel == nil {return}- r.checkSelect(ctx, func() (bool, bool) {- return r.checkSelectWithParensForWhere(ctx)- })-}+ // For set operations (UNION/INTERSECT/EXCEPT), recurse into children.+ if sel.Op != ast.SETOP_NONE {+ r.checkSelectStmt(sel.Larg, false)+ r.checkSelectStmt(sel.Rarg, false)+ return+ }-// checkSelect is a common function to check for WHERE clause requirement-func (r *statementWhereRequiredSelectRule) checkSelect(- ctx antlr.ParserRuleContext,- checkFunc func() (hasWhere bool, hasFrom bool),-) {- // Check if this SELECT has a WHERE clause and FROM clause- hasWhere, hasFrom := checkFunc()+ // Walk into subqueries in all expressions before checking this SELECT.+ r.walkSubqueries(sel)- // Allow SELECT queries without a FROM clause to proceed, e.g. SELECT 1- if !hasFrom {+ // Skip SELECTs without FROM clause (e.g. SELECT 1).+ if sel.FromClause == nil || len(sel.FromClause.Items) == 0 {return}- // If there's a WHERE clause, all good- if hasWhere {+ // If there's a WHERE clause, it's fine.+ if sel.WhereClause != nil {return}- // Get clean statement text from token stream- stmtText := getTextFromTokens(r.tokens, ctx)- if stmtText == "" {- stmtText = "<unknown statement>"- }+ stmtText := r.extractSelectText(sel, isTopLevel)r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.StatementNoWhere.Int32(),- Title: r.title,+ Title: r.Title,Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}-// checkSelectWithParensForWhere checks a select_with_parens for WHERE and FROM-func (r *statementWhereRequiredSelectRule) checkSelectWithParensForWhere(ctx parser.ISelect_with_parensContext) (hasWhere bool, hasFrom bool) {- if ctx == nil {- return false, false+// extractSelectText returns the text representation of a SelectStmt.+func (r *statementWhereRequiredSelectRule) extractSelectText(sel *ast.SelectStmt, isTopLevel bool) string {+ if isTopLevel {+ return strings.TrimSpace(r.StmtText)}-- // select_with_parens can contain either select_no_parens or another select_with_parens- if ctx.Select_no_parens() != nil {- selectNoParens := ctx.Select_no_parens()- if selectNoParens.Select_clause() != nil {- return r.checkSelectClause(selectNoParens.Select_clause())+ // For nested subqueries, extract from StmtText using Loc byte offsets.+ loc := sel.Loc+ if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(r.StmtText) {+ start := loc.Start+ end := loc.End+ // Include surrounding parentheses if present.+ if start > 0 && r.StmtText[start-1] == '(' && end < len(r.StmtText) && r.StmtText[end] == ')' {+ start--+ end++}+ return r.StmtText[start:end]}+ return strings.TrimSpace(r.StmtText)+}- if ctx.Select_with_parens() != nil {- return r.checkSelectWithParensForWhere(ctx.Select_with_parens())- }-- return false, false+// walkSubqueries walks the AST nodes within a SelectStmt to find nested subqueries.+func (r *statementWhereRequiredSelectRule) walkSubqueries(sel *ast.SelectStmt) {+ // Check target list expressions for subqueries.+ r.walkNodeList(sel.TargetList)+ // Check FROM clause for subqueries (e.g., subqueries in FROM).+ r.walkNodeList(sel.FromClause)+ // Check WHERE clause for subqueries.+ r.walkNode(sel.WhereClause)+ // Check HAVING clause for subqueries.+ r.walkNode(sel.HavingClause)+ // Check GROUP BY clause.+ r.walkNodeList(sel.GroupClause)+ // Check sort clause.+ r.walkNodeList(sel.SortClause)+ // Check limit/offset.+ r.walkNode(sel.LimitCount)+ r.walkNode(sel.LimitOffset)}-// checkSelectClauses checks if a SELECT statement has WHERE and FROM clauses-func (r *statementWhereRequiredSelectRule) checkSelectClauses(ctx *parser.SelectstmtContext) (hasWhere bool, hasFrom bool) {- // Try Select_no_parens first- if ctx.Select_no_parens() != nil {- selectNoParens := ctx.Select_no_parens()- if selectNoParens.Select_clause() != nil {- return r.checkSelectClause(selectNoParens.Select_clause())- }+func (r *statementWhereRequiredSelectRule) walkNodeList(list *ast.List) {+ if list == nil {+ return}-- // Try Select_with_parens- if ctx.Select_with_parens() != nil {- // For a selectstmt that directly contains select_with_parens,- // delegate to the recursive handler- return r.checkSelectWithParensForWhere(ctx.Select_with_parens())+ for _, item := range list.Items {+ r.walkNode(item)}-- return false, false}-// checkSelectClause checks a select_clause for WHERE and FROM-func (*statementWhereRequiredSelectRule) checkSelectClause(selectClause parser.ISelect_clauseContext) (hasWhere bool, hasFrom bool) {- if selectClause == nil {- return false, false+func (r *statementWhereRequiredSelectRule) walkNode(node ast.Node) {+ if node == nil {+ return}-- // Get all simple_select_intersect- allIntersects := selectClause.AllSimple_select_intersect()- for _, intersect := range allIntersects {- if intersect == nil {- continue+ switch n := node.(type) {+ case *ast.SubLink:+ if sub, ok := n.Subselect.(*ast.SelectStmt); ok {+ r.checkSelectStmt(sub, false)}- // Get all simple_select_pramary (note: typo in parser, it's "pramary" not "primary")- allPrimary := intersect.AllSimple_select_pramary()- for _, primary := range allPrimary {- if primary == nil {- continue- }- // Check for WHERE clause- if primary.Where_clause() != nil {- hasWhere = true- }- // Check for FROM clause- if primary.From_clause() != nil {- hasFrom = true- }+ case *ast.RangeSubselect:+ if sub, ok := n.Subquery.(*ast.SelectStmt); ok {+ r.checkSelectStmt(sub, false)}+ case *ast.List:+ r.walkNodeList(n)+ case *ast.ResTarget:+ r.walkNode(n.Val)+ case *ast.FuncCall:+ r.walkNodeList(n.Args)+ case *ast.A_Expr:+ r.walkNode(n.Lexpr)+ r.walkNode(n.Rexpr)+ case *ast.BoolExpr:+ r.walkNodeList(n.Args)+ case *ast.CoalesceExpr:+ r.walkNodeList(n.Args)+ case *ast.CaseExpr:+ r.walkNode(n.Arg)+ r.walkNodeList(n.Args)+ r.walkNode(n.Defresult)+ case *ast.CaseWhen:+ r.walkNode(n.Expr)+ r.walkNode(n.Result)+ case *ast.NullTest:+ r.walkNode(n.Arg)+ case *ast.TypeCast:+ r.walkNode(n.Arg)+ case *ast.JoinExpr:+ r.walkNode(n.Larg)+ r.walkNode(n.Rarg)+ r.walkNode(n.Quals)+ case *ast.SortBy:+ r.walkNode(n.Node)+ default:}-- return hasWhere, hasFrom}diff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go b/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.goindex 16d9bf2475..03846f48d4 100644--- a/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go@@ -4,13 +4,11 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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")var (@@ -32,104 +30,52 @@ func (*StatementWhereRequiredUpdateDeleteAdvisor) Check(_ context.Context, checkreturn nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &statementWhereRequiredRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &statementWhereRequiredUpdateDeleteRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}-type statementWhereRequiredRule struct {- BaseRule- tokens *antlr.CommonTokenStream-}--// Name returns the rule name.-func (*statementWhereRequiredRule) Name() string {- return "statement.where-required-update-delete"-}--// OnEnter is called when the parser enters a rule context.-func (r *statementWhereRequiredRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Updatestmt":- r.handleUpdatestmt(ctx.(*parser.UpdatestmtContext))- case "Deletestmt":- r.handleDeletestmt(ctx.(*parser.DeletestmtContext))- default:- // Do nothing for other node types- }- return nil+type statementWhereRequiredUpdateDeleteRule struct {+ OmniBaseRule}-// OnExit is called when the parser exits a rule context.-func (*statementWhereRequiredRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil+func (*statementWhereRequiredUpdateDeleteRule) Name() string {+ return string(storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_UPDATE_DELETE)}-func (r *statementWhereRequiredRule) handleUpdatestmt(ctx *parser.UpdatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if WHERE clause exists- if ctx.Where_or_current_clause() == nil || ctx.Where_or_current_clause().WHERE() == nil {- stmtText := getTextFromTokens(r.tokens, ctx)- if stmtText == "" {- stmtText = "<unknown statement>"+func (r *statementWhereRequiredUpdateDeleteRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.UpdateStmt:+ if n.WhereClause == nil {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementNoWhere.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", r.TrimmedStmtText()),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementNoWhere.Int32(),- Title: r.title,- Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- }-}--func (r *statementWhereRequiredRule) handleDeletestmt(ctx *parser.DeletestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if WHERE clause exists- if ctx.Where_or_current_clause() == nil || ctx.Where_or_current_clause().WHERE() == nil {- stmtText := getTextFromTokens(r.tokens, ctx)- if stmtText == "" {- stmtText = "<unknown statement>"+ case *ast.DeleteStmt:+ if n.WhereClause == nil {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.StatementNoWhere.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", r.TrimmedStmtText()),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.StatementNoWhere.Int32(),- Title: r.title,- Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })+ default:}}diff --git a/backend/plugin/advisor/pg/advisor_table_comment_convention.go b/backend/plugin/advisor/pg/advisor_table_comment_convention.goindex 043d2ea11b..3234bdae4c 100644--- a/backend/plugin/advisor/pg/advisor_table_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_table_comment_convention.go@@ -4,14 +4,11 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg")@@ -36,133 +33,76 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.commentPayload := checkCtx.Rule.GetCommentConventionPayload()rule := &tableCommentConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},payload: commentPayload,createdTables: make(map[string]*tableInfo),tableComments: make(map[string]*tableCommentInfo),}- checker := NewGenericChecker([]Rule{rule})-for _, stmt := range checkCtx.ParsedStatements {if stmt.AST == nil {continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)+ node, ok := pgparser.GetOmniNode(stmt.AST)if !ok {continue}- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)+ rule.SetStatement(stmt.BaseLine(), stmt.Text)+ rule.OnStatement(node)}- // Check each created table for comment requirements- for tableKey, tableInfo := range rule.createdTables {- tableCommentInfo, hasComment := rule.tableComments[tableKey]-- if !hasComment || tableCommentInfo.comment == "" {- if rule.payload.Required {- rule.AddAdvice(&storepb.Advice{- Status: rule.level,- Code: code.CommentEmpty.Int32(),- Title: rule.title,- Content: fmt.Sprintf("Comment is required for table `%s`", tableInfo.displayName),- StartPosition: &storepb.Position{- Line: int32(tableInfo.line),- Column: 0,- },- })- }- } else {- comment := tableCommentInfo.comment- if rule.payload.MaxLength > 0 && int32(len(comment)) > rule.payload.MaxLength {- rule.AddAdvice(&storepb.Advice{- Status: rule.level,- Code: code.CommentTooLong.Int32(),- Title: rule.title,- Content: fmt.Sprintf("Table `%s` comment is too long. The length of comment should be within %d characters", tableInfo.displayName, rule.payload.MaxLength),- StartPosition: &storepb.Position{- Line: int32(tableCommentInfo.line),- Column: 0,- },- })- }- }- }-- return checker.GetAdviceList(), nil+ return rule.generateAdvice(), nil}type tableInfo struct {schema stringtableName stringdisplayName string- line int+ line int32}type tableCommentInfo struct {comment string- line int+ line int32}type tableCommentConventionRule struct {- BaseRule+ OmniBaseRulepayload *storepb.SQLReviewRule_CommentConventionRulePayloadcreatedTables map[string]*tableInfotableComments map[string]*tableCommentInfo}-// Name returns the rule name.func (*tableCommentConventionRule) Name() string {return "table-comment-convention"}-// OnEnter handles entering a parse tree node.-func (r *tableCommentConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx)- case "Commentstmt":- r.handleCommentstmt(ctx)+func (r *tableCommentConventionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.CommentStmt:+ r.handleCommentStmt(n)default:- // Ignore other node types}- return nil-}--// OnExit handles exiting a parse tree node.-func (*tableCommentConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-// handleCreatestmt collects CREATE TABLE statements-func (r *tableCommentConventionRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createstmtCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }-- if !isTopLevel(createstmtCtx.GetParent()) {+func (r *tableCommentConventionRule) handleCreateStmt(n *ast.CreateStmt) {+ if n.Relation == nil {return}- var tableName, schemaName string- allQualifiedNames := createstmtCtx.AllQualified_name()- if len(allQualifiedNames) > 0 {- tableName = extractTableName(allQualifiedNames[0])- schemaName = extractSchemaName(allQualifiedNames[0])- if schemaName == "" {- schemaName = "public"- }+ tableName := n.Relation.Relname+ schemaName := n.Relation.Schemaname+ if schemaName == "" {+ schemaName = "public"}tableKey := fmt.Sprintf("%s.%s", schemaName, tableName)- // Only include schema in display name if it's not the default "public" schemadisplayName := tableNameif schemaName != "public" {displayName = fmt.Sprintf("%s.%s", schemaName, tableName)@@ -172,59 +112,82 @@ func (r *tableCommentConventionRule) handleCreatestmt(ctx antlr.ParserRuleContexschema: schemaName,tableName: tableName,displayName: displayName,- line: createstmtCtx.GetStart().GetLine(),+ line: r.absoluteLine(),}}-// handleCommentstmt collects COMMENT ON TABLE statements-func (r *tableCommentConventionRule) handleCommentstmt(ctx antlr.ParserRuleContext) {- commentstmtCtx, ok := ctx.(*parser.CommentstmtContext)- if !ok {+func (r *tableCommentConventionRule) handleCommentStmt(n *ast.CommentStmt) {+ if n.Objtype != ast.OBJECT_TABLE {return}- if !isTopLevel(commentstmtCtx.GetParent()) {- return- }-- // Check if this is COMMENT ON TABLE- if commentstmtCtx.Object_type_any_name() == nil || commentstmtCtx.Object_type_any_name().TABLE() == nil {+ var schemaName, tableName string+ switch obj := n.Object.(type) {+ case *ast.List:+ items := obj.Items+ switch len(items) {+ case 1:+ schemaName = "public"+ tableName = omniStringVal(items[0])+ case 2:+ schemaName = omniStringVal(items[0])+ tableName = omniStringVal(items[1])+ default:+ return+ }+ case *ast.String:+ schemaName = "public"+ tableName = obj.Str+ default:return}- // Extract table name from Any_name- if commentstmtCtx.Any_name() == nil {- return+ tableKey := fmt.Sprintf("%s.%s", schemaName, tableName)+ r.tableComments[tableKey] = &tableCommentInfo{+ comment: n.Comment,+ line: r.absoluteLine(),}+}- parts := pgparser.NormalizePostgreSQLAnyName(commentstmtCtx.Any_name())- if len(parts) == 0 {- return- }+// absoluteLine returns the absolute 1-based line number for the current statement.+func (r *tableCommentConventionRule) absoluteLine() int32 {+ return r.ContentStartLine() + int32(r.BaseLine)+}- var schemaName, tableName string- if len(parts) == 1 {- schemaName = "public"- tableName = parts[0]- } else {- schemaName = parts[0]- tableName = parts[1]- }+func (r *tableCommentConventionRule) generateAdvice() []*storepb.Advice {+ var adviceList []*storepb.Advice- tableKey := fmt.Sprintf("%s.%s", schemaName, tableName)+ for tableKey, ti := range r.createdTables {+ tc, hasComment := r.tableComments[tableKey]- // Extract comment text- comment := ""- if commentstmtCtx.Comment_text() != nil && commentstmtCtx.Comment_text().Sconst() != nil {- commentText := commentstmtCtx.Comment_text().Sconst().GetText()- // Remove surrounding quotes- if len(commentText) >= 2 {- comment = commentText[1 : len(commentText)-1]+ if !hasComment || tc.comment == "" {+ if r.payload.Required {+ adviceList = append(adviceList, &storepb.Advice{+ Status: r.Level,+ Code: code.CommentEmpty.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Comment is required for table `%s`", ti.displayName),+ StartPosition: &storepb.Position{+ Line: ti.line,+ Column: 0,+ },+ })+ }+ } else {+ if r.payload.MaxLength > 0 && int32(len(tc.comment)) > r.payload.MaxLength {+ adviceList = append(adviceList, &storepb.Advice{+ Status: r.Level,+ Code: code.CommentTooLong.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Table `%s` comment is too long. The length of comment should be within %d characters", ti.displayName, r.payload.MaxLength),+ StartPosition: &storepb.Position{+ Line: tc.line,+ Column: 0,+ },+ })+ }}}- r.tableComments[tableKey] = &tableCommentInfo{- comment: comment,- line: commentstmtCtx.GetStart().GetLine(),- }+ return adviceList}diff --git a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go b/backend/plugin/advisor/pg/advisor_table_disallow_partition.goindex 06b762f053..eda8fcd40f 100644--- a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go+++ b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go@@ -4,15 +4,11 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -34,35 +30,18 @@ func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.return nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &tableDisallowPartitionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }- rule.SetBaseLine(stmtInfo.BaseLine())-- checker := NewGenericChecker([]Rule{rule})- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &tableDisallowPartitionRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowPartitionRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRule}// Name returns the rule name.@@ -70,69 +49,46 @@ func (*tableDisallowPartitionRule) Name() string {return "table.disallow-partition"}-// OnEnter is called when the parser enters a rule context.-func (r *tableDisallowPartitionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Partition_cmd":- r.handlePartitionCmd(ctx.(*parser.Partition_cmdContext))+// OnStatement is called for each top-level statement AST node.+func (r *tableDisallowPartitionRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil-}--// OnExit is called when the parser exits a rule context.-func (*tableDisallowPartitionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-func (r *tableDisallowPartitionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check if this is a partitioned table- if ctx.Optpartitionspec() != nil {+func (r *tableDisallowPartitionRule) handleCreateStmt(n *ast.CreateStmt) {+ if n.Partspec != nil {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.CreateTablePartition.Int32(),- Title: r.title,- Content: fmt.Sprintf("Table partition is forbidden, but %q creates", getTextFromTokens(r.tokens, ctx)),+ Title: r.Title,+ Content: fmt.Sprintf("Table partition is forbidden, but %q creates", r.TrimmedStmtText()),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})}}-func (r *tableDisallowPartitionRule) handlePartitionCmd(ctx *parser.Partition_cmdContext) {- if !isTopLevel(ctx.GetParent().GetParent().GetParent()) {- // Partition_cmd is nested: Altertablestmt -> Alter_table_cmds -> Alter_table_cmd -> Partition_cmd- return- }-- // Check for ATTACH PARTITION- if ctx.ATTACH() != nil && ctx.PARTITION() != nil {- // Navigate up to get the Altertablestmt context for line position- parent := ctx.GetParent()- for parent != nil {- if alterTableCtx, ok := parent.(*parser.AltertablestmtContext); ok {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.CreateTablePartition.Int32(),- Title: r.title,- Content: fmt.Sprintf("Table partition is forbidden, but %q creates", getTextFromTokens(r.tokens, alterTableCtx)),- StartPosition: &storepb.Position{- Line: int32(alterTableCtx.GetStart().GetLine()),- Column: 0,- },- })- return- }- parent = parent.GetParent()+func (r *tableDisallowPartitionRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AttachPartition {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.CreateTablePartition.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("Table partition is forbidden, but %q creates", r.TrimmedStmtText()),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })+ return}}}diff --git a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.goindex 3998543bf5..8f7082388e 100644--- a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go+++ b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go@@ -7,16 +7,11 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -49,33 +44,18 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advis}rule := &tableDropNamingConventionRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},format: format,}- checker := NewGenericChecker([]Rule{rule})-- for _, stmt := range checkCtx.ParsedStatements {- if stmt.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- rule.SetBaseLine(stmt.BaseLine())- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-- return checker.GetAdviceList(), nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDropNamingConventionRule struct {- BaseRule+ OmniBaseRuleformat *regexp.Regexp}@@ -84,59 +64,29 @@ func (*tableDropNamingConventionRule) Name() string {return "table.drop-naming-convention"}-// OnEnter is called when the parser enters a rule context.-func (r *tableDropNamingConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Dropstmt":- r.handleDropstmt(ctx.(*parser.DropstmtContext))- default:- // Do nothing for other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*tableDropNamingConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *tableDropNamingConventionRule) handleDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {+// OnStatement is called for each top-level statement AST node.+func (r *tableDropNamingConventionRule) OnStatement(node ast.Node) {+ n, ok := node.(*ast.DropStmt)+ if !ok {return}-- // Check if this is a DROP TABLE statement- if ctx.Object_type_any_name() == nil || ctx.Object_type_any_name().TABLE() == nil {+ if n.RemoveType != int(ast.OBJECT_TABLE) {return}- // Check all tables being dropped- if ctx.Any_name_list() != nil {- allNames := ctx.Any_name_list().AllAny_name()- for _, nameCtx := range allNames {- tableName := r.extractTableNameFromAnyName(nameCtx)- if tableName != "" && !r.format.MatchString(tableName) {- r.AddAdvice(&storepb.Advice{- Status: r.level,- Code: code.TableDropNamingConventionMismatch.Int32(),- Title: r.title,- Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", tableName, r.format),- StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),- Column: 0,- },- })- }+ for _, obj := range omniDropObjects(n) {+ tableName := obj[1] // [schema, name]+ if !r.format.MatchString(tableName) {+ r.AddAdvice(&storepb.Advice{+ Status: r.Level,+ Code: code.TableDropNamingConventionMismatch.Int32(),+ Title: r.Title,+ Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", tableName, r.format),+ StartPosition: &storepb.Position{+ Line: r.ContentStartLine(),+ Column: 0,+ },+ })}}}--// extractTableNameFromAnyName extracts the table name from Any_name context.-// For schema.table, returns "table". For just "table", returns "table".-func (*tableDropNamingConventionRule) extractTableNameFromAnyName(ctx parser.IAny_nameContext) string {- parts := pg.NormalizePostgreSQLAnyName(ctx)- if len(parts) == 0 {- return ""- }- return parts[len(parts)-1]-}diff --git a/backend/plugin/advisor/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.goindex 8ea46fa38c..9e314829d7 100644--- a/backend/plugin/advisor/pg/advisor_table_no_fk.go+++ b/backend/plugin/advisor/pg/advisor_table_no_fk.go@@ -4,15 +4,11 @@ import ("context""fmt"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code")var (@@ -34,164 +30,87 @@ func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*return nil, err}- var adviceList []*storepb.Advice- for _, stmtInfo := range checkCtx.ParsedStatements {- if stmtInfo.AST == nil {- continue- }- antlrAST, ok := base.GetANTLRAST(stmtInfo.AST)- if !ok {- continue- }- rule := &tableNoFKRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),- },- tokens: antlrAST.Tokens,- }-- checker := NewGenericChecker([]Rule{rule})- checker.SetBaseLine(stmtInfo.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- adviceList = append(adviceList, checker.GetAdviceList()...)+ rule := &tableNoFKRule{+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),+ },}- return adviceList, nil+ return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableNoFKRule struct {- BaseRule-- tokens *antlr.CommonTokenStream+ OmniBaseRule}func (*tableNoFKRule) Name() string {return "table_no_fk"}-func (r *tableNoFKRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx)- case "Altertablestmt":- r.handleAltertablestmt(ctx)+func (r *tableNoFKRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)default:- // Do nothing for other node types}- return nil}-func (*tableNoFKRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}+// handleCreateStmt handles CREATE TABLE with FK constraints.+func (r *tableNoFKRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ schema := omniSchemaName(n.Relation)-// handleCreatestmt handles CREATE TABLE with FK constraints-func (r *tableNoFKRule) handleCreatestmt(ctx antlr.ParserRuleContext) {- createstmtCtx, ok := ctx.(*parser.CreatestmtContext)- if !ok {- return- }+ cols, constraints := omniTableElements(n)- if !isTopLevel(createstmtCtx.GetParent()) {- return- }-- var tableName, schemaName string- allQualifiedNames := createstmtCtx.AllQualified_name()- if len(allQualifiedNames) > 0 {- tableName = extractTableName(allQualifiedNames[0])- schemaName = extractSchemaName(allQualifiedNames[0])- if schemaName == "" {- schemaName = "public"+ // Check table-level constraints for FOREIGN KEY+ for _, c := range constraints {+ if c.Contype == ast.CONSTR_FOREIGN {+ r.addFKAdvice(schema, tableName)+ return}}- // Check table-level constraints- if createstmtCtx.Opttableelementlist() != nil && createstmtCtx.Opttableelementlist().Tableelementlist() != nil {- allElements := createstmtCtx.Opttableelementlist().Tableelementlist().AllTableelement()- for _, elem := range allElements {- // Check if this is a table constraint- if elem.Tableconstraint() != nil {- constraint := elem.Tableconstraint()- if constraint.Constraintelem() != nil {- constraintElem := constraint.Constraintelem()- // Check for FOREIGN KEY- if constraintElem.FOREIGN() != nil && constraintElem.KEY() != nil {- r.addFKAdvice(schemaName, tableName, createstmtCtx)- return- }- }- }-- // Check column-level constraints- if elem.ColumnDef() != nil {- columnDef := elem.ColumnDef()- if columnDef.Colquallist() != nil {- allQuals := columnDef.Colquallist().AllColconstraint()- for _, qual := range allQuals {- if qual.Colconstraintelem() != nil {- constraintElem := qual.Colconstraintelem()- // Check for REFERENCES (column-level FK)- if constraintElem.REFERENCES() != nil {- r.addFKAdvice(schemaName, tableName, createstmtCtx)- return- }- }- }- }+ // Check column-level constraints for REFERENCES (column-level FK)+ for _, col := range cols {+ for _, c := range omniColumnConstraints(col) {+ if c.Contype == ast.CONSTR_FOREIGN {+ r.addFKAdvice(schema, tableName)+ return}}}}-// handleAltertablestmt handles ALTER TABLE ADD CONSTRAINT with FK-func (r *tableNoFKRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {- altertablestmtCtx, ok := ctx.(*parser.AltertablestmtContext)- if !ok {- return- }+// handleAlterTableStmt handles ALTER TABLE ADD CONSTRAINT with FK.+func (r *tableNoFKRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)+ schema := omniSchemaName(n.Relation)- if !isTopLevel(altertablestmtCtx.GetParent()) {- return- }-- var tableName, schemaName string- if altertablestmtCtx.Relation_expr() != nil && altertablestmtCtx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(altertablestmtCtx.Relation_expr().Qualified_name())- schemaName = extractSchemaName(altertablestmtCtx.Relation_expr().Qualified_name())- if schemaName == "" {- schemaName = "public"- }- }-- // Check all alter table commands for ADD CONSTRAINT with FOREIGN KEY- if altertablestmtCtx.Alter_table_cmds() != nil {- allCmds := altertablestmtCtx.Alter_table_cmds().AllAlter_table_cmd()- for _, cmd := range allCmds {- if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {- constraint := cmd.Tableconstraint()- if constraint.Constraintelem() != nil {- constraintElem := constraint.Constraintelem()- // Check for FOREIGN KEY- if constraintElem.FOREIGN() != nil && constraintElem.KEY() != nil {- r.addFKAdvice(schemaName, tableName, altertablestmtCtx)- return- }- }+ for _, cmd := range omniAlterTableCmds(n) {+ if ast.AlterTableType(cmd.Subtype) == ast.AT_AddConstraint {+ constraint, ok := cmd.Def.(*ast.Constraint)+ if !ok || constraint == nil {+ continue+ }+ if constraint.Contype == ast.CONSTR_FOREIGN {+ r.addFKAdvice(schema, tableName)+ return}}}}-func (r *tableNoFKRule) addFKAdvice(schemaName, tableName string, ctx antlr.ParserRuleContext) {+func (r *tableNoFKRule) addFKAdvice(schemaName, tableName string) {r.AddAdvice(&storepb.Advice{- Status: r.level,+ Status: r.Level,Code: code.TableHasFK.Int32(),- Title: r.title,- Content: fmt.Sprintf("Foreign key is not allowed in the table %q.%q, related statement: \"%s\"", schemaName, tableName, getTextFromTokens(r.tokens, ctx)),+ Title: r.Title,+ Content: fmt.Sprintf("Foreign key is not allowed in the table %q.%q, related statement: \"%s\"", schemaName, tableName, r.TrimmedStmtText()),StartPosition: &storepb.Position{- Line: int32(ctx.GetStart().GetLine()),+ Line: r.ContentStartLine(),Column: 0,},})diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.goindex 5509e70bc9..8a77305393 100644--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go@@ -4,14 +4,11 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4"-- parser "github.com/bytebase/parser/postgresql"+ "github.com/bytebase/omni/pg/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"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg""github.com/bytebase/bytebase/backend/store/model")@@ -36,48 +33,43 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)}rule := &tableRequirePKRule{- BaseRule: BaseRule{- level: level,- title: checkCtx.Rule.Type.String(),+ OmniBaseRule: OmniBaseRule{+ Level: level,+ Title: checkCtx.Rule.Type.String(),},finalMetadata: checkCtx.FinalMetadata,tableMentions: make(map[string]*tableMention),}- checker := NewGenericChecker([]Rule{rule})-+ // Manually iterate statements instead of using RunOmniRules because+ // validateFinalState must be called AFTER all statements have been processed.for _, stmt := range checkCtx.ParsedStatements {if stmt.AST == nil {continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)+ node, ok := pgparser.GetOmniNode(stmt.AST)if !ok {continue}- rule.SetBaseLine(stmt.BaseLine())- rule.tokens = antlrAST.Tokens- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)+ rule.SetStatement(stmt.BaseLine(), stmt.Text)+ rule.OnStatement(node)}- // Simple Solution: Validate final state after walking all statementsrule.validateFinalState()- return checker.GetAdviceList(), nil+ return rule.GetAdviceList(), nil}type tableMention struct {startLine int- endLine inttext string}type tableRequirePKRule struct {- BaseRule- tokens *antlr.CommonTokenStream+ OmniBaseRulefinalMetadata *model.DatabaseMetadata- // Simple Solution: Track last mention of each table+ // Track last mention of each tabletableMentions map[string]*tableMention // key: "schema.table", value: last mention info}@@ -86,113 +78,66 @@ func (*tableRequirePKRule) Name() string {return "table.require-pk"}-// OnEnter is called when the parser enters a rule context.-func (r *tableRequirePKRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Createstmt":- r.handleCreatestmt(ctx.(*parser.CreatestmtContext))- case "Altertablestmt":- r.handleAltertablestmt(ctx.(*parser.AltertablestmtContext))- case "Dropstmt":- r.handleDropstmt(ctx.(*parser.DropstmtContext))+// OnStatement is called for each top-level statement AST node.+func (r *tableRequirePKRule) OnStatement(node ast.Node) {+ switch n := node.(type) {+ case *ast.CreateStmt:+ r.handleCreateStmt(n)+ case *ast.AlterTableStmt:+ r.handleAlterTableStmt(n)+ case *ast.DropStmt:+ r.handleDropStmt(n)default:- // Do nothing for other node types}- return nil-}--// OnExit is called when the parser exits a rule context.-func (*tableRequirePKRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil}-// handleCreatestmt records CREATE TABLE statements (Simple Solution)-func (r *tableRequirePKRule) handleCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {+// handleCreateStmt records CREATE TABLE statements.+func (r *tableRequirePKRule) handleCreateStmt(n *ast.CreateStmt) {+ tableName := omniTableName(n.Relation)+ if tableName == "" {return}+ schema := omniSchemaName(n.Relation)- var tableName, schemaName string- allQualifiedNames := ctx.AllQualified_name()- if len(allQualifiedNames) > 0 {- tableName = extractTableName(allQualifiedNames[0])- schemaName = extractSchemaName(allQualifiedNames[0])- if schemaName == "" {- schemaName = "public"- }- }-- // Simple Solution: Just record the table mention (ALWAYS update for last occurrence)- // Store absolute line numbers (with baseLine offset added now)- key := fmt.Sprintf("%s.%s", schemaName, tableName)+ key := fmt.Sprintf("%s.%s", schema, tableName)r.tableMentions[key] = &tableMention{- startLine: ctx.GetStart().GetLine() + r.baseLine,- endLine: ctx.GetStop().GetLine() + r.baseLine,- text: getTextFromTokens(r.tokens, ctx),+ startLine: int(r.ContentStartLine()) + r.BaseLine,+ text: r.TrimmedStmtText(),}}-// handleAltertablestmt records ALTER TABLE statements (Simple Solution)-func (r *tableRequirePKRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {+// handleAlterTableStmt records ALTER TABLE statements.+func (r *tableRequirePKRule) handleAlterTableStmt(n *ast.AlterTableStmt) {+ tableName := omniTableName(n.Relation)+ if tableName == "" {return}+ schema := omniSchemaName(n.Relation)- var tableName, schemaName string- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {- tableName = extractTableName(ctx.Relation_expr().Qualified_name())- schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())- if schemaName == "" {- schemaName = "public"- }- }-- // Simple Solution: Just record the table mention (ALWAYS update for last occurrence)- // Store absolute line numbers (with baseLine offset added now)- key := fmt.Sprintf("%s.%s", schemaName, tableName)+ key := fmt.Sprintf("%s.%s", schema, tableName)r.tableMentions[key] = &tableMention{- startLine: ctx.GetStart().GetLine() + r.baseLine,- endLine: ctx.GetStop().GetLine() + r.baseLine,- text: getTextFromTokens(r.tokens, ctx),+ startLine: int(r.ContentStartLine()) + r.BaseLine,+ text: r.TrimmedStmtText(),}}-// handleDropstmt handles DROP TABLE - remove from tracking-func (r *tableRequirePKRule) handleDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {+// handleDropStmt handles DROP TABLE - remove from tracking.+func (r *tableRequirePKRule) handleDropStmt(n *ast.DropStmt) {+ if n.RemoveType != int(ast.OBJECT_TABLE) {return}- // Check if this is DROP TABLE- if ctx.Object_type_any_name() == nil || ctx.Object_type_any_name().TABLE() == nil {- return- }-- // Remove all dropped tables from tracking (simplified - best effort)- // Note: For the Simple Solution, not handling DROP TABLE perfectly is acceptable- // since dropped tables won't be in catalog.Final anyway- if ctx.Any_name_list() != nil {- allNames := ctx.Any_name_list().AllAny_name()- for _, anyName := range allNames {- if anyName.Colid() != nil {- // Simple table name (most common case)- name := pgparser.NormalizePostgreSQLColid(anyName.Colid())- key := fmt.Sprintf("public.%s", name)- delete(r.tableMentions, key)- }- // For qualified names, we skip for simplicity - they won't cause false positives- // because catalog.Final won't have dropped tables- }+ for _, obj := range omniDropObjects(n) {+ key := fmt.Sprintf("%s.%s", obj[0], obj[1])+ delete(r.tableMentions, key)}}-// validateFinalState checks all mentioned tables against catalog.Final (Simple Solution)+// validateFinalState checks all mentioned tables against FinalMetadata for PRIMARY KEY.func (r *tableRequirePKRule) validateFinalState() {for tableKey, mention := range r.tableMentions {- // Parse table key: "schema.table"schemaName, tableName := parseTableKey(tableKey)- // Check catalog.Final for PRIMARY KEYschema := r.finalMetadata.GetSchemaMetadata(schemaName)var hasPK boolif schema != nil {@@ -205,17 +150,14 @@ func (r *tableRequirePKRule) validateFinalState() {if !hasPK {content := fmt.Sprintf("Table %q.%q requires PRIMARY KEY", schemaName, tableName)- // Include the related statementif mention.text != "" {content = fmt.Sprintf("%s, related statement: %q", content, mention.text)}- // Directly append to adviceList instead of using AddAdvice,- // because mention.startLine already contains the absolute line number- r.adviceList = append(r.adviceList, &storepb.Advice{- Status: r.level,+ r.AddAdviceAbsolute(&storepb.Advice{+ Status: r.Level,Code: code.TableNoPK.Int32(),- Title: r.title,+ Title: r.Title,Content: content,StartPosition: &storepb.Position{Line: int32(mention.startLine),@@ -226,9 +168,8 @@ func (r *tableRequirePKRule) validateFinalState() {}}-// parseTableKey splits "schema.table" into schema and table name+// parseTableKey splits "schema.table" into schema and table name.func parseTableKey(key string) (string, string) {- // Simple split on first dotfor i := 0; i < len(key); i++ {if key[i] == '.' {return key[:i], key[i+1:]diff --git a/backend/plugin/advisor/pg/generic_checker.go b/backend/plugin/advisor/pg/generic_checker.goindex 434bc192c9..f9d8467236 100644--- a/backend/plugin/advisor/pg/generic_checker.go+++ b/backend/plugin/advisor/pg/generic_checker.go@@ -97,8 +97,6 @@ func (*GenericChecker) getNodeType(ctx antlr.ParserRuleContext) string {// BaseRule provides common functionality for rules.// Other rules can embed this struct to get common behavior.type BaseRule struct {- level storepb.Advice_Status- title stringadviceList []*storepb.AdvicebaseLine int}diff --git a/backend/plugin/advisor/pg/generic_checker_omni.go b/backend/plugin/advisor/pg/generic_checker_omni.gonew file mode 100644index 0000000000..cc27413848--- /dev/null+++ b/backend/plugin/advisor/pg/generic_checker_omni.go@@ -0,0 +1,151 @@+package pg++import (+ "strings"++ "github.com/bytebase/omni/pg/ast"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++// OmniRule defines the interface for omni-based SQL validation rules.+type OmniRule interface {+ // OnStatement is called for each top-level statement AST node.+ OnStatement(node ast.Node)++ // Name returns the rule name for logging/debugging.+ Name() string++ // GetAdviceList returns the accumulated advice from this rule.+ GetAdviceList() []*storepb.Advice+}++// OmniBaseRule provides common functionality for omni-based rules.+type OmniBaseRule struct {+ Level storepb.Advice_Status+ Title string+ Advice []*storepb.Advice+ BaseLine int+ StmtText string+}++// SetStatement sets the statement context for position calculations.+func (r *OmniBaseRule) SetStatement(baseLine int, stmtText string) {+ r.BaseLine = baseLine+ r.StmtText = stmtText+}++// GetAdviceList returns the accumulated advice.+func (r *OmniBaseRule) GetAdviceList() []*storepb.Advice {+ return r.Advice+}++// AddAdvice adds advice. The BaseLine offset is added automatically to StartPosition.Line.+func (r *OmniBaseRule) AddAdvice(advice *storepb.Advice) {+ if advice.StartPosition != nil {+ advice.StartPosition.Line += int32(r.BaseLine)+ }+ r.Advice = append(r.Advice, advice)+}++// AddAdviceAbsolute adds advice with an already-absolute line number.+func (r *OmniBaseRule) AddAdviceAbsolute(advice *storepb.Advice) {+ r.Advice = append(r.Advice, advice)+}++// LocToLine converts an omni Loc byte offset to a 1-based line number+// relative to the current statement (suitable for AddAdvice which adds BaseLine).+func (r *OmniBaseRule) LocToLine(loc ast.Loc) int32 {+ if loc.Start < 0 || r.StmtText == "" {+ return r.ContentStartLine()+ }+ pos := pgparser.ByteOffsetToRunePosition(r.StmtText, loc.Start)+ return pos.Line+}++// TrimmedStmtText returns the statement text with leading/trailing whitespace+// and trailing semicolons removed. This matches the behavior of the ANTLR+// getTextFromTokens helper that did not include semicolons.+func (r *OmniBaseRule) TrimmedStmtText() string {+ return strings.TrimRight(strings.TrimSpace(r.StmtText), ";")+}++// ContentStartLine returns the 1-based line number of the first non-whitespace+// character in StmtText. This accounts for leading newlines that SplitSQL may+// include in the statement text. Returns 1 if the text is empty or has no+// leading newlines.+func (r *OmniBaseRule) ContentStartLine() int32 {+ idx := strings.IndexFunc(r.StmtText, func(c rune) bool {+ return c != ' ' && c != '\t' && c != '\n' && c != '\r'+ })+ if idx <= 0 {+ return 1+ }+ pos := pgparser.ByteOffsetToRunePosition(r.StmtText, idx)+ return pos.Line+}++// ContentEndLine returns the 1-based line number of the last non-whitespace+// character in StmtText. This matches ANTLR's GetStop().GetLine() behavior.+func (r *OmniBaseRule) ContentEndLine() int32 {+ if r.StmtText == "" {+ return 1+ }+ // Find last non-whitespace character+ idx := -1+ for i := len(r.StmtText) - 1; i >= 0; i-- {+ c := r.StmtText[i]+ if c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != ';' {+ idx = i+ break+ }+ }+ if idx <= 0 {+ return 1+ }+ pos := pgparser.ByteOffsetToRunePosition(r.StmtText, idx)+ return pos.Line+}++// FindLineByName searches for an identifier name in the statement text and returns+// its 1-based line number. Falls back to ContentStartLine() if not found.+// This is useful when the AST node's Loc is unknown (-1) but we need a line number.+func (r *OmniBaseRule) FindLineByName(name string) int32 {+ if name == "" || r.StmtText == "" {+ return r.ContentStartLine()+ }+ idx := strings.Index(r.StmtText, name)+ if idx < 0 {+ return r.ContentStartLine()+ }+ pos := pgparser.ByteOffsetToRunePosition(r.StmtText, idx)+ return pos.Line+}++// RunOmniRules iterates over parsed statements and dispatches each omni AST node to all rules.+// Returns combined advice from all rules. Skips statements without omni AST.+func RunOmniRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {+ for _, stmt := range stmts {+ if stmt.AST == nil {+ continue+ }+ node, ok := pgparser.GetOmniNode(stmt.AST)+ if !ok {+ continue+ }+ baseLine := stmt.BaseLine()+ for _, rule := range rules {+ if br, ok := rule.(interface{ SetStatement(int, string) }); ok {+ br.SetStatement(baseLine, stmt.Text)+ }+ rule.OnStatement(node)+ }+ }+ var allAdvice []*storepb.Advice+ for _, rule := range rules {+ allAdvice = append(allAdvice, rule.GetAdviceList()...)+ }+ return allAdvice+}diff --git a/backend/plugin/advisor/pg/test/statement_disallow_on_del_cascade.yaml b/backend/plugin/advisor/pg/test/statement_disallow_on_del_cascade.yamlindex 9e9e5abf2a..ca9a1187c3 100644--- a/backend/plugin/advisor/pg/test/statement_disallow_on_del_cascade.yaml+++ b/backend/plugin/advisor/pg/test/statement_disallow_on_del_cascade.yaml@@ -14,7 +14,7 @@content: The CASCADE option is not permitted for ON DELETE clausesstartposition:line: 1- column: 1+ column: 0endposition: null- statement: |-CREATE TABLE users (@@ -39,6 +39,6 @@title: STATEMENT_DISALLOW_ON_DEL_CASCADEcontent: The CASCADE option is not permitted for ON DELETE clausesstartposition:- line: 2- column: 1+ line: 3+ column: 0endposition: nulldiff --git a/backend/plugin/advisor/pg/test/table_comment.yaml b/backend/plugin/advisor/pg/test/table_comment.yamlindex 2a2bbfe1a1..ca0c9e1489 100644--- a/backend/plugin/advisor/pg/test/table_comment.yaml+++ b/backend/plugin/advisor/pg/test/table_comment.yaml@@ -24,7 +24,7 @@title: TABLE_COMMENTcontent: Comment is required for table `d`startposition:- line: 3+ line: 2column: 0endposition: null- statement: |-@@ -38,7 +38,7 @@title: TABLE_COMMENTcontent: Comment is required for table `t`startposition:- line: 2+ line: 1column: 0endposition: null- statement: |-@@ -52,7 +52,7 @@title: TABLE_COMMENTcontent: Comment is required for table `t`startposition:- line: 2+ line: 1column: 0endposition: null- statement: |-diff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.goindex 31d9b43978..52c6bade14 100644--- a/backend/plugin/advisor/pg/utils.go+++ b/backend/plugin/advisor/pg/utils.go@@ -106,20 +106,7 @@ func extractSchemaName(ctx parser.IQualified_nameContext) string {return parts[0]}-// extractIntegerConstant extracts an integer value from an Iconst context.-// Returns the integer value and an error if parsing fails.-func extractIntegerConstant(ctx parser.IIconstContext) (int, error) {- if ctx == nil {- return 0, errors.New("iconst context is nil")- }- text := ctx.GetText()- val, err := strconv.Atoi(text)- if err != nil {- return 0, errors.Wrapf(err, "failed to parse integer constant: %s", text)- }- return val, nil-}-+// nolint:unused// extractStringConstant extracts a string value from an Sconst context.// Removes surrounding quotes and handles basic escape sequences.func extractStringConstant(ctx parser.ISconstContext) string {@@ -154,3 +141,44 @@ func normalizeSchemaName(schemaName string) string {}return schemaName}++// getAffectedRows extracts the estimated row count from a PostgreSQL EXPLAIN result.+func getAffectedRows(res []any) (int64, error) {+ // the res struct is []any{columnName, columnTable, rowDataList}+ if len(res) != 3 {+ return 0, errors.Errorf("expected 3 but got %d", len(res))+ }+ rowList, ok := res[2].([]any)+ if !ok {+ return 0, errors.Errorf("expected []any but got %t", res[2])+ }+ // EXPLAIN output has at least 2 rows+ if len(rowList) < 2 {+ return 0, errors.Errorf("not found any data")+ }+ // We need row 2+ rowTwo, ok := rowList[1].([]any)+ if !ok {+ return 0, errors.Errorf("expected []any but got %t", rowList[0])+ }+ // PostgreSQL EXPLAIN result has one column+ if len(rowTwo) != 1 {+ return 0, errors.Errorf("expected one but got %d", len(rowTwo))+ }+ // Get the string value+ text, ok := rowTwo[0].(string)+ if !ok {+ return 0, errors.Errorf("expected string but got %t", rowTwo[0])+ }++ rowsRegexp := regexp.MustCompile("rows=([0-9]+)")+ matches := rowsRegexp.FindStringSubmatch(text)+ if len(matches) != 2 {+ return 0, errors.Errorf("failed to find rows in %q", text)+ }+ value, err := strconv.ParseInt(matches[1], 10, 64)+ if err != nil {+ return 0, errors.Errorf("failed to get integer from %q", matches[1])+ }+ return value, nil+}diff --git a/backend/plugin/advisor/pg/utils_omni.go b/backend/plugin/advisor/pg/utils_omni.gonew file mode 100644index 0000000000..ec3ff4986c--- /dev/null+++ b/backend/plugin/advisor/pg/utils_omni.go@@ -0,0 +1,270 @@+package pg++import (+ "fmt"+ "strings"++ "github.com/bytebase/omni/pg/ast"+)++// nolint:unused+// omniTableName extracts the table name from a RangeVar.+func omniTableName(rv *ast.RangeVar) string {+ if rv == nil {+ return ""+ }+ return rv.Relname+}++// nolint:unused+// omniSchemaName extracts the schema name from a RangeVar, defaulting to "public".+func omniSchemaName(rv *ast.RangeVar) string {+ if rv == nil || rv.Schemaname == "" {+ return "public"+ }+ return rv.Schemaname+}++// nolint:unused+// omniConstraintColumns extracts column names from a Constraint's Keys list.+func omniConstraintColumns(c *ast.Constraint) []string {+ if c == nil || c.Keys == nil {+ return nil+ }+ var cols []string+ for _, item := range c.Keys.Items {+ if s, ok := item.(*ast.String); ok {+ cols = append(cols, s.Str)+ }+ }+ return cols+}++// nolint:unused+// omniColumnConstraints iterates over a ColumnDef's constraint list.+func omniColumnConstraints(col *ast.ColumnDef) []*ast.Constraint {+ if col == nil || col.Constraints == nil {+ return nil+ }+ var result []*ast.Constraint+ for _, item := range col.Constraints.Items {+ if c, ok := item.(*ast.Constraint); ok {+ result = append(result, c)+ }+ }+ return result+}++// nolint:unused+// omniTableElements iterates over a CreateStmt's table elements,+// returning column defs and table constraints separately.+func omniTableElements(create *ast.CreateStmt) ([]*ast.ColumnDef, []*ast.Constraint) {+ if create.TableElts == nil {+ return nil, nil+ }+ var cols []*ast.ColumnDef+ var cons []*ast.Constraint+ for _, item := range create.TableElts.Items {+ switch n := item.(type) {+ case *ast.ColumnDef:+ cols = append(cols, n)+ case *ast.Constraint:+ cons = append(cons, n)+ default:+ }+ }+ return cols, cons+}++// nolint:unused+// omniAlterTableCmds extracts AlterTableCmd items from an AlterTableStmt.+func omniAlterTableCmds(alter *ast.AlterTableStmt) []*ast.AlterTableCmd {+ if alter.Cmds == nil {+ return nil+ }+ var cmds []*ast.AlterTableCmd+ for _, item := range alter.Cmds.Items {+ if cmd, ok := item.(*ast.AlterTableCmd); ok {+ cmds = append(cmds, cmd)+ }+ }+ return cmds+}++// nolint:unused+// omniIsRoleOrSearchPathSet checks if a VariableSetStmt is SET ROLE or SET search_path.+func omniIsRoleOrSearchPathSet(stmt *ast.VariableSetStmt) bool {+ if stmt == nil {+ return false+ }+ name := strings.ToLower(stmt.Name)+ return name == "role" || name == "search_path"+}++// nolint:unused+// omniTypeName extracts the type name string from a TypeName node.+func omniTypeName(tn *ast.TypeName) string {+ if tn == nil || tn.Names == nil {+ return ""+ }+ var parts []string+ for _, item := range tn.Names.Items {+ if s, ok := item.(*ast.String); ok {+ parts = append(parts, s.Str)+ }+ }+ if len(parts) > 0 {+ return parts[len(parts)-1]+ }+ return ""+}++// omniTypeNameFull extracts the full type name with modifiers from a TypeName node.+// For example, "character varying(20)" instead of just "character varying".+func omniTypeNameFull(tn *ast.TypeName) string {+ name := omniTypeName(tn)+ if name == "" {+ return ""+ }+ if tn.Typmods != nil && len(tn.Typmods.Items) > 0 {+ var mods []string+ for _, item := range tn.Typmods.Items {+ switch v := item.(type) {+ case *ast.Integer:+ mods = append(mods, fmt.Sprintf("%d", v.Ival))+ case *ast.A_Const:+ if iv, ok := v.Val.(*ast.Integer); ok {+ mods = append(mods, fmt.Sprintf("%d", iv.Ival))+ }+ default:+ }+ }+ if len(mods) > 0 {+ name += "(" + strings.Join(mods, ",") + ")"+ }+ }+ if tn.ArrayBounds != nil && len(tn.ArrayBounds.Items) > 0 {+ name += "[]"+ }+ return name+}++// omniListStrings extracts string values from an ast.List.+func omniListStrings(list *ast.List) []string {+ if list == nil {+ return nil+ }+ var result []string+ for _, item := range list.Items {+ if s, ok := item.(*ast.String); ok {+ result = append(result, s.Str)+ }+ }+ return result+}++// omniIndexColumns extracts column names from an IndexStmt's IndexParams list.+func omniIndexColumns(idx *ast.IndexStmt) []string {+ if idx == nil || idx.IndexParams == nil {+ return nil+ }+ var cols []string+ for _, item := range idx.IndexParams.Items {+ if elem, ok := item.(*ast.IndexElem); ok && elem.Name != "" {+ cols = append(cols, elem.Name)+ }+ }+ return cols+}++// omniDropObjectNames extracts object names from a DropStmt.+// Returns list of qualified name string slices.+func omniDropObjectNames(drop *ast.DropStmt) [][]string {+ if drop.Objects == nil {+ return nil+ }+ var result [][]string+ for _, item := range drop.Objects.Items {+ list, ok := item.(*ast.List)+ if !ok {+ continue+ }+ var parts []string+ for _, nameItem := range list.Items {+ if s, ok := nameItem.(*ast.String); ok {+ parts = append(parts, s.Str)+ }+ }+ if len(parts) > 0 {+ result = append(result, parts)+ }+ }+ return result+}++// omniCollectFromClauseRangeVars recursively collects RangeVar nodes from a FROM clause list.+func omniCollectFromClauseRangeVars(fromClause *ast.List) []*ast.RangeVar {+ if fromClause == nil {+ return nil+ }+ var result []*ast.RangeVar+ for _, item := range fromClause.Items {+ result = append(result, omniCollectRangeVars(item)...)+ }+ return result+}++// omniCollectRangeVars recursively collects RangeVar nodes from a node,+// including those inside subqueries.+func omniCollectRangeVars(node ast.Node) []*ast.RangeVar {+ if node == nil {+ return nil+ }+ switch n := node.(type) {+ case *ast.RangeVar:+ return []*ast.RangeVar{n}+ case *ast.JoinExpr:+ var result []*ast.RangeVar+ result = append(result, omniCollectRangeVars(n.Larg)...)+ result = append(result, omniCollectRangeVars(n.Rarg)...)+ return result+ case *ast.RangeSubselect:+ // Recurse into subquery+ if sel, ok := n.Subquery.(*ast.SelectStmt); ok {+ return omniCollectFromClauseRangeVars(sel.FromClause)+ }+ return nil+ default:+ return nil+ }+}++// nolint:unused+// omniDropObjects extracts object names from a DropStmt.+// Returns list of (schema, name) pairs.+func omniDropObjects(drop *ast.DropStmt) [][2]string {+ if drop.Objects == nil {+ return nil+ }+ var result [][2]string+ for _, item := range drop.Objects.Items {+ list, ok := item.(*ast.List)+ if !ok {+ continue+ }+ var parts []string+ for _, nameItem := range list.Items {+ if s, ok := nameItem.(*ast.String); ok {+ parts = append(parts, s.Str)+ }+ }+ switch len(parts) {+ case 1:+ result = append(result, [2]string{"public", parts[0]})+ case 2:+ result = append(result, [2]string{parts[0], parts[1]})+ default:+ }+ }+ return result+}diff --git a/backend/plugin/parser/pg/diagnose.go b/backend/plugin/parser/pg/diagnose.goindex eb23d307ea..d082d41c04 100644--- a/backend/plugin/parser/pg/diagnose.go+++ b/backend/plugin/parser/pg/diagnose.go@@ -49,7 +49,7 @@ func parsePostgreSQLStatement(statement string) *base.SyntaxError {}}- pos := byteOffsetToRunePosition(statement, parseErr.Position)+ pos := ByteOffsetToRunePosition(statement, parseErr.Position)return &base.SyntaxError{Position: pos,Message: parseErr.Message,diff --git a/backend/plugin/parser/pg/omni.go b/backend/plugin/parser/pg/omni.goindex 621e66d4f1..a6371d03a8 100644--- a/backend/plugin/parser/pg/omni.go+++ b/backend/plugin/parser/pg/omni.go@@ -57,9 +57,9 @@ func GetOmniNode(a base.AST) (ast.Node, bool) {return omniAST.Node, true}-// byteOffsetToRunePosition converts a byte offset in sql to a 1-based line:column+// ByteOffsetToRunePosition converts a byte offset in sql to a 1-based line:column// where column is measured in Unicode code points (runes), matching storepb.Position semantics.-func byteOffsetToRunePosition(sql string, byteOffset int) *storepb.Position {+func ByteOffsetToRunePosition(sql string, byteOffset int) *storepb.Position {if byteOffset > len(sql) {byteOffset = len(sql)}diff --git a/backend/plugin/parser/pg/parser_integration_test.go b/backend/plugin/parser/pg/parser_integration_test.goindex d19e05f8c4..5965eb7927 100644--- a/backend/plugin/parser/pg/parser_integration_test.go+++ b/backend/plugin/parser/pg/parser_integration_test.go@@ -56,7 +56,7 @@ FRAM t1;`,if parseErr != nil {var pe *omniparser.ParseErrorrequire.True(t, errors.As(parseErr, &pe), "expected *ParseError, got %T", parseErr)- pos := byteOffsetToRunePosition(stmt.Text, pe.Position)+ pos := ByteOffsetToRunePosition(stmt.Text, pe.Position)// Adjust line by the statement's base line.if stmt.Start != nil {pos.Line += stmt.Start.Line - 1diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.goindex 02e39d90f0..24e1d56ba8 100644--- a/backend/plugin/parser/pg/pg.go+++ b/backend/plugin/parser/pg/pg.go@@ -87,7 +87,7 @@ func convertOmniError(err error, _ string, stmt base.Statement) error {}// Convert byte offset within stmt.Text to line:column.- pos := byteOffsetToRunePosition(stmt.Text, parseErr.Position)+ pos := ByteOffsetToRunePosition(stmt.Text, parseErr.Position)// Adjust line by the statement's base line (stmt.Start.Line is 1-based).if stmt.Start != nil {diff --git a/backend/plugin/parser/pg/split.go b/backend/plugin/parser/pg/split.goindex 9c3b3d2b67..8728d8e1b9 100644--- a/backend/plugin/parser/pg/split.go+++ b/backend/plugin/parser/pg/split.go@@ -23,8 +23,8 @@ func SplitSQL(statement string) ([]base.Statement, error) {result = append(result, base.Statement{Text: seg.Text,Empty: seg.Empty(),- Start: byteOffsetToRunePosition(statement, seg.ByteStart),- End: byteOffsetToRunePosition(statement, seg.ByteEnd),+ Start: ByteOffsetToRunePosition(statement, seg.ByteStart),+ End: ByteOffsetToRunePosition(statement, seg.ByteEnd),Range: &storepb.Range{Start: int32(seg.ByteStart),End: int32(seg.ByteEnd),