Skip to content

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

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.go
index 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 pg
import (
"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 advisor
if 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 advisor
return 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 true
default:
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 statement
type StatementType int
@@ -278,101 +228,107 @@ type TableReference struct {
type statementInfo struct {
offset int
statement string
- tree antlr.ParserRuleContext
table *TableReference
}
func prepareTransformation(parsedStatements []base.ParsedStatement) []statementInfo {
- extractor := &dmlExtractor{}
+ var dmls []statementInfo
+ offset := 0
for _, 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.go
index 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 pg
import (
"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
+ OmniBaseRule
allowlist 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.go
index 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 advisor
commentPayload := 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 comments
return rule.generateAdvice(), nil
}
@@ -63,7 +58,7 @@ type columnInfo struct {
schema string
table string
column string
- line int
+ line int32
}
type commentInfo struct {
@@ -71,14 +66,12 @@ type commentInfo struct {
table string
column string
comment string
- line int
+ line int32
}
type columnCommentConventionRule struct {
- BaseRule
+ OmniBaseRule
- level storepb.Advice_Status
- title string
payload *storepb.SQLReviewRule_CommentConventionRulePayload
columns []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 validate
for _, col := range r.columns {
- // Find the last matching comment for this column
var matchedComment *commentInfo
for 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.go
index 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 pg
import (
"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.go
index 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 pg
import (
"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.go
index 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 pg
import (
"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
+ OmniBaseRule
maximum 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.go
index 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 walked
rule.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]int32
type columnNoNullRule struct {
- BaseRule
+ OmniBaseRule
originalMetadata *model.DatabaseMetadata
nullableColumns 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 []columnName
for column := range r.nullableColumns {
@@ -121,7 +129,6 @@ func (r *columnNoNullRule) generateAdvice() {
}
if len(columnList) > 0 {
- // Order it cause the random iteration order in Go
slices.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 first
lineNumber := 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.go
index 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.go
index 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.Conte
return nil, errors.New("string_array_payload is required for column required rule")
}
- // Convert to map for O(1) lookup
requiredColumnsMap := 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.go
index 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 comparison
typeRestriction := 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
+ OmniBaseRule
typeRestriction 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 list
var matchedDisallowedType string
for disallowedType := range r.typeRestriction {
if areTypesEquivalent(typeText, disallowedType) {
@@ -188,12 +122,12 @@ func (r *columnTypeDisallowListRule) checkType(tableName, columnName string, typ
if 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.go
index 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
+ OmniBaseRule
maxLength 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.go
index 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.Conte
stringArrayPayload := checkCtx.Rule.GetStringArrayPayload()
- // Convert allowlist to lowercase for case-insensitive comparison
allowlist := 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
+ OmniBaseRule
allowlist 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.go
index 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 pg
import (
"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
+ OmniBaseRule
newlyCreatedTables 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.go
index 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
+ OmniBaseRule
max 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.go
index 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.go
index 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 ad
stringArrayPayload := 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
+ OmniBaseRule
allowlist []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 mapping
columnTypes := 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.go
index 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.C
return 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.go
index 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 advis
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 := &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.go
index 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 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 := &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.go
index 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.Contex
return 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
+ OmniBaseRule
maxRow int
driver *sql.DB
ctx context.Context
- tokens *antlr.CommonTokenStream
explainCount int
preExecutions []string
TenantMode 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.Ok
rows := 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.go
index 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.CommonTokenStream
lastCreateTable 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 created
if 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 created
if 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.go
index 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
+ OmniBaseRule
format *regexp.Regexp
maxLength 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 strin
if 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.go
index 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 pg
import (
"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
+ OmniBaseRule
format string
maxLength int
@@ -96,7 +76,6 @@ type namingFKConventionRule struct {
type fkMetaData struct {
indexName string
tableName string
- line int
metaData 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 FkAttrs
var 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.ITableconstra
return &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 PkAttrs
var 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.IColconstrain
return &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.go
index 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 pg
import (
"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 adviso
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 := &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
+ OmniBaseRule
dbMetadata *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 {
- // Tables
for _, tbl := range schema.Tables {
filterMap[tbl.Name] = true
}
- // External Tables
for _, tbl := range schema.ExternalTables {
filterMap[tbl.Name] = true
}
@@ -377,31 +152,10 @@ func (r *fullyQualifiedObjectNameRule) getSchemaNameMapFromPublic() map[string]b
return 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.go
index 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.C
originalMetadata: 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
+ OmniBaseRule
format string
maxLength 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.Idxname
if 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.go
index 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.Cont
maxLength = 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
+ OmniBaseRule
format string
maxLength 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.go
index 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
+ OmniBaseRule
format *regexp.Regexp
maxLength 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.go
index 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 pg
import (
"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.Cont
originalMetadata: 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
+ OmniBaseRule
format string
maxLength 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 key
if 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.go
index 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 pg
import (
"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.go
index 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 pg
import (
"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.go
index 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 adv
return 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
+ OmniBaseRule
maxRow int
driver *sql.DB
ctx context.Context
explainCount int
preExecutions []string
tenantMode 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 count
res, err := advisor.Query(r.ctx, advisor.QueryContext{
TenantMode: r.tenantMode,
PreExecutions: r.preExecutions,
@@ -159,12 +99,12 @@ func (r *statementAffectedRowLimitRule) checkAffectedRows(ctx antlr.ParserRuleCo
if 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.ParserRuleCo
rowCount, 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.ParserRuleCo
if 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.go
index 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 pg
import (
"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 {
+ OmniBaseRule
hasSetRole bool
foundNonSetStmt 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.go
index 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 pg
import (
"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.go
index 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 pg
import (
"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.go
index 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.go
index 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 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 := &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.go
index 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 pg
import (
"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 a
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 := &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.go
index 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 pg
import (
"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.go
index 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.Co
return 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
+ OmniBaseRule
driver *sql.DB
ctx context.Context
explainCount int
preExecutions []string
tenantMode 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 queries
if 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.go
index 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 pg
import (
"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
+ OmniBaseRule
limitMaxValue 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.go
index 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
+ OmniBaseRule
tableMap 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.go
index 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, checkCtx
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 := &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.go
index 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 pg
import (
"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.go
index 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 pg
import (
"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.Contex
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 := &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.go
index 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
+ OmniBaseRule
dbMetadata *model.DatabaseMetadata
currentRole 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.go
index 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 pg
import (
"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 ad
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 := &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.go
index 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, check
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 := &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.go
index 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 string
tableName string
displayName string
- line int
+ line int32
}
type tableCommentInfo struct {
comment string
- line int
+ line int32
}
type tableCommentConventionRule struct {
- BaseRule
+ OmniBaseRule
payload *storepb.SQLReviewRule_CommentConventionRulePayload
createdTables map[string]*tableInfo
tableComments 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" schema
displayName := tableName
if schemaName != "public" {
displayName = fmt.Sprintf("%s.%s", schemaName, tableName)
@@ -172,59 +112,82 @@ func (r *tableCommentConventionRule) handleCreatestmt(ctx antlr.ParserRuleContex
schema: 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.go
index 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.go
index 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
+ OmniBaseRule
format *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.go
index 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.go
index 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 statements
rule.validateFinalState()
- return checker.GetAdviceList(), nil
+ return rule.GetAdviceList(), nil
}
type tableMention struct {
startLine int
- endLine int
text string
}
type tableRequirePKRule struct {
- BaseRule
- tokens *antlr.CommonTokenStream
+ OmniBaseRule
finalMetadata *model.DatabaseMetadata
- // Simple Solution: Track last mention of each table
+ // Track last mention of each table
tableMentions 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 KEY
schema := r.finalMetadata.GetSchemaMetadata(schemaName)
var hasPK bool
if 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 statement
if 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 dot
for 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.go
index 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 string
adviceList []*storepb.Advice
baseLine int
}
diff --git a/backend/plugin/advisor/pg/generic_checker_omni.go b/backend/plugin/advisor/pg/generic_checker_omni.go
new file mode 100644
index 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.yaml
index 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 clauses
startposition:
line: 1
- column: 1
+ column: 0
endposition: null
- statement: |-
CREATE TABLE users (
@@ -39,6 +39,6 @@
title: STATEMENT_DISALLOW_ON_DEL_CASCADE
content: The CASCADE option is not permitted for ON DELETE clauses
startposition:
- line: 2
- column: 1
+ line: 3
+ column: 0
endposition: null
diff --git a/backend/plugin/advisor/pg/test/table_comment.yaml b/backend/plugin/advisor/pg/test/table_comment.yaml
index 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_COMMENT
content: Comment is required for table `d`
startposition:
- line: 3
+ line: 2
column: 0
endposition: null
- statement: |-
@@ -38,7 +38,7 @@
title: TABLE_COMMENT
content: Comment is required for table `t`
startposition:
- line: 2
+ line: 1
column: 0
endposition: null
- statement: |-
@@ -52,7 +52,7 @@
title: TABLE_COMMENT
content: Comment is required for table `t`
startposition:
- line: 2
+ line: 1
column: 0
endposition: null
- statement: |-
diff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.go
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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.go
index 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.ParseError
require.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 - 1
diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.go
index 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.go
index 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),