Skip to content

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

refactor(advisor/pg): convert all 54 advisors to generic checker pattern to reduce binary size (#18038)

h3n4l61999bd0883d
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 57f4a4a265..1be7bc0704 100644
--- a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
+++ b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
@@ -53,14 +53,16 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisor
return nil, err
}
- ddlChecker := &ddlChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: title,
- tokens: tree.Tokens,
+ ddlRule := &ddlRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: title,
+ },
+ tokens: tree.Tokens,
}
- antlr.ParseTreeWalkerDefault.Walk(ddlChecker, tree.Tree)
- adviceList = append(adviceList, ddlChecker.adviceList...)
+ checker := NewGenericChecker([]Rule{ddlRule})
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ adviceList = append(adviceList, checker.GetAdviceList()...)
// Check if backup schema exists
schemaName := common.BackupDatabaseNameOfEngine(storepb.Engine_POSTGRES)
@@ -211,31 +213,40 @@ func isDDLStatement(ctx antlr.Tree) bool {
}
}
-// ddlChecker checks for DDL statements in DML context
-type ddlChecker struct {
- *parser.BasePostgreSQLParserListener
+// 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)
+}
- level storepb.Advice_Status
- title string
- tokens *antlr.CommonTokenStream
- adviceList []*storepb.Advice
+func (*ddlRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-func (c *ddlChecker) getStatementText(ctx antlr.ParserRuleContext) string {
- return c.tokens.GetTextFromRuleContext(ctx)
+func (r *ddlRule) getStatementText(ctx antlr.ParserRuleContext) string {
+ return r.tokens.GetTextFromRuleContext(ctx)
}
-func (c *ddlChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
+func (r *ddlRule) handleEveryRule(ctx antlr.ParserRuleContext) error {
// Check if this is a top-level DDL statement
if !isTopLevel(ctx.GetParent()) {
- return
+ return nil
}
if isDDLStatement(ctx) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
- Title: c.title,
- Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", c.getStatementText(ctx)),
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
+ Title: r.title,
+ Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", r.getStatementText(ctx)),
Code: advisor.BuiltinPriorBackupCheck.Int32(),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -243,6 +254,7 @@ func (c *ddlChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
},
})
}
+ return nil
}
// StatementType represents the type of DML statement
diff --git a/backend/plugin/advisor/pg/advisor_collation_allowlist.go b/backend/plugin/advisor/pg/advisor_collation_allowlist.go
index c3b9c70b55..e309ec3150 100644
--- a/backend/plugin/advisor/pg/advisor_collation_allowlist.go
+++ b/backend/plugin/advisor/pg/advisor_collation_allowlist.go
@@ -40,57 +40,80 @@ func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Cont
return nil, err
}
- checker := &collationAllowlistChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- allowlist: make(map[string]bool),
- tokens: tree.Tokens,
- }
+ allowlist := make(map[string]bool)
for _, collation := range payload.List {
- checker.allowlist[collation] = true
+ allowlist[collation] = true
+ }
+
+ rule := &collationAllowlistRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ allowlist: allowlist,
+ tokens: tree.Tokens,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type collationAllowlistChecker struct {
- *parser.BasePostgreSQLParserListener
+type collationAllowlistRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- allowlist map[string]bool
- tokens *antlr.CommonTokenStream
+ allowlist map[string]bool
+ tokens *antlr.CommonTokenStream
}
-// EnterCreatestmt handles CREATE TABLE statements
-func (c *collationAllowlistChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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))
+ 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
+ return nil
}
// Extract collations from column definitions
if ctx.Opttableelementlist() != nil {
- c.checkTableElementList(ctx.Opttableelementlist(), ctx)
+ r.checkTableElementList(ctx.Opttableelementlist(), ctx)
}
+ return nil
}
-// EnterAltertablestmt handles ALTER TABLE statements
-func (c *collationAllowlistChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+// handleAltertablestmt handles ALTER TABLE statements
+func (r *collationAllowlistRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) error {
if !isTopLevel(ctx.GetParent()) {
- return
+ return nil
}
// Check ALTER TABLE ADD COLUMN
if ctx.Alter_table_cmds() != nil {
- c.checkAlterTableCmds(ctx.Alter_table_cmds(), ctx)
+ r.checkAlterTableCmds(ctx.Alter_table_cmds(), ctx)
}
+ return nil
}
-func (c *collationAllowlistChecker) checkTableElementList(listCtx parser.IOpttableelementlistContext, stmtCtx antlr.ParserRuleContext) {
+func (r *collationAllowlistRule) checkTableElementList(listCtx parser.IOpttableelementlistContext, stmtCtx antlr.ParserRuleContext) {
if listCtx == nil || listCtx.Tableelementlist() == nil {
return
}
@@ -98,12 +121,12 @@ func (c *collationAllowlistChecker) checkTableElementList(listCtx parser.IOpttab
allElements := listCtx.Tableelementlist().AllTableelement()
for _, elem := range allElements {
if elem.ColumnDef() != nil {
- c.checkColumnDef(elem.ColumnDef(), stmtCtx)
+ r.checkColumnDef(elem.ColumnDef(), stmtCtx)
}
}
}
-func (c *collationAllowlistChecker) checkColumnDef(colDef parser.IColumnDefContext, stmtCtx antlr.ParserRuleContext) {
+func (r *collationAllowlistRule) checkColumnDef(colDef parser.IColumnDefContext, stmtCtx antlr.ParserRuleContext) {
if colDef == nil || colDef.Colquallist() == nil {
return
}
@@ -114,15 +137,15 @@ func (c *collationAllowlistChecker) checkColumnDef(colDef parser.IColumnDefConte
for _, constraint := range allConstraints {
// Check if this constraint is a COLLATE constraint
if constraint.COLLATE() != nil && constraint.Any_name() != nil {
- collName := c.extractCollationNameFromAnyName(constraint.Any_name())
- if collName != "" && !c.allowlist[collName] {
- c.addAdvice(collName, stmtCtx)
+ collName := r.extractCollationNameFromAnyName(constraint.Any_name())
+ if collName != "" && !r.allowlist[collName] {
+ r.addAdvice(collName, stmtCtx)
}
}
}
}
-func (c *collationAllowlistChecker) checkAlterTableCmds(cmds parser.IAlter_table_cmdsContext, stmtCtx antlr.ParserRuleContext) {
+func (r *collationAllowlistRule) checkAlterTableCmds(cmds parser.IAlter_table_cmdsContext, stmtCtx antlr.ParserRuleContext) {
if cmds == nil {
return
}
@@ -131,22 +154,22 @@ func (c *collationAllowlistChecker) checkAlterTableCmds(cmds parser.IAlter_table
for _, cmd := range allCmds {
// ADD COLUMN
if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
- c.checkColumnDef(cmd.ColumnDef(), stmtCtx)
+ 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 := c.extractCollationNameFromAnyName(cmd.Opt_collate_clause().Any_name())
- if collName != "" && !c.allowlist[collName] {
- c.addAdvice(collName, stmtCtx)
+ collName := r.extractCollationNameFromAnyName(cmd.Opt_collate_clause().Any_name())
+ if collName != "" && !r.allowlist[collName] {
+ r.addAdvice(collName, stmtCtx)
}
}
}
}
-func (*collationAllowlistChecker) extractCollationNameFromAnyName(anyName parser.IAny_nameContext) string {
+func (*collationAllowlistRule) extractCollationNameFromAnyName(anyName parser.IAny_nameContext) string {
if anyName == nil {
return ""
}
@@ -164,13 +187,13 @@ func (*collationAllowlistChecker) extractCollationNameFromAnyName(anyName parser
return text
}
-func (c *collationAllowlistChecker) addAdvice(collation string, ctx antlr.ParserRuleContext) {
- text := c.tokens.GetTextFromRuleContext(ctx)
+func (r *collationAllowlistRule) addAdvice(collation string, ctx antlr.ParserRuleContext) {
+ text := r.tokens.GetTextFromRuleContext(ctx)
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.DisabledCollation.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Use disabled collation \"%s\", related statement \"%s\"", collation, text),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
diff --git a/backend/plugin/advisor/pg/advisor_column_comment_convention.go b/backend/plugin/advisor/pg/advisor_column_comment_convention.go
index 8a4bd534c8..108bb52198 100644
--- a/backend/plugin/advisor/pg/advisor_column_comment_convention.go
+++ b/backend/plugin/advisor/pg/advisor_column_comment_convention.go
@@ -41,18 +41,19 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor
return nil, err
}
- checker := &columnCommentConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- payload: payload,
- classificationConfig: checkCtx.ClassificationConfig,
+ rule := &columnCommentConventionRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ payload: payload,
+ classificationConfig: checkCtx.ClassificationConfig,
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
// Now validate all collected columns against comments
- return checker.generateAdvice(), nil
+ return rule.generateAdvice(), nil
}
type columnInfo struct {
@@ -70,8 +71,8 @@ type commentInfo struct {
line int
}
-type columnCommentConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type columnCommentConventionRule struct {
+ BaseRule
level storepb.Advice_Status
title string
@@ -82,12 +83,34 @@ type columnCommentConventionChecker struct {
comments []commentInfo
}
-func (c *columnCommentConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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))
+ 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()) {
return
}
- tableName := c.extractTableName(ctx.AllQualified_name())
+ tableName := r.extractTableName(ctx.AllQualified_name())
if tableName == "" {
return
}
@@ -98,7 +121,7 @@ func (c *columnCommentConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtC
for _, elem := range allElements {
if elem.ColumnDef() != nil && elem.ColumnDef().Colid() != nil {
columnName := pg.NormalizePostgreSQLColid(elem.ColumnDef().Colid())
- c.columns = append(c.columns, columnInfo{
+ r.columns = append(r.columns, columnInfo{
schema: "public", // Default schema
table: tableName,
column: columnName,
@@ -109,7 +132,7 @@ func (c *columnCommentConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtC
}
}
-func (c *columnCommentConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *columnCommentConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -130,7 +153,7 @@ func (c *columnCommentConventionChecker) EnterAltertablestmt(ctx *parser.Alterta
// ADD COLUMN
if cmd.ADD_P() != nil && cmd.ColumnDef() != nil && cmd.ColumnDef().Colid() != nil {
columnName := pg.NormalizePostgreSQLColid(cmd.ColumnDef().Colid())
- c.columns = append(c.columns, columnInfo{
+ r.columns = append(r.columns, columnInfo{
schema: "public", // Default schema
table: tableName,
column: columnName,
@@ -141,7 +164,7 @@ func (c *columnCommentConventionChecker) EnterAltertablestmt(ctx *parser.Alterta
}
}
-func (c *columnCommentConventionChecker) EnterCommentstmt(ctx *parser.CommentstmtContext) {
+func (r *columnCommentConventionRule) handleCommentstmt(ctx *parser.CommentstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -168,7 +191,7 @@ func (c *columnCommentConventionChecker) EnterCommentstmt(ctx *parser.Commentstm
comment = extractStringConstant(ctx.Comment_text().Sconst())
}
- c.comments = append(c.comments, commentInfo{
+ r.comments = append(r.comments, commentInfo{
schema: "public",
table: tableName,
column: columnName,
@@ -177,7 +200,7 @@ func (c *columnCommentConventionChecker) EnterCommentstmt(ctx *parser.Commentstm
})
}
-func (*columnCommentConventionChecker) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
+func (*columnCommentConventionRule) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
if len(qualifiedNames) == 0 {
return ""
}
@@ -186,15 +209,15 @@ func (*columnCommentConventionChecker) extractTableName(qualifiedNames []parser.
return extractTableName(qualifiedNames[0])
}
-func (c *columnCommentConventionChecker) generateAdvice() []*storepb.Advice {
+func (r *columnCommentConventionRule) generateAdvice() []*storepb.Advice {
var adviceList []*storepb.Advice
// For each column, find its comment and validate
- for _, col := range c.columns {
+ for _, col := range r.columns {
// Find the last matching comment for this column
var matchedComment *commentInfo
- for i := range c.comments {
- comment := &c.comments[i]
+ 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
@@ -202,11 +225,11 @@ func (c *columnCommentConventionChecker) generateAdvice() []*storepb.Advice {
}
if matchedComment == nil || matchedComment.comment == "" {
- if c.payload.Required {
+ if r.payload.Required {
adviceList = append(adviceList, &storepb.Advice{
- Status: c.level,
+ Status: r.level,
Code: advisor.CommentEmpty.Int32(),
- Title: c.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),
@@ -218,12 +241,12 @@ func (c *columnCommentConventionChecker) generateAdvice() []*storepb.Advice {
comment := matchedComment.comment
// Check max length
- if c.payload.MaxLength > 0 && len(comment) > c.payload.MaxLength {
+ if r.payload.MaxLength > 0 && len(comment) > r.payload.MaxLength {
adviceList = append(adviceList, &storepb.Advice{
- Status: c.level,
+ Status: r.level,
Code: advisor.CommentTooLong.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("Column `%s.%s` comment is too long. The length of comment should be within %d characters", col.table, col.column, c.payload.MaxLength),
+ 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),
Column: 0,
@@ -232,12 +255,12 @@ func (c *columnCommentConventionChecker) generateAdvice() []*storepb.Advice {
}
// Check classification
- if c.payload.RequiredClassification {
- if classification, _ := common.GetClassificationAndUserComment(comment, c.classificationConfig); classification == "" {
+ if r.payload.RequiredClassification {
+ if classification, _ := common.GetClassificationAndUserComment(comment, r.classificationConfig); classification == "" {
adviceList = append(adviceList, &storepb.Advice{
- Status: c.level,
+ Status: r.level,
Code: advisor.CommentMissingClassification.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Column `%s.%s` comment requires classification", col.table, col.column),
StartPosition: &storepb.Position{
Line: int32(matchedComment.line),
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 3b0ef02d34..2869f892d7 100644
--- a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go
+++ b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go
@@ -38,16 +38,19 @@ func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx a
return nil, err
}
- checker := &columnDefaultDisallowVolatileChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- columnSet: make(map[string]columnData),
+ rule := &columnDefaultDisallowVolatileRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ columnSet: make(map[string]columnData),
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.generateAdvice(), nil
+ return checker.GetAdviceList(), nil
}
type columnData struct {
@@ -57,16 +60,35 @@ type columnData struct {
line int
}
-type columnDefaultDisallowVolatileChecker struct {
- *parser.BasePostgreSQLParserListener
+type columnDefaultDisallowVolatileRule struct {
+ BaseRule
+
+ columnSet map[string]columnData
+}
+
+func (*columnDefaultDisallowVolatileRule) Name() string {
+ return string(advisor.SchemaRuleColumnDefaultDisallowVolatile)
+}
+
+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
+ default:
+ }
+ return nil
+}
- level storepb.Advice_Status
- title string
- columnSet map[string]columnData
- adviceList []*storepb.Advice
+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 (c *columnDefaultDisallowVolatileChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *columnDefaultDisallowVolatileRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -91,8 +113,8 @@ func (c *columnDefaultDisallowVolatileChecker) EnterAltertablestmt(ctx *parser.A
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
// Check if this column has a volatile DEFAULT
- if c.hasVolatileDefault(colDef) {
- c.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())
+ if r.hasVolatileDefault(colDef) {
+ r.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())
}
}
}
@@ -100,7 +122,7 @@ func (c *columnDefaultDisallowVolatileChecker) EnterAltertablestmt(ctx *parser.A
}
}
-func (c *columnDefaultDisallowVolatileChecker) hasVolatileDefault(colDef parser.IColumnDefContext) bool {
+func (r *columnDefaultDisallowVolatileRule) hasVolatileDefault(colDef parser.IColumnDefContext) bool {
if colDef == nil || colDef.Colquallist() == nil {
return false
}
@@ -114,7 +136,7 @@ func (c *columnDefaultDisallowVolatileChecker) hasVolatileDefault(colDef parser.
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 c.containsFunctionCall(elem.B_expr()) {
+ if r.containsFunctionCall(elem.B_expr()) {
return true
}
}
@@ -124,17 +146,17 @@ func (c *columnDefaultDisallowVolatileChecker) hasVolatileDefault(colDef parser.
return false
}
-func (c *columnDefaultDisallowVolatileChecker) containsFunctionCall(expr antlr.Tree) bool {
+func (r *columnDefaultDisallowVolatileRule) containsFunctionCall(expr antlr.Tree) bool {
if expr == nil {
return false
}
// Check if this expression is or contains a function call
// In PostgreSQL, function calls are represented as func_expr
- return c.hasFuncExpr(expr)
+ return r.hasFuncExpr(expr)
}
-func (c *columnDefaultDisallowVolatileChecker) hasFuncExpr(node antlr.Tree) bool {
+func (r *columnDefaultDisallowVolatileRule) hasFuncExpr(node antlr.Tree) bool {
if node == nil {
return false
}
@@ -151,7 +173,7 @@ func (c *columnDefaultDisallowVolatileChecker) hasFuncExpr(node antlr.Tree) bool
if parserRule, ok := node.(antlr.ParserRuleContext); ok {
for i := 0; i < parserRule.GetChildCount(); i++ {
child := parserRule.GetChild(i)
- if c.hasFuncExpr(child) {
+ if r.hasFuncExpr(child) {
return true
}
}
@@ -160,12 +182,12 @@ func (c *columnDefaultDisallowVolatileChecker) hasFuncExpr(node antlr.Tree) bool
return false
}
-func (c *columnDefaultDisallowVolatileChecker) addColumn(schema string, table string, column string, line int) {
+func (r *columnDefaultDisallowVolatileRule) addColumn(schema string, table string, column string, line int) {
if schema == "" {
schema = "public"
}
- c.columnSet[fmt.Sprintf("%s.%s.%s", schema, table, column)] = columnData{
+ r.columnSet[fmt.Sprintf("%s.%s.%s", schema, table, column)] = columnData{
schema: schema,
table: table,
name: column,
@@ -173,9 +195,9 @@ func (c *columnDefaultDisallowVolatileChecker) addColumn(schema string, table st
}
}
-func (c *columnDefaultDisallowVolatileChecker) generateAdvice() []*storepb.Advice {
+func (r *columnDefaultDisallowVolatileRule) generateAdvice() {
var columnList []columnData
- for _, column := range c.columnSet {
+ for _, column := range r.columnSet {
columnList = append(columnList, column)
}
slices.SortFunc(columnList, func(i, j columnData) int {
@@ -189,10 +211,10 @@ func (c *columnDefaultDisallowVolatileChecker) generateAdvice() []*storepb.Advic
})
for _, column := range columnList {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NoDefault.Int32(),
- Title: c.title,
+ 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),
@@ -200,6 +222,4 @@ func (c *columnDefaultDisallowVolatileChecker) generateAdvice() []*storepb.Advic
},
})
}
-
- return c.adviceList
}
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 13cd3e300c..51095db0e9 100644
--- a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go
+++ b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go
@@ -36,28 +36,45 @@ func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advi
return nil, err
}
- checker := &columnDisallowChangingTypeChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- tokens: tree.Tokens,
+ rule := &columnDisallowChangingTypeRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ tokens: tree.Tokens,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type columnDisallowChangingTypeChecker struct {
- *parser.BasePostgreSQLParserListener
+type columnDisallowChangingTypeRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- tokens *antlr.CommonTokenStream
+ tokens *antlr.CommonTokenStream
}
-func (c *columnDisallowChangingTypeChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+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
}
@@ -72,12 +89,12 @@ func (c *columnDisallowChangingTypeChecker) EnterAltertablestmt(ctx *parser.Alte
// 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 := c.tokens.GetTextFromRuleContext(ctx)
+ text := r.tokens.GetTextFromRuleContext(ctx)
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.ChangeColumnType.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("The statement \"%s\" changes column type", text),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
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 d48ee0802c..d4b260e84f 100644
--- a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go
+++ b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go
@@ -45,33 +45,52 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx ad
return nil, nil
}
- checker := &columnMaximumCharacterLengthChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- maximum: payload.Number,
+ rule := &columnMaximumCharacterLengthRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ maximum: payload.Number,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
+}
+
+type columnMaximumCharacterLengthRule struct {
+ BaseRule
+
+ maximum int
}
-type columnMaximumCharacterLengthChecker struct {
- *parser.BasePostgreSQLParserListener
+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))
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- maximum int
+func (*columnMaximumCharacterLengthRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-func (c *columnMaximumCharacterLengthChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (r *columnMaximumCharacterLengthRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- tableName := c.extractTableName(ctx.AllQualified_name())
+ tableName := r.extractTableName(ctx.AllQualified_name())
// Check all columns
if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
@@ -81,9 +100,9 @@ func (c *columnMaximumCharacterLengthChecker) EnterCreatestmt(ctx *parser.Create
colDef := elem.ColumnDef()
if colDef.Colid() != nil && colDef.Typename() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
- charLength := c.getCharLength(colDef.Typename())
- if charLength > c.maximum {
- c.addAdvice(tableName, columnName, colDef.GetStart().GetLine())
+ charLength := r.getCharLength(colDef.Typename())
+ if charLength > r.maximum {
+ r.addAdvice(tableName, columnName, colDef.GetStart().GetLine())
return // Only report first violation
}
}
@@ -92,7 +111,7 @@ func (c *columnMaximumCharacterLengthChecker) EnterCreatestmt(ctx *parser.Create
}
}
-func (c *columnMaximumCharacterLengthChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *columnMaximumCharacterLengthRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -123,9 +142,9 @@ func (c *columnMaximumCharacterLengthChecker) EnterAltertablestmt(ctx *parser.Al
colDef := cmd.ColumnDef()
if colDef.Colid() != nil && colDef.Typename() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
- charLength := c.getCharLength(colDef.Typename())
- if charLength > c.maximum {
- c.addAdvice(tableName, columnName, colDef.GetStart().GetLine())
+ charLength := r.getCharLength(colDef.Typename())
+ if charLength > r.maximum {
+ r.addAdvice(tableName, columnName, colDef.GetStart().GetLine())
return
}
}
@@ -137,9 +156,9 @@ func (c *columnMaximumCharacterLengthChecker) EnterAltertablestmt(ctx *parser.Al
allColids := cmd.AllColid()
if len(allColids) > 0 {
columnName := pg.NormalizePostgreSQLColid(allColids[0])
- charLength := c.getCharLength(cmd.Typename())
- if charLength > c.maximum {
- c.addAdvice(tableName, columnName, cmd.GetStart().GetLine())
+ charLength := r.getCharLength(cmd.Typename())
+ if charLength > r.maximum {
+ r.addAdvice(tableName, columnName, cmd.GetStart().GetLine())
return
}
}
@@ -148,7 +167,7 @@ func (c *columnMaximumCharacterLengthChecker) EnterAltertablestmt(ctx *parser.Al
}
}
-func (*columnMaximumCharacterLengthChecker) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
+func (*columnMaximumCharacterLengthRule) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
if len(qualifiedNames) == 0 {
return ""
}
@@ -165,7 +184,7 @@ func (*columnMaximumCharacterLengthChecker) extractTableName(qualifiedNames []pa
return fmt.Sprintf("%q.%q", parts[0], parts[1])
}
-func (*columnMaximumCharacterLengthChecker) getCharLength(typename parser.ITypenameContext) int {
+func (*columnMaximumCharacterLengthRule) getCharLength(typename parser.ITypenameContext) int {
if typename == nil {
return 0
}
@@ -213,12 +232,12 @@ func (*columnMaximumCharacterLengthChecker) getCharLength(typename parser.ITypen
return 0
}
-func (c *columnMaximumCharacterLengthChecker) addAdvice(tableName, columnName string, line int) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+func (r *columnMaximumCharacterLengthRule) addAdvice(tableName, columnName string, line int) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CharLengthExceedsLimit.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("The length of the CHAR column %q in table %s is bigger than %d, please use VARCHAR instead", columnName, tableName, c.maximum),
+ 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),
Column: 0,
diff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.go
index 9352376918..fd02f60a9f 100644
--- a/backend/plugin/advisor/pg/advisor_column_no_null.go
+++ b/backend/plugin/advisor/pg/advisor_column_no_null.go
@@ -39,17 +39,20 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (
return nil, err
}
- checker := &columnNoNullChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- catalog: checkCtx.Catalog,
- nullableColumns: make(columnMap),
+ rule := &columnNoNullRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ catalog: checkCtx.Catalog,
+ nullableColumns: make(columnMap),
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.generateAdviceList(), nil
+ return checker.GetAdviceList(), nil
}
type columnName struct {
@@ -67,21 +70,88 @@ func (c columnName) normalizeTableName() string {
type columnMap map[columnName]int
-type columnNoNullChecker struct {
- *parser.BasePostgreSQLParserListener
+type columnNoNullRule struct {
+ BaseRule
- level storepb.Advice_Status
- title string
catalog *catalog.Finder
nullableColumns columnMap
}
-func (c *columnNoNullChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (*columnNoNullRule) Name() string {
+ return "CreatestmtAltertablestmt"
+}
+
+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)
+ }
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
+
+func (r *columnNoNullRule) OnExit(ctx antlr.ParserRuleContext, _ string) error {
+ // Generate advice when we exit the root node
+ if _, ok := ctx.(*parser.RootContext); ok {
+ var columnList []columnName
+ for column := range r.nullableColumns {
+ columnList = append(columnList, column)
+ }
+
+ 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 {
+ return -1
+ }
+ return 1
+ }
+ if i.table != j.table {
+ if i.table < j.table {
+ return -1
+ }
+ return 1
+ }
+ if i.column < j.column {
+ return -1
+ }
+ if i.column > j.column {
+ return 1
+ }
+ return 0
+ })
+ }
+
+ for _, column := range columnList {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
+ Code: advisor.ColumnCannotNull.Int32(),
+ Title: r.title,
+ Content: fmt.Sprintf("Column %q in %s cannot have NULL value", column.column, column.normalizeTableName()),
+ StartPosition: &storepb.Position{
+ Line: int32(r.nullableColumns[column]),
+ Column: 0,
+ },
+ })
+ }
+ }
+ return nil
+}
+
+func (r *columnNoNullRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- tableName := c.extractTableName(ctx.AllQualified_name())
+ tableName := r.extractTableName(ctx.AllQualified_name())
if tableName == "" {
return
}
@@ -96,22 +166,22 @@ func (c *columnNoNullChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
if colDef.Colid() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
// Add column as nullable by default
- c.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())
+ r.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())
// Check column constraints for NOT NULL or PRIMARY KEY
- c.removeColumnByColConstraints("public", tableName, colDef)
+ r.removeColumnByColConstraints("public", tableName, colDef)
}
}
// Table constraint (like PRIMARY KEY (id))
if elem.Tableconstraint() != nil {
- c.removeColumnByTableConstraint("public", tableName, elem.Tableconstraint())
+ r.removeColumnByTableConstraint("public", tableName, elem.Tableconstraint())
}
}
}
}
-func (c *columnNoNullChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *columnNoNullRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -131,8 +201,8 @@ func (c *columnNoNullChecker) EnterAltertablestmt(ctx *parser.AltertablestmtCont
colDef := cmd.ColumnDef()
if colDef.Colid() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
- c.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())
- c.removeColumnByColConstraints("public", tableName, colDef)
+ r.addColumn("public", tableName, columnName, colDef.GetStart().GetLine())
+ r.removeColumnByColConstraints("public", tableName, colDef)
}
}
@@ -141,7 +211,7 @@ func (c *columnNoNullChecker) EnterAltertablestmt(ctx *parser.AltertablestmtCont
allColids := cmd.AllColid()
if len(allColids) > 0 {
columnName := pg.NormalizePostgreSQLColid(allColids[0])
- c.removeColumn("public", tableName, columnName)
+ r.removeColumn("public", tableName, columnName)
}
}
@@ -150,19 +220,19 @@ func (c *columnNoNullChecker) EnterAltertablestmt(ctx *parser.AltertablestmtCont
allColids := cmd.AllColid()
if len(allColids) > 0 {
columnName := pg.NormalizePostgreSQLColid(allColids[0])
- c.addColumn("public", tableName, columnName, cmd.GetStart().GetLine())
+ r.addColumn("public", tableName, columnName, cmd.GetStart().GetLine())
}
}
// ADD table constraint
if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
- c.removeColumnByTableConstraint("public", tableName, cmd.Tableconstraint())
+ r.removeColumnByTableConstraint("public", tableName, cmd.Tableconstraint())
}
}
}
}
-func (*columnNoNullChecker) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
+func (*columnNoNullRule) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
if len(qualifiedNames) == 0 {
return ""
}
@@ -170,21 +240,21 @@ func (*columnNoNullChecker) extractTableName(qualifiedNames []parser.IQualified_
return extractTableName(qualifiedNames[0])
}
-func (c *columnNoNullChecker) addColumn(schema, table, column string, line int) {
+func (r *columnNoNullRule) addColumn(schema, table, column string, line int) {
if schema == "" {
schema = "public"
}
- c.nullableColumns[columnName{schema: schema, table: table, column: column}] = line
+ r.nullableColumns[columnName{schema: schema, table: table, column: column}] = line
}
-func (c *columnNoNullChecker) removeColumn(schema, table, column string) {
+func (r *columnNoNullRule) removeColumn(schema, table, column string) {
if schema == "" {
schema = "public"
}
- delete(c.nullableColumns, columnName{schema: schema, table: table, column: column})
+ delete(r.nullableColumns, columnName{schema: schema, table: table, column: column})
}
-func (c *columnNoNullChecker) removeColumnByColConstraints(schema, table string, colDef parser.IColumnDefContext) {
+func (r *columnNoNullRule) removeColumnByColConstraints(schema, table string, colDef parser.IColumnDefContext) {
if colDef.Colquallist() == nil {
return
}
@@ -200,19 +270,19 @@ func (c *columnNoNullChecker) removeColumnByColConstraints(schema, table string,
// NOT NULL constraint
if elem.NOT() != nil && elem.NULL_P() != nil {
- c.removeColumn(schema, table, columnName)
+ r.removeColumn(schema, table, columnName)
return
}
// PRIMARY KEY constraint
if elem.PRIMARY() != nil && elem.KEY() != nil {
- c.removeColumn(schema, table, columnName)
+ r.removeColumn(schema, table, columnName)
return
}
}
}
-func (c *columnNoNullChecker) removeColumnByTableConstraint(schema, table string, constraint parser.ITableconstraintContext) {
+func (r *columnNoNullRule) removeColumnByTableConstraint(schema, table string, constraint parser.ITableconstraintContext) {
if constraint.Constraintelem() == nil {
return
}
@@ -224,7 +294,7 @@ func (c *columnNoNullChecker) removeColumnByTableConstraint(schema, table string
allColumnElems := elem.Columnlist().AllColumnElem()
for _, columnElem := range allColumnElems {
if columnElem.Colid() != nil {
- c.removeColumn(schema, table, pg.NormalizePostgreSQLColid(columnElem.Colid()))
+ r.removeColumn(schema, table, pg.NormalizePostgreSQLColid(columnElem.Colid()))
}
}
return
@@ -236,67 +306,18 @@ func (c *columnNoNullChecker) removeColumnByTableConstraint(schema, table string
if existingIndex.Name() != nil {
indexName := pg.NormalizePostgreSQLName(existingIndex.Name())
// Try to find index in catalog
- if c.catalog != nil {
- _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ if r.catalog != nil {
+ _, index := r.catalog.Origin.FindIndex(&catalog.IndexFind{
SchemaName: schema,
TableName: table,
IndexName: indexName,
})
if index != nil {
for _, expression := range index.ExpressionList() {
- c.removeColumn(schema, table, expression)
+ r.removeColumn(schema, table, expression)
}
}
}
}
}
}
-
-func (c *columnNoNullChecker) generateAdviceList() []*storepb.Advice {
- var adviceList []*storepb.Advice
- var columnList []columnName
-
- for column := range c.nullableColumns {
- columnList = append(columnList, column)
- }
-
- 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 {
- return -1
- }
- return 1
- }
- if i.table != j.table {
- if i.table < j.table {
- return -1
- }
- return 1
- }
- if i.column < j.column {
- return -1
- }
- if i.column > j.column {
- return 1
- }
- return 0
- })
- }
-
- for _, column := range columnList {
- adviceList = append(adviceList, &storepb.Advice{
- Status: c.level,
- Code: advisor.ColumnCannotNull.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("Column %q in %s cannot have NULL value", column.column, column.normalizeTableName()),
- StartPosition: &storepb.Position{
- Line: int32(c.nullableColumns[column]),
- Column: 0,
- },
- })
- }
-
- return adviceList
-}
diff --git a/backend/plugin/advisor/pg/advisor_column_require_default.go b/backend/plugin/advisor/pg/advisor_column_require_default.go
index 7dc6d5f045..a7e81c48b0 100644
--- a/backend/plugin/advisor/pg/advisor_column_require_default.go
+++ b/backend/plugin/advisor/pg/advisor_column_require_default.go
@@ -38,26 +38,48 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Co
return nil, err
}
- checker := &columnRequireDefaultChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &columnRequireDefaultRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type columnRequireDefaultChecker struct {
- *parser.BasePostgreSQLParserListener
+type columnRequireDefaultRule struct {
+ BaseRule
+}
+
+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)
+ }
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+func (*columnRequireDefaultRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-func (c *columnRequireDefaultChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (r *columnRequireDefaultRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -81,11 +103,11 @@ func (c *columnRequireDefaultChecker) EnterCreatestmt(ctx *parser.CreatestmtCont
if colDef.Colid() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
// Check if column has DEFAULT
- if !c.hasDefault(colDef) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if !r.hasDefault(colDef) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NoDefault.Int32(),
- Title: c.title,
+ 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()),
@@ -99,7 +121,7 @@ func (c *columnRequireDefaultChecker) EnterCreatestmt(ctx *parser.CreatestmtCont
}
}
-func (c *columnRequireDefaultChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *columnRequireDefaultRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -123,11 +145,11 @@ func (c *columnRequireDefaultChecker) EnterAltertablestmt(ctx *parser.Altertable
if colDef.Colid() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
// Check if column has DEFAULT
- if !c.hasDefault(colDef) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if !r.hasDefault(colDef) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NoDefault.Int32(),
- Title: c.title,
+ 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()),
@@ -143,7 +165,7 @@ func (c *columnRequireDefaultChecker) EnterAltertablestmt(ctx *parser.Altertable
// hasDefault checks if a column definition has a DEFAULT clause
// or uses a type that implicitly includes a default (like serial, bigserial, smallserial)
-func (*columnRequireDefaultChecker) hasDefault(colDef parser.IColumnDefContext) bool {
+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()
diff --git a/backend/plugin/advisor/pg/advisor_column_required.go b/backend/plugin/advisor/pg/advisor_column_required.go
index 366b07b0bd..245ec14dd9 100644
--- a/backend/plugin/advisor/pg/advisor_column_required.go
+++ b/backend/plugin/advisor/pg/advisor_column_required.go
@@ -52,40 +52,66 @@ func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Conte
requiredColumnsMap[col] = true
}
- checker := &columnRequirementChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- requiredColumnsMap: requiredColumnsMap,
+ rule := &columnRequirementRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ requiredColumnsMap: requiredColumnsMap,
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type columnRequirementChecker struct {
- *parser.BasePostgreSQLParserListener
+type columnRequirementRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
requiredColumnsMap columnSet // Map of all required columns (from config)
requiredColumns columnSet // Temp map for checking CREATE TABLE
}
-func (c *columnRequirementChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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)
+ 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)
- c.requiredColumns = make(columnSet)
- for column := range c.requiredColumnsMap {
- c.requiredColumns[column] = true
+ r.requiredColumns = make(columnSet)
+ for column := range r.requiredColumnsMap {
+ r.requiredColumns[column] = true
}
- qualifiedNames := ctx.AllQualified_name()
+ qualifiedNames := createCtx.AllQualified_name()
if len(qualifiedNames) == 0 {
return
}
@@ -96,54 +122,58 @@ func (c *columnRequirementChecker) EnterCreatestmt(ctx *parser.CreatestmtContext
}
// Mark columns as present
- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ 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(c.requiredColumns, columnName)
+ delete(r.requiredColumns, columnName)
}
}
}
// Check if any required columns are missing
- if len(c.requiredColumns) > 0 {
+ if len(r.requiredColumns) > 0 {
var missingColumns []string
- for column := range c.requiredColumns {
+ for column := range r.requiredColumns {
missingColumns = append(missingColumns, column)
}
slices.Sort(missingColumns)
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NoRequiredColumn.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Table %q requires columns: %s", tableName, strings.Join(missingColumns, ", ")),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(createCtx.GetStart().GetLine()),
Column: 0,
},
})
}
}
-func (c *columnRequirementChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *columnRequirementRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AltertablestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ if alterCtx.Relation_expr() == nil || alterCtx.Relation_expr().Qualified_name() == nil {
return
}
- tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+ tableName := extractTableName(alterCtx.Relation_expr().Qualified_name())
if tableName == "" {
return
}
// Check ALTER TABLE commands
- if ctx.Alter_table_cmds() != nil {
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ 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 {
@@ -151,14 +181,14 @@ func (c *columnRequirementChecker) EnterAltertablestmt(ctx *parser.Altertablestm
if len(allColids) > 0 {
columnName := pg.NormalizePostgreSQLColid(allColids[0])
// Check if this is a required column (O(1) lookup)
- if c.requiredColumnsMap[columnName] {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.requiredColumnsMap[columnName] {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NoRequiredColumn.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Table %q requires columns: %s", tableName, columnName),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(alterCtx.GetStart().GetLine()),
Column: 0,
},
})
@@ -169,27 +199,31 @@ func (c *columnRequirementChecker) EnterAltertablestmt(ctx *parser.Altertablestm
}
}
-func (c *columnRequirementChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+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 ctx.Opt_column() == nil || ctx.Opt_column().COLUMN() == nil {
+ if renameCtx.Opt_column() == nil || renameCtx.Opt_column().COLUMN() == nil {
return
}
// Get table name
var tableName string
- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
- tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ if renameCtx.Relation_expr() != nil && renameCtx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(renameCtx.Relation_expr().Qualified_name())
}
if tableName == "" {
return
}
// Get old and new column names
- allNames := ctx.AllName()
+ allNames := renameCtx.AllName()
if len(allNames) < 2 {
return
}
@@ -198,14 +232,14 @@ func (c *columnRequirementChecker) EnterRenamestmt(ctx *parser.RenamestmtContext
newName := pg.NormalizePostgreSQLName(allNames[1])
// Check if renaming away from a required column name (O(1) lookup)
- if c.requiredColumnsMap[oldName] && oldName != newName {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.requiredColumnsMap[oldName] && oldName != newName {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NoRequiredColumn.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Table %q requires columns: %s", tableName, oldName),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(renameCtx.GetStart().GetLine()),
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 d3150987a4..e6117c095b 100644
--- a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go
+++ b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go
@@ -49,28 +49,51 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.
typeRestriction[strings.ToLower(tp)] = true
}
- checker := &columnTypeDisallowListChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- typeRestriction: typeRestriction,
+ rule := &columnTypeDisallowListRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ typeRestriction: typeRestriction,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type columnTypeDisallowListChecker struct {
- *parser.BasePostgreSQLParserListener
+type columnTypeDisallowListRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
typeRestriction map[string]bool
}
-func (c *columnTypeDisallowListChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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)
+ }
+ 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
}
@@ -93,14 +116,14 @@ func (c *columnTypeDisallowListChecker) EnterCreatestmt(ctx *parser.CreatestmtCo
colDef := elem.ColumnDef()
if colDef.Colid() != nil && colDef.Typename() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
- c.checkType(tableName, columnName, colDef.Typename(), colDef.GetStart().GetLine())
+ r.checkType(tableName, columnName, colDef.Typename(), colDef.GetStart().GetLine())
}
}
}
}
}
-func (c *columnTypeDisallowListChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *columnTypeDisallowListRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -123,7 +146,7 @@ func (c *columnTypeDisallowListChecker) EnterAltertablestmt(ctx *parser.Altertab
colDef := cmd.ColumnDef()
if colDef.Colid() != nil && colDef.Typename() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
- c.checkType(tableName, columnName, colDef.Typename(), colDef.GetStart().GetLine())
+ r.checkType(tableName, columnName, colDef.Typename(), colDef.GetStart().GetLine())
}
}
@@ -132,14 +155,14 @@ func (c *columnTypeDisallowListChecker) EnterAltertablestmt(ctx *parser.Altertab
allColids := cmd.AllColid()
if len(allColids) > 0 {
columnName := pg.NormalizePostgreSQLColid(allColids[0])
- c.checkType(tableName, columnName, cmd.Typename(), cmd.GetStart().GetLine())
+ r.checkType(tableName, columnName, cmd.Typename(), cmd.GetStart().GetLine())
}
}
}
}
}
-func (c *columnTypeDisallowListChecker) checkType(tableName, columnName string, typename parser.ITypenameContext, line int) {
+func (r *columnTypeDisallowListRule) checkType(tableName, columnName string, typename parser.ITypenameContext, line int) {
if typename == nil {
return
}
@@ -149,7 +172,7 @@ func (c *columnTypeDisallowListChecker) checkType(tableName, columnName string,
// Check if this type is equivalent to any type in the disallow list
var matchedDisallowedType string
- for disallowedType := range c.typeRestriction {
+ for disallowedType := range r.typeRestriction {
if areTypesEquivalent(typeText, disallowedType) {
matchedDisallowedType = disallowedType
break
@@ -157,10 +180,10 @@ func (c *columnTypeDisallowListChecker) checkType(tableName, columnName string,
}
if matchedDisallowedType != "" {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.DisabledColumnType.Int32(),
- Title: c.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),
diff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.go
index 083e09d7f2..75a0982830 100644
--- a/backend/plugin/advisor/pg/advisor_comment_convention.go
+++ b/backend/plugin/advisor/pg/advisor_comment_convention.go
@@ -41,45 +41,67 @@ func (*CommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Conte
return nil, err
}
- checker := &commentConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- maxLength: payload.Number,
+ rule := &commentConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ maxLength: payload.Number,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type commentConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type commentConventionRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- maxLength int
+ maxLength int
}
-func (c *commentConventionChecker) EnterCommentstmt(ctx *parser.CommentstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+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)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(commentstmtCtx.GetParent()) {
return
}
// Extract comment text
- if ctx.Comment_text() != nil && ctx.Comment_text().Sconst() != nil {
- comment := extractStringConstant(ctx.Comment_text().Sconst())
+ if commentstmtCtx.Comment_text() != nil && commentstmtCtx.Comment_text().Sconst() != nil {
+ comment := extractStringConstant(commentstmtCtx.Comment_text().Sconst())
// Check length
- if c.maxLength > 0 && len(comment) > c.maxLength {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.maxLength > 0 && len(comment) > r.maxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CommentTooLong.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("The length of comment should be within %d characters", c.maxLength),
+ Title: r.title,
+ Content: fmt.Sprintf("The length of comment should be within %d characters", r.maxLength),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(commentstmtCtx.GetStart().GetLine()),
Column: 0,
},
})
diff --git a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go
index f4d9ada24a..d7f28ed496 100644
--- a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go
+++ b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go
@@ -48,28 +48,45 @@ func (*EncodingAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Conte
allowlist[strings.ToLower(encoding)] = true
}
- checker := &encodingAllowlistChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- allowlist: allowlist,
+ rule := &encodingAllowlistRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ allowlist: allowlist,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type encodingAllowlistChecker struct {
- *parser.BasePostgreSQLParserListener
+type encodingAllowlistRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- allowlist map[string]bool
+ allowlist map[string]bool
}
-func (c *encodingAllowlistChecker) EnterCreatedbstmt(ctx *parser.CreatedbstmtContext) {
+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()) {
return
}
@@ -78,16 +95,16 @@ func (c *encodingAllowlistChecker) EnterCreatedbstmt(ctx *parser.CreatedbstmtCon
// Check both with and without WITH keyword
var encoding string
if ctx.Createdb_opt_list() != nil {
- encoding = c.extractEncoding(ctx.Createdb_opt_list())
+ encoding = r.extractEncoding(ctx.Createdb_opt_list())
}
if encoding != "" {
// Check if encoding is in allowlist
- if !c.allowlist[strings.ToLower(encoding)] {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if !r.allowlist[strings.ToLower(encoding)] {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.DisabledCharset.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"\" used disabled encoding '%s'", strings.ToLower(encoding)),
StartPosition: &storepb.Position{
Line: 0,
@@ -98,7 +115,7 @@ func (c *encodingAllowlistChecker) EnterCreatedbstmt(ctx *parser.CreatedbstmtCon
}
}
-func (*encodingAllowlistChecker) extractEncoding(optList parser.ICreatedb_opt_listContext) string {
+func (*encodingAllowlistRule) extractEncoding(optList parser.ICreatedb_opt_listContext) string {
if optList == nil {
return ""
}
diff --git a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go
index 8ed97d0306..86b6c27c24 100644
--- a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go
+++ b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go
@@ -35,30 +35,56 @@ func (*IndexConcurrentlyAdvisor) Check(_ context.Context, checkCtx advisor.Conte
return nil, err
}
- checker := &indexCreateConcurrentlyChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- newlyCreatedTables: make(map[string]bool),
+ rule := &indexCreateConcurrentlyRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ newlyCreatedTables: make(map[string]bool),
}
- // First pass: collect all newly created tables
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type indexCreateConcurrentlyChecker struct {
- *parser.BasePostgreSQLParserListener
+type indexCreateConcurrentlyRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
newlyCreatedTables map[string]bool
}
-// EnterCreatestmt collects newly created tables
-func (c *indexCreateConcurrentlyChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (*indexCreateConcurrentlyRule) Name() string {
+ return "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
}
@@ -68,13 +94,13 @@ func (c *indexCreateConcurrentlyChecker) EnterCreatestmt(ctx *parser.CreatestmtC
if len(qualifiedNames) > 0 {
tableName := extractTableName(qualifiedNames[0])
if tableName != "" {
- c.newlyCreatedTables[tableName] = true
+ r.newlyCreatedTables[tableName] = true
}
}
}
-// EnterIndexstmt checks CREATE INDEX statements
-func (c *indexCreateConcurrentlyChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+// handleIndexstmt checks CREATE INDEX statements
+func (r *indexCreateConcurrentlyRule) handleIndexstmt(ctx *parser.IndexstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -87,15 +113,15 @@ func (c *indexCreateConcurrentlyChecker) EnterIndexstmt(ctx *parser.IndexstmtCon
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
- if c.newlyCreatedTables[tableName] {
+ if r.newlyCreatedTables[tableName] {
return
}
}
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CreateIndexUnconcurrently.Int32(),
- Title: c.title,
+ Title: r.title,
Content: "Creating indexes will block writes on the table, unless use CONCURRENTLY",
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -105,8 +131,8 @@ func (c *indexCreateConcurrentlyChecker) EnterIndexstmt(ctx *parser.IndexstmtCon
}
}
-// EnterDropstmt checks DROP INDEX statements
-func (c *indexCreateConcurrentlyChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+// handleDropstmt checks DROP INDEX statements
+func (r *indexCreateConcurrentlyRule) handleDropstmt(ctx *parser.DropstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -115,10 +141,10 @@ func (c *indexCreateConcurrentlyChecker) EnterDropstmt(ctx *parser.DropstmtConte
if ctx.INDEX() != nil {
// Check if CONCURRENTLY is used
if ctx.CONCURRENTLY() == nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.DropIndexUnconcurrently.Int32(),
- Title: c.title,
+ Title: r.title,
Content: "Droping indexes will block writes on the table, unless use CONCURRENTLY",
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
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 06c66facbc..313f08ea6a 100644
--- a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go
+++ b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go
@@ -42,54 +42,80 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Con
return nil, err
}
- checker := &indexKeyNumberLimitChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- max: payload.Number,
+ rule := &indexKeyNumberLimitRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ max: payload.Number,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type indexKeyNumberLimitChecker struct {
- *parser.BasePostgreSQLParserListener
+type indexKeyNumberLimitRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- max int
+ max int
}
-// EnterIndexstmt checks CREATE INDEX statements
-func (c *indexKeyNumberLimitChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+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)
+ 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 ctx.Index_params() != nil {
- keyCount := c.countIndexKeys(ctx.Index_params())
- if c.max > 0 && keyCount > c.max {
+ if indexstmtCtx.Index_params() != nil {
+ keyCount := r.countIndexKeys(indexstmtCtx.Index_params())
+ if r.max > 0 && keyCount > r.max {
indexName := ""
- if ctx.Name() != nil {
- indexName = pg.NormalizePostgreSQLName(ctx.Name())
+ if indexstmtCtx.Name() != nil {
+ indexName = pg.NormalizePostgreSQLName(indexstmtCtx.Name())
}
tableName := ""
- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
- tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ if indexstmtCtx.Relation_expr() != nil && indexstmtCtx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(indexstmtCtx.Relation_expr().Qualified_name())
}
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.IndexKeyNumberExceedsLimit.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("The number of keys of index %q in table %q should be not greater than %d", indexName, tableName, c.max),
+ 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(ctx.GetStart().GetLine()),
+ Line: int32(indexstmtCtx.GetStart().GetLine()),
Column: 0,
},
})
@@ -97,13 +123,18 @@ func (c *indexKeyNumberLimitChecker) EnterIndexstmt(ctx *parser.IndexstmtContext
}
}
-// EnterCreatestmt checks CREATE TABLE with inline constraints
-func (c *indexKeyNumberLimitChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// 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 := ctx.AllQualified_name()
+ qualifiedNames := createstmtCtx.AllQualified_name()
if len(qualifiedNames) == 0 {
return
}
@@ -114,47 +145,52 @@ func (c *indexKeyNumberLimitChecker) EnterCreatestmt(ctx *parser.CreatestmtConte
}
// Check table-level constraints
- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ 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 {
- c.checkTableConstraint(elem.Tableconstraint(), tableName, ctx.GetStart().GetLine())
+ r.checkTableConstraint(elem.Tableconstraint(), tableName, createstmtCtx.GetStart().GetLine())
}
}
}
}
-// EnterAltertablestmt checks ALTER TABLE ADD CONSTRAINT
-func (c *indexKeyNumberLimitChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// 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 ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ if altertablestmtCtx.Relation_expr() == nil || altertablestmtCtx.Relation_expr().Qualified_name() == nil {
return
}
- tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+ tableName := extractTableName(altertablestmtCtx.Relation_expr().Qualified_name())
if tableName == "" {
return
}
// Check ALTER TABLE ADD CONSTRAINT
- if ctx.Alter_table_cmds() != nil {
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ 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 {
- c.checkTableConstraint(cmd.Tableconstraint(), tableName, ctx.GetStart().GetLine())
+ r.checkTableConstraint(cmd.Tableconstraint(), tableName, altertablestmtCtx.GetStart().GetLine())
}
}
}
}
-func (c *indexKeyNumberLimitChecker) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {
+func (r *indexKeyNumberLimitRule) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {
if constraint == nil {
return
}
@@ -174,24 +210,24 @@ func (c *indexKeyNumberLimitChecker) checkTableConstraint(constraint parser.ITab
// PRIMARY KEY or UNIQUE
if (elem.PRIMARY() != nil && elem.KEY() != nil) || (elem.UNIQUE() != nil) {
if elem.Columnlist() != nil {
- keyCount = c.countColumnList(elem.Columnlist())
+ keyCount = r.countColumnList(elem.Columnlist())
}
}
// FOREIGN KEY
if elem.FOREIGN() != nil && elem.KEY() != nil {
if elem.Columnlist() != nil {
- keyCount = c.countColumnList(elem.Columnlist())
+ keyCount = r.countColumnList(elem.Columnlist())
}
}
}
- if c.max > 0 && keyCount > c.max {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.max > 0 && keyCount > r.max {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.IndexKeyNumberExceedsLimit.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("The number of keys of index %q in table %q should be not greater than %d", constraintName, tableName, c.max),
+ 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),
StartPosition: &storepb.Position{
Line: int32(line),
Column: 0,
@@ -200,7 +236,7 @@ func (c *indexKeyNumberLimitChecker) checkTableConstraint(constraint parser.ITab
}
}
-func (*indexKeyNumberLimitChecker) countIndexKeys(params parser.IIndex_paramsContext) int {
+func (*indexKeyNumberLimitRule) countIndexKeys(params parser.IIndex_paramsContext) int {
if params == nil {
return 0
}
@@ -209,7 +245,7 @@ func (*indexKeyNumberLimitChecker) countIndexKeys(params parser.IIndex_paramsCon
return len(allParams)
}
-func (*indexKeyNumberLimitChecker) countColumnList(columnList parser.IColumnlistContext) int {
+func (*indexKeyNumberLimitRule) countColumnList(columnList parser.IColumnlistContext) int {
if columnList == nil {
return 0
}
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 f125a1a89d..445874b718 100644
--- a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go
+++ b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go
@@ -37,59 +37,86 @@ func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.
return nil, err
}
- checker := &indexNoDuplicateColumnChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &indexNoDuplicateColumnRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
+}
+
+type indexNoDuplicateColumnRule struct {
+ BaseRule
}
-type indexNoDuplicateColumnChecker struct {
- *parser.BasePostgreSQLParserListener
+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)
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+func (*indexNoDuplicateColumnRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-// EnterIndexstmt checks CREATE INDEX statements
-func (c *indexNoDuplicateColumnChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+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 ctx.Name() != nil {
- indexName = pg.NormalizePostgreSQLName(ctx.Name())
+ if indexCtx.Name() != nil {
+ indexName = pg.NormalizePostgreSQLName(indexCtx.Name())
}
// Get table name
tableName := ""
- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
- tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ 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 ctx.Index_params() != nil {
- columns := c.extractIndexColumns(ctx.Index_params())
+ if indexCtx.Index_params() != nil {
+ columns := r.extractIndexColumns(indexCtx.Index_params())
if dupCol := findDuplicate(columns); dupCol != "" {
- c.addAdvice("INDEX", indexName, tableName, dupCol, ctx.GetStart().GetLine())
+ r.addAdvice("INDEX", indexName, tableName, dupCol, indexCtx.GetStart().GetLine())
}
}
}
-// EnterCreatestmt checks CREATE TABLE with inline constraints
-func (c *indexNoDuplicateColumnChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (r *indexNoDuplicateColumnRule) handleCreatestmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreatestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- qualifiedNames := ctx.AllQualified_name()
+ qualifiedNames := createCtx.AllQualified_name()
if len(qualifiedNames) == 0 {
return
}
@@ -100,44 +127,47 @@ func (c *indexNoDuplicateColumnChecker) EnterCreatestmt(ctx *parser.CreatestmtCo
}
// Check table-level constraints
- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ if createCtx.Opttableelementlist() != nil && createCtx.Opttableelementlist().Tableelementlist() != nil {
+ allElements := createCtx.Opttableelementlist().Tableelementlist().AllTableelement()
for _, elem := range allElements {
if elem.Tableconstraint() != nil {
- c.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())
+ r.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())
}
}
}
}
-// EnterAltertablestmt checks ALTER TABLE ADD CONSTRAINT
-func (c *indexNoDuplicateColumnChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *indexNoDuplicateColumnRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AltertablestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ if alterCtx.Relation_expr() == nil || alterCtx.Relation_expr().Qualified_name() == nil {
return
}
- tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+ tableName := extractTableName(alterCtx.Relation_expr().Qualified_name())
if tableName == "" {
return
}
// Check ALTER TABLE ADD CONSTRAINT
- if ctx.Alter_table_cmds() != nil {
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ 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 {
- c.checkTableConstraint(cmd.Tableconstraint(), tableName, ctx.GetStart().GetLine())
+ r.checkTableConstraint(cmd.Tableconstraint(), tableName, alterCtx.GetStart().GetLine())
}
}
}
}
-func (c *indexNoDuplicateColumnChecker) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {
+func (r *indexNoDuplicateColumnRule) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {
if constraint == nil {
return
}
@@ -155,9 +185,9 @@ func (c *indexNoDuplicateColumnChecker) checkTableConstraint(constraint parser.I
// PRIMARY KEY
if elem.PRIMARY() != nil && elem.KEY() != nil {
if elem.Columnlist() != nil {
- columns := c.extractColumnList(elem.Columnlist())
+ columns := r.extractColumnList(elem.Columnlist())
if dupCol := findDuplicate(columns); dupCol != "" {
- c.addAdvice("PRIMARY KEY", constraintName, tableName, dupCol, line)
+ r.addAdvice("PRIMARY KEY", constraintName, tableName, dupCol, line)
}
}
}
@@ -165,9 +195,9 @@ func (c *indexNoDuplicateColumnChecker) checkTableConstraint(constraint parser.I
// UNIQUE
if elem.UNIQUE() != nil {
if elem.Columnlist() != nil {
- columns := c.extractColumnList(elem.Columnlist())
+ columns := r.extractColumnList(elem.Columnlist())
if dupCol := findDuplicate(columns); dupCol != "" {
- c.addAdvice("UNIQUE KEY", constraintName, tableName, dupCol, line)
+ r.addAdvice("UNIQUE KEY", constraintName, tableName, dupCol, line)
}
}
}
@@ -175,16 +205,16 @@ func (c *indexNoDuplicateColumnChecker) checkTableConstraint(constraint parser.I
// FOREIGN KEY
if elem.FOREIGN() != nil && elem.KEY() != nil {
if elem.Columnlist() != nil {
- columns := c.extractColumnList(elem.Columnlist())
+ columns := r.extractColumnList(elem.Columnlist())
if dupCol := findDuplicate(columns); dupCol != "" {
- c.addAdvice("FOREIGN KEY", constraintName, tableName, dupCol, line)
+ r.addAdvice("FOREIGN KEY", constraintName, tableName, dupCol, line)
}
}
}
}
}
-func (*indexNoDuplicateColumnChecker) extractIndexColumns(params parser.IIndex_paramsContext) []string {
+func (*indexNoDuplicateColumnRule) extractIndexColumns(params parser.IIndex_paramsContext) []string {
if params == nil {
return nil
}
@@ -201,7 +231,7 @@ func (*indexNoDuplicateColumnChecker) extractIndexColumns(params parser.IIndex_p
return columns
}
-func (*indexNoDuplicateColumnChecker) extractColumnList(columnList parser.IColumnlistContext) []string {
+func (*indexNoDuplicateColumnRule) extractColumnList(columnList parser.IColumnlistContext) []string {
if columnList == nil {
return nil
}
@@ -229,11 +259,11 @@ func findDuplicate(columns []string) string {
return ""
}
-func (c *indexNoDuplicateColumnChecker) addAdvice(constraintType, constraintName, tableName, duplicateColumn string, line int) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+func (r *indexNoDuplicateColumnRule) addAdvice(constraintType, constraintName, tableName, duplicateColumn string, line int) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.DuplicateColumnInIndex.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("%s %q has duplicate column %q.%q", constraintType, constraintName, tableName, duplicateColumn),
StartPosition: &storepb.Position{
Line: int32(line),
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 a9a61baa4b..738000cd42 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
@@ -42,29 +42,43 @@ func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx ad
return nil, err
}
- checker := &indexPrimaryKeyTypeAllowlistChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- allowlist: payload.List,
+ rule := &indexPrimaryKeyTypeAllowlistRule{
+ BaseRule: BaseRule{level: level, title: string(checkCtx.Rule.Type)},
+ allowlist: payload.List,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type indexPrimaryKeyTypeAllowlistChecker struct {
- *parser.BasePostgreSQLParserListener
+type indexPrimaryKeyTypeAllowlistRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- allowlist []string
+ allowlist []string
}
-// EnterCreatestmt checks CREATE TABLE with inline PRIMARY KEY constraints
-func (c *indexPrimaryKeyTypeAllowlistChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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))
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
+
+func (*indexPrimaryKeyTypeAllowlistRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
+}
+
+// handleCreatestmt checks CREATE TABLE with inline PRIMARY KEY constraints
+func (r *indexPrimaryKeyTypeAllowlistRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -80,14 +94,14 @@ func (c *indexPrimaryKeyTypeAllowlistChecker) EnterCreatestmt(ctx *parser.Create
colDef := elem.ColumnDef()
if colDef.Colid() != nil && colDef.Typename() != nil {
columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
- columnType := c.getTypeName(colDef.Typename())
+ columnType := r.getTypeName(colDef.Typename())
columnTypes[columnName] = columnType
columnLines[columnName] = colDef.GetStart().GetLine()
// Check if this column has PRIMARY KEY constraint
- if c.hasColumnPrimaryKeyConstraint(colDef) {
- if !c.isTypeAllowed(columnType) {
- c.addAdvice(columnName, columnType, colDef.GetStart().GetLine())
+ if r.hasColumnPrimaryKeyConstraint(colDef) {
+ if !r.isTypeAllowed(columnType) {
+ r.addAdvice(columnName, columnType, colDef.GetStart().GetLine())
}
}
}
@@ -97,13 +111,13 @@ func (c *indexPrimaryKeyTypeAllowlistChecker) EnterCreatestmt(ctx *parser.Create
// Check table-level PRIMARY KEY constraints
for _, elem := range allElements {
if elem.Tableconstraint() != nil {
- c.checkTablePrimaryKey(elem.Tableconstraint(), columnTypes, columnLines)
+ r.checkTablePrimaryKey(elem.Tableconstraint(), columnTypes, columnLines)
}
}
}
}
-func (*indexPrimaryKeyTypeAllowlistChecker) hasColumnPrimaryKeyConstraint(colDef parser.IColumnDefContext) bool {
+func (*indexPrimaryKeyTypeAllowlistRule) hasColumnPrimaryKeyConstraint(colDef parser.IColumnDefContext) bool {
if colDef.Colquallist() == nil {
return false
}
@@ -121,7 +135,7 @@ func (*indexPrimaryKeyTypeAllowlistChecker) hasColumnPrimaryKeyConstraint(colDef
return false
}
-func (c *indexPrimaryKeyTypeAllowlistChecker) checkTablePrimaryKey(constraint parser.ITableconstraintContext, columnTypes map[string]string, columnLines map[string]int) {
+func (r *indexPrimaryKeyTypeAllowlistRule) checkTablePrimaryKey(constraint parser.ITableconstraintContext, columnTypes map[string]string, columnLines map[string]int) {
if constraint == nil || constraint.Constraintelem() == nil {
return
}
@@ -137,10 +151,10 @@ func (c *indexPrimaryKeyTypeAllowlistChecker) checkTablePrimaryKey(constraint pa
if col.Colid() != nil {
columnName := pg.NormalizePostgreSQLColid(col.Colid())
if columnType, exists := columnTypes[columnName]; exists {
- if !c.isTypeAllowed(columnType) {
+ if !r.isTypeAllowed(columnType) {
// Use the column definition's line, not the constraint's line
line := columnLines[columnName]
- c.addAdvice(columnName, columnType, line)
+ r.addAdvice(columnName, columnType, line)
}
}
}
@@ -149,7 +163,7 @@ func (c *indexPrimaryKeyTypeAllowlistChecker) checkTablePrimaryKey(constraint pa
}
}
-func (*indexPrimaryKeyTypeAllowlistChecker) getTypeName(typename parser.ITypenameContext) string {
+func (*indexPrimaryKeyTypeAllowlistRule) getTypeName(typename parser.ITypenameContext) string {
if typename == nil {
return ""
}
@@ -158,16 +172,16 @@ func (*indexPrimaryKeyTypeAllowlistChecker) getTypeName(typename parser.ITypenam
return normalizePostgreSQLType(typename.GetText())
}
-func (c *indexPrimaryKeyTypeAllowlistChecker) isTypeAllowed(columnType string) bool {
+func (r *indexPrimaryKeyTypeAllowlistRule) isTypeAllowed(columnType string) bool {
// Check if the column type is equivalent to any type in the allowlist
- return isTypeInList(columnType, c.allowlist)
+ return isTypeInList(columnType, r.allowlist)
}
-func (c *indexPrimaryKeyTypeAllowlistChecker) addAdvice(columnName, columnType string, line int) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+func (r *indexPrimaryKeyTypeAllowlistRule) addAdvice(columnName, columnType string, line int) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.IndexPKType.Int32(),
- Title: c.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),
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 d850516c7c..f5b4900a17 100644
--- a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
+++ b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
@@ -42,20 +42,21 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.C
return nil, err
}
- checker := &indexTotalNumberLimitChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- max: payload.Number,
- catalog: checkCtx.Catalog,
- tableLine: make(tableLineMap),
+ rule := &indexTotalNumberLimitRule{
+ BaseRule: BaseRule{level: level, title: string(checkCtx.Rule.Type)},
+ max: payload.Number,
+ catalog: checkCtx.Catalog,
+ tableLine: make(tableLineMap),
}
- if checker.catalog.Final.Usable() {
+ if rule.catalog.Final.Usable() {
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ rule.generateAdvice()
+ return checker.GetAdviceList(), nil
}
- return checker.generateAdvice(), nil
+ return nil, nil
}
type tableLine struct {
@@ -77,20 +78,39 @@ func (m tableLineMap) set(schema string, table string, line int) {
}
}
-type indexTotalNumberLimitChecker struct {
- *parser.BasePostgreSQLParserListener
+type indexTotalNumberLimitRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- max int
- catalog *catalog.Finder
- tableLine tableLineMap
+ max int
+ catalog *catalog.Finder
+ tableLine tableLineMap
}
-func (c *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice {
+func (*indexTotalNumberLimitRule) Name() string {
+ return "index_total_number_limit"
+}
+
+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))
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
+
+func (*indexTotalNumberLimitRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
+}
+
+func (r *indexTotalNumberLimitRule) generateAdvice() {
var tableList []tableLine
- for _, table := range c.tableLine {
+ for _, table := range r.tableLine {
tableList = append(tableList, table)
}
slices.SortFunc(tableList, func(i, j tableLine) int {
@@ -104,16 +124,16 @@ func (c *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice {
})
for _, table := range tableList {
- tableInfo := c.catalog.Final.FindTable(&catalog.TableFind{
+ tableInfo := r.catalog.Final.FindTable(&catalog.TableFind{
SchemaName: table.schema,
TableName: table.table,
})
- if tableInfo != nil && tableInfo.CountIndex() > c.max {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if tableInfo != nil && tableInfo.CountIndex() > r.max {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.IndexCountExceedsLimit.Int32(),
- Title: c.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, c.max, tableInfo.CountIndex()),
+ 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, tableInfo.CountIndex()),
StartPosition: &storepb.Position{
Line: int32(table.line),
Column: 0,
@@ -121,11 +141,9 @@ func (c *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice {
})
}
}
-
- return c.adviceList
}
-func (c *indexTotalNumberLimitChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (r *indexTotalNumberLimitRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -150,21 +168,21 @@ func (c *indexTotalNumberLimitChecker) EnterCreatestmt(ctx *parser.CreatestmtCon
// Check column-level constraints
if elem.ColumnDef() != nil {
if hasIndexConstraint(elem.ColumnDef()) {
- c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ r.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
return
}
}
// Check table-level constraints
if elem.Tableconstraint() != nil && hasTableIndexConstraint(elem.Tableconstraint()) {
- c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ r.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
return
}
}
}
}
-func (c *indexTotalNumberLimitChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *indexTotalNumberLimitRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -187,7 +205,7 @@ func (c *indexTotalNumberLimitChecker) EnterAltertablestmt(ctx *parser.Altertabl
// ADD COLUMN with PRIMARY KEY or UNIQUE
if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
if hasIndexConstraint(cmd.ColumnDef()) {
- c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ r.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
return
}
}
@@ -195,7 +213,7 @@ func (c *indexTotalNumberLimitChecker) EnterAltertablestmt(ctx *parser.Altertabl
// ADD CONSTRAINT (PRIMARY KEY or UNIQUE)
if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
if hasTableIndexConstraint(cmd.Tableconstraint()) {
- c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ r.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
return
}
}
@@ -203,7 +221,7 @@ func (c *indexTotalNumberLimitChecker) EnterAltertablestmt(ctx *parser.Altertabl
}
}
-func (c *indexTotalNumberLimitChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+func (r *indexTotalNumberLimitRule) handleIndexstmt(ctx *parser.IndexstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -218,7 +236,7 @@ func (c *indexTotalNumberLimitChecker) EnterIndexstmt(ctx *parser.IndexstmtConte
}
schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())
- c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ r.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
}
// hasIndexConstraint checks if a column definition has PRIMARY KEY or UNIQUE constraint
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 df11960b4b..b4a7c3e396 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
@@ -37,49 +37,71 @@ func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advis
return nil, err
}
- checker := &insertDisallowOrderByRandChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &insertDisallowOrderByRandRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type insertDisallowOrderByRandChecker struct {
- *parser.BasePostgreSQLParserListener
+type insertDisallowOrderByRandRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
statementsText string
}
-func (c *insertDisallowOrderByRandChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+func (*insertDisallowOrderByRandRule) Name() string {
+ return "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)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(insertstmtCtx.GetParent()) {
return
}
// Check if this is INSERT...SELECT
- if ctx.Insert_rest() == nil || ctx.Insert_rest().Selectstmt() == nil {
+ if insertstmtCtx.Insert_rest() == nil || insertstmtCtx.Insert_rest().Selectstmt() == nil {
return
}
// Check for ORDER BY random() in the SELECT statement
- if c.hasOrderByRandom(ctx.Insert_rest().Selectstmt()) {
+ if r.hasOrderByRandom(insertstmtCtx.Insert_rest().Selectstmt()) {
// Extract the statement text from the original statements
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ stmtText := extractStatementText(r.statementsText, insertstmtCtx.GetStart().GetLine(), insertstmtCtx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.InsertUseOrderByRand.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("The INSERT statement uses ORDER BY random() or random_between(), related statement \"%s\"", stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(insertstmtCtx.GetStart().GetLine()),
Column: 0,
},
})
@@ -87,7 +109,7 @@ func (c *insertDisallowOrderByRandChecker) EnterInsertstmt(ctx *parser.Insertstm
}
// hasOrderByRandom checks if a SELECT statement has ORDER BY random() or random_between()
-func (*insertDisallowOrderByRandChecker) hasOrderByRandom(selectCtx parser.ISelectstmtContext) bool {
+func (*insertDisallowOrderByRandRule) hasOrderByRandom(selectCtx parser.ISelectstmtContext) bool {
if selectCtx == nil {
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 4e43076c13..bc0899955a 100644
--- a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go
+++ b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go
@@ -36,54 +36,76 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor
return nil, err
}
- checker := &insertMustSpecifyColumnChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &insertMustSpecifyColumnRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type insertMustSpecifyColumnChecker struct {
- *parser.BasePostgreSQLParserListener
+type insertMustSpecifyColumnRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
statementsText string
}
-func (c *insertMustSpecifyColumnChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+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
+}
+
+func (r *insertMustSpecifyColumnRule) handleInsertstmt(ctx antlr.ParserRuleContext) {
+ insertstmtCtx, ok := ctx.(*parser.InsertstmtContext)
+ 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 ctx.Insert_rest() == nil {
+ if insertstmtCtx.Insert_rest() == nil {
return
}
// Check if there's an insert_column_list
// Insert_column_list exists, which means columns are specified
- hasColumnList := ctx.Insert_rest().Insert_column_list() != nil
+ hasColumnList := insertstmtCtx.Insert_rest().Insert_column_list() != nil
if !hasColumnList {
// Extract the statement text from the original statements
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ stmtText := extractStatementText(r.statementsText, insertstmtCtx.GetStart().GetLine(), insertstmtCtx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.InsertNotSpecifyColumn.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(insertstmtCtx.GetStart().GetLine()),
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 ae5b9bafa1..2a0497a624 100644
--- a/backend/plugin/advisor/pg/advisor_insert_row_limit.go
+++ b/backend/plugin/advisor/pg/advisor_insert_row_limit.go
@@ -45,30 +45,30 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contex
return nil, err
}
- checker := &insertRowLimitChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- maxRow: payload.Number,
- driver: checkCtx.Driver,
- ctx: ctx,
- statementsText: checkCtx.Statements,
- UsePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
+ rule := &insertRowLimitRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ maxRow: payload.Number,
+ driver: checkCtx.Driver,
+ ctx: ctx,
+ statementsText: checkCtx.Statements,
+ UsePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
}
if payload.Number > 0 {
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ return checker.GetAdviceList(), nil
}
- return checker.adviceList, nil
+ return nil, nil
}
-type insertRowLimitChecker struct {
- *parser.BasePostgreSQLParserListener
+type insertRowLimitRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
maxRow int
driver *sql.DB
ctx context.Context
@@ -78,7 +78,31 @@ type insertRowLimitChecker struct {
UsePostgresDatabaseOwner bool
}
-func (c *insertRowLimitChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+func (*insertRowLimitRule) Name() string {
+ return "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)
+ }
+ 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
}
@@ -88,12 +112,12 @@ func (c *insertRowLimitChecker) EnterVariablesetstmt(ctx *parser.Variablesetstmt
setRestMore := ctx.Set_rest().Set_rest_more()
// Check if this is SET ROLE
if setRestMore.ROLE() != nil {
- c.setRoles = append(c.setRoles, ctx.GetText())
+ r.setRoles = append(r.setRoles, ctx.GetText())
}
}
}
-func (c *insertRowLimitChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+func (r *insertRowLimitRule) handleInsertstmt(ctx *parser.InsertstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -107,28 +131,28 @@ func (c *insertRowLimitChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
rowCount := countValueLists(ctx.Insert_rest().Selectstmt())
if rowCount > 0 {
// This is INSERT ... VALUES
- if rowCount > c.maxRow {
+ if rowCount > r.maxRow {
code = advisor.InsertTooManyRows
rows = int64(rowCount)
}
- } else if c.driver != nil {
+ } else if r.driver != nil {
// For INSERT ... SELECT, use EXPLAIN
- if c.explainCount >= common.MaximumLintExplainSize {
+ if r.explainCount >= common.MaximumLintExplainSize {
return
}
- c.explainCount++
+ r.explainCount++
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- res, err := advisor.Query(c.ctx, advisor.QueryContext{
- UsePostgresDatabaseOwner: c.UsePostgresDatabaseOwner,
- PreExecutions: c.setRoles,
- }, c.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ res, err := advisor.Query(r.ctx, advisor.QueryContext{
+ UsePostgresDatabaseOwner: r.UsePostgresDatabaseOwner,
+ PreExecutions: r.setRoles,
+ }, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.InsertTooManyRows.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" dry runs failed: %s", stmtText, err.Error()),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -140,10 +164,10 @@ func (c *insertRowLimitChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
rowCount, err := getAffectedRows(res)
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.Internal.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("failed to get row count for \"%s\": %s", stmtText, err.Error()),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -153,7 +177,7 @@ func (c *insertRowLimitChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
return
}
- if rowCount > int64(c.maxRow) {
+ if rowCount > int64(r.maxRow) {
code = advisor.InsertTooManyRows
rows = rowCount
}
@@ -161,12 +185,12 @@ func (c *insertRowLimitChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
}
if code != advisor.Ok {
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: code.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("The statement \"%s\" inserts %d rows. The count exceeds %d.", stmtText, rows, c.maxRow),
+ Title: r.title,
+ Content: fmt.Sprintf("The statement \"%s\" inserts %d rows. The count exceeds %d.", stmtText, rows, r.maxRow),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
Column: 0,
diff --git a/backend/plugin/advisor/pg/advisor_migration_compatibility.go b/backend/plugin/advisor/pg/advisor_migration_compatibility.go
index 034d24c3bc..0d002defa4 100644
--- a/backend/plugin/advisor/pg/advisor_migration_compatibility.go
+++ b/backend/plugin/advisor/pg/advisor_migration_compatibility.go
@@ -36,77 +36,119 @@ func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context)
return nil, err
}
- checker := &compatibilityChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &compatibilityRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type compatibilityChecker struct {
- *parser.BasePostgreSQLParserListener
+type compatibilityRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
statementsText string
lastCreateTable string
}
-// EnterCreatestmt tracks CREATE TABLE statements
-func (c *compatibilityChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+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)
+ 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 := ctx.AllQualified_name()
+ qualifiedNames := createstmtCtx.AllQualified_name()
if len(qualifiedNames) > 0 {
- c.lastCreateTable = extractTableName(qualifiedNames[0])
+ r.lastCreateTable = extractTableName(qualifiedNames[0])
}
}
-// EnterDropdbstmt handles DROP DATABASE
-func (c *compatibilityChecker) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// handleDropdbstmt handles DROP DATABASE
+func (r *compatibilityRule) handleDropdbstmt(ctx antlr.ParserRuleContext) {
+ dropdbstmtCtx, ok := ctx.(*parser.DropdbstmtContext)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(dropdbstmtCtx.GetParent()) {
return
}
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, dropdbstmtCtx.GetStart().GetLine(), dropdbstmtCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CompatibilityDropDatabase.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(dropdbstmtCtx.GetStart().GetLine()),
Column: 0,
},
})
}
-// EnterDropstmt handles DROP TABLE/VIEW
-func (c *compatibilityChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// handleDropstmt handles DROP TABLE/VIEW
+func (r *compatibilityRule) handleDropstmt(ctx antlr.ParserRuleContext) {
+ dropstmtCtx, ok := ctx.(*parser.DropstmtContext)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(dropstmtCtx.GetParent()) {
return
}
// Check if this is DROP TABLE or DROP VIEW
- if ctx.Object_type_any_name() != nil {
- objType := ctx.Object_type_any_name()
+ if dropstmtCtx.Object_type_any_name() != nil {
+ objType := dropstmtCtx.Object_type_any_name()
if objType.TABLE() != nil || objType.VIEW() != nil {
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, dropstmtCtx.GetStart().GetLine(), dropstmtCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CompatibilityDropTable.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(dropstmtCtx.GetStart().GetLine()),
Column: 0,
},
})
@@ -114,20 +156,25 @@ func (c *compatibilityChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
}
}
-// EnterRenamestmt handles ALTER TABLE RENAME and RENAME COLUMN
-func (c *compatibilityChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// 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
}
code := advisor.Ok
// Check if this is a column rename
- if ctx.Opt_column() != nil && ctx.Opt_column().COLUMN() != nil {
+ if renamestmtCtx.Opt_column() != nil && renamestmtCtx.Opt_column().COLUMN() != nil {
// RENAME COLUMN - check if not on last created table
- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
- tableName := extractTableName(ctx.Relation_expr().Qualified_name())
- if c.lastCreateTable != tableName {
+ if renamestmtCtx.Relation_expr() != nil && renamestmtCtx.Relation_expr().Qualified_name() != nil {
+ tableName := extractTableName(renamestmtCtx.Relation_expr().Qualified_name())
+ if r.lastCreateTable != tableName {
code = advisor.CompatibilityRenameColumn
}
}
@@ -137,41 +184,46 @@ func (c *compatibilityChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
}
if code != advisor.Ok {
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, renamestmtCtx.GetStart().GetLine(), renamestmtCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: code.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(renamestmtCtx.GetStart().GetLine()),
Column: 0,
},
})
}
}
-// EnterAltertablestmt handles various ALTER TABLE commands
-func (c *compatibilityChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// handleAltertablestmt handles various ALTER TABLE commands
+func (r *compatibilityRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {
+ altertablestmtCtx, ok := ctx.(*parser.AltertablestmtContext)
+ if !ok {
return
}
- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ if !isTopLevel(altertablestmtCtx.GetParent()) {
return
}
- tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+
+ if altertablestmtCtx.Relation_expr() == nil || altertablestmtCtx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+ tableName := extractTableName(altertablestmtCtx.Relation_expr().Qualified_name())
// Skip if this is the table we just created
- if c.lastCreateTable == tableName {
+ if r.lastCreateTable == tableName {
return
}
- if ctx.Alter_table_cmds() == nil {
+ if altertablestmtCtx.Alter_table_cmds() == nil {
return
}
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ allCmds := altertablestmtCtx.Alter_table_cmds().AllAlter_table_cmd()
for _, cmd := range allCmds {
code := advisor.Ok
@@ -227,14 +279,14 @@ func (c *compatibilityChecker) EnterAltertablestmt(ctx *parser.AltertablestmtCon
}
if code != advisor.Ok {
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, altertablestmtCtx.GetStart().GetLine(), altertablestmtCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: code.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(altertablestmtCtx.GetStart().GetLine()),
Column: 0,
},
})
@@ -243,36 +295,41 @@ func (c *compatibilityChecker) EnterAltertablestmt(ctx *parser.AltertablestmtCon
}
}
-// EnterIndexstmt handles CREATE UNIQUE INDEX
-func (c *compatibilityChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// 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
}
// Check if this is CREATE UNIQUE INDEX
- if ctx.Opt_unique() == nil || ctx.Opt_unique().UNIQUE() == nil {
+ if indexstmtCtx.Opt_unique() == nil || indexstmtCtx.Opt_unique().UNIQUE() == nil {
return
}
// Get table name
- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ if indexstmtCtx.Relation_expr() == nil || indexstmtCtx.Relation_expr().Qualified_name() == nil {
return
}
- tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+ tableName := extractTableName(indexstmtCtx.Relation_expr().Qualified_name())
// Skip if this is the table we just created
- if c.lastCreateTable == tableName {
+ if r.lastCreateTable == tableName {
return
}
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, indexstmtCtx.GetStart().GetLine(), indexstmtCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CompatibilityAddUniqueKey.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(indexstmtCtx.GetStart().GetLine()),
Column: 0,
},
})
diff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.go
index 4db9e4f5c5..b469ccf38c 100644
--- a/backend/plugin/advisor/pg/advisor_naming_column.go
+++ b/backend/plugin/advisor/pg/advisor_naming_column.go
@@ -43,129 +43,159 @@ func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.
return nil, err
}
- checker := &namingColumnConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- format: format,
- maxLength: maxLength,
+ rule := &namingColumnConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ format: format,
+ maxLength: maxLength,
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
+}
+
+type namingColumnConventionRule struct {
+ BaseRule
+
+ format *regexp.Regexp
+ maxLength int
}
-type namingColumnConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+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)
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- format *regexp.Regexp
- maxLength int
+func (*namingColumnConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-// EnterCreatestmt handles CREATE TABLE statements
-func (c *namingColumnConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (r *namingColumnConventionRule) handleCreatestmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreatestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
// Get table name
- qualifiedNames := ctx.AllQualified_name()
+ qualifiedNames := createCtx.AllQualified_name()
if len(qualifiedNames) == 0 {
return
}
tableName := extractTableName(qualifiedNames[0])
// Get OptTableElementList which contains column definitions
- if ctx.Opttableelementlist() == nil || ctx.Opttableelementlist().Tableelementlist() == nil {
+ if createCtx.Opttableelementlist() == nil || createCtx.Opttableelementlist().Tableelementlist() == nil {
return
}
// Iterate through all table elements
- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ 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())
- c.checkColumnName(tableName, columnName, colDef.GetStart().GetLine())
+ r.checkColumnName(tableName, columnName, colDef.GetStart().GetLine())
}
}
}
}
-// EnterAltertablestmt handles ALTER TABLE ADD COLUMN statements
-func (c *namingColumnConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *namingColumnConventionRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AltertablestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
// Get table name
- if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ if alterCtx.Relation_expr() == nil || alterCtx.Relation_expr().Qualified_name() == nil {
return
}
- tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+ tableName := extractTableName(alterCtx.Relation_expr().Qualified_name())
// Get ALTER TABLE commands
- if ctx.Alter_table_cmds() == nil {
+ if alterCtx.Alter_table_cmds() == nil {
return
}
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ 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())
- c.checkColumnName(tableName, columnName, colDef.GetStart().GetLine())
+ r.checkColumnName(tableName, columnName, colDef.GetStart().GetLine())
}
}
}
}
-// EnterRenamestmt handles RENAME COLUMN statements
-func (c *namingColumnConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+func (r *namingColumnConventionRule) handleRenamestmt(ctx antlr.ParserRuleContext) {
+ renameCtx, ok := ctx.(*parser.RenamestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
// Check if this is RENAME COLUMN
- if ctx.Opt_column() == nil || ctx.Opt_column().COLUMN() == nil {
+ if renameCtx.Opt_column() == nil || renameCtx.Opt_column().COLUMN() == nil {
return
}
// Get table name
var tableName string
- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
- tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ 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 := ctx.AllName()
+ allNames := renameCtx.AllName()
if len(allNames) < 2 {
return
}
newColumnName := pg.NormalizePostgreSQLName(allNames[1])
- c.checkColumnName(tableName, newColumnName, ctx.GetStart().GetLine())
+ r.checkColumnName(tableName, newColumnName, renameCtx.GetStart().GetLine())
}
-// checkColumnName validates a column name against the format and max length rules
-func (c *namingColumnConventionChecker) checkColumnName(tableName, columnName string, line int) {
- if !c.format.MatchString(columnName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+func (r *namingColumnConventionRule) checkColumnName(tableName, columnName string, line int) {
+ if !r.format.MatchString(columnName) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingColumnConventionMismatch.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, naming format should be %q", tableName, columnName, c.format),
+ 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),
Column: 0,
@@ -173,12 +203,12 @@ func (c *namingColumnConventionChecker) checkColumnName(tableName, columnName st
})
}
- if c.maxLength > 0 && len(columnName) > c.maxLength {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.maxLength > 0 && len(columnName) > r.maxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingColumnConventionMismatch.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, its length should be within %d characters", tableName, columnName, c.maxLength),
+ 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),
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 9d5429fd35..d09666a67b 100644
--- a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go
@@ -44,26 +44,26 @@ func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont
return nil, err
}
- checker := &namingFKConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- format: format,
- maxLength: maxLength,
- templateList: templateList,
+ rule := &namingFKConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type namingFKConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type namingFKConventionRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
format string
maxLength int
templateList []string
@@ -76,8 +76,27 @@ type fkMetaData struct {
metaData map[string]string
}
-// EnterCreatestmt handles CREATE TABLE with FOREIGN KEY constraints
-func (c *namingFKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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))
+ 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
}
@@ -98,9 +117,9 @@ func (c *namingFKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContex
for _, element := range ctx.Opttableelementlist().Tableelementlist().AllTableelement() {
// Check table-level constraints
if element.Tableconstraint() != nil {
- metadata := c.extractFKMetadata(element.Tableconstraint(), tableName, ctx.GetStart().GetLine())
+ metadata := r.extractFKMetadata(element.Tableconstraint(), tableName, ctx.GetStart().GetLine())
if metadata != nil {
- c.checkFKMetadata(metadata)
+ r.checkFKMetadata(metadata)
}
}
@@ -110,9 +129,9 @@ func (c *namingFKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContex
if columnDef.Colquallist() != nil {
allQuals := columnDef.Colquallist().AllColconstraint()
for _, qual := range allQuals {
- metadata := c.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())
+ metadata := r.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())
if metadata != nil {
- c.checkFKMetadata(metadata)
+ r.checkFKMetadata(metadata)
}
}
}
@@ -121,8 +140,7 @@ func (c *namingFKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContex
}
}
-// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT FOREIGN KEY
-func (c *namingFKConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *namingFKConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -141,9 +159,9 @@ func (c *namingFKConventionChecker) EnterAltertablestmt(ctx *parser.Altertablest
for _, cmd := range allCmds {
// Check for ADD + Tableconstraint
if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
- metadata := c.extractFKMetadata(cmd.Tableconstraint(), tableName, cmd.GetStart().GetLine())
+ metadata := r.extractFKMetadata(cmd.Tableconstraint(), tableName, cmd.GetStart().GetLine())
if metadata != nil {
- c.checkFKMetadata(metadata)
+ r.checkFKMetadata(metadata)
}
}
@@ -153,9 +171,9 @@ func (c *namingFKConventionChecker) EnterAltertablestmt(ctx *parser.Altertablest
if columnDef.Colquallist() != nil {
allQuals := columnDef.Colquallist().AllColconstraint()
for _, qual := range allQuals {
- metadata := c.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())
+ metadata := r.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())
if metadata != nil {
- c.checkFKMetadata(metadata)
+ r.checkFKMetadata(metadata)
}
}
}
@@ -163,7 +181,7 @@ func (c *namingFKConventionChecker) EnterAltertablestmt(ctx *parser.Altertablest
}
}
-func (*namingFKConventionChecker) extractFKMetadata(constraint parser.ITableconstraintContext, tableName string, line int) *fkMetaData {
+func (*namingFKConventionRule) extractFKMetadata(constraint parser.ITableconstraintContext, tableName string, line int) *fkMetaData {
if constraint.Constraintelem() == nil {
return nil
}
@@ -221,7 +239,7 @@ func (*namingFKConventionChecker) extractFKMetadata(constraint parser.ITablecons
}
}
-func (*namingFKConventionChecker) extractColumnFKMetadata(qual parser.IColconstraintContext, tableName string, columnDef parser.IColumnDefContext, line int) *fkMetaData {
+func (*namingFKConventionRule) extractColumnFKMetadata(qual parser.IColconstraintContext, tableName string, columnDef parser.IColumnDefContext, line int) *fkMetaData {
if qual.Colconstraintelem() == nil {
return nil
}
@@ -275,11 +293,11 @@ func (*namingFKConventionChecker) extractColumnFKMetadata(qual parser.IColconstr
}
}
-func (c *namingFKConventionChecker) checkFKMetadata(fkData *fkMetaData) {
- regex, err := c.getTemplateRegexp(fkData.metaData)
+func (r *namingFKConventionRule) checkFKMetadata(fkData *fkMetaData) {
+ regex, err := r.getTemplateRegexp(fkData.metaData)
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.Internal.Int32(),
Title: "Internal error for foreign key naming convention rule",
Content: fmt.Sprintf("Failed to compile regex: %s", err.Error()),
@@ -292,10 +310,10 @@ func (c *namingFKConventionChecker) checkFKMetadata(fkData *fkMetaData) {
}
if !regex.MatchString(fkData.indexName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingFKConventionMismatch.Int32(),
- Title: c.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),
@@ -304,12 +322,12 @@ func (c *namingFKConventionChecker) checkFKMetadata(fkData *fkMetaData) {
})
}
- if c.maxLength > 0 && len(fkData.indexName) > c.maxLength {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.maxLength > 0 && len(fkData.indexName) > r.maxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingFKConventionMismatch.Int32(),
- Title: c.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, c.maxLength),
+ 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),
Column: 0,
@@ -318,9 +336,9 @@ func (c *namingFKConventionChecker) checkFKMetadata(fkData *fkMetaData) {
}
}
-func (c *namingFKConventionChecker) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {
- template := c.format
- for _, key := range c.templateList {
+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)
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
index f804f45206..8123eaf577 100644
--- a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
+++ b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
@@ -39,78 +39,137 @@ func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx adviso
return nil, err
}
- checker := &fullyQualifiedObjectNameChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- dbSchema: checkCtx.DBSchema,
- statementsText: checkCtx.Statements,
+ rule := &fullyQualifiedObjectNameRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ dbSchema: checkCtx.DBSchema,
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type fullyQualifiedObjectNameChecker struct {
- *parser.BasePostgreSQLParserListener
+type fullyQualifiedObjectNameRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
dbSchema *storepb.DatabaseSchemaMetadata
statementsText string
}
-// EnterCreatestmt handles CREATE TABLE
-func (c *fullyQualifiedObjectNameChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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)
+ }
+ 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 {
- c.checkQualifiedName(allQualifiedNames[0], ctx.GetStop().GetLine())
+ r.checkQualifiedName(allQualifiedNames[0], ctx.GetStop().GetLine())
}
}
-// EnterCreateseqstmt handles CREATE SEQUENCE
-func (c *fullyQualifiedObjectNameChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {
+// handleCreateseqstmt handles CREATE SEQUENCE
+func (r *fullyQualifiedObjectNameRule) handleCreateseqstmt(ctx *parser.CreateseqstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
if ctx.Qualified_name() != nil {
- c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
}
}
-// EnterCreatetrigstmt handles CREATE TRIGGER
-func (c *fullyQualifiedObjectNameChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {
+// 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 {
- c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
}
}
-// EnterIndexstmt handles CREATE INDEX
-func (c *fullyQualifiedObjectNameChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+// 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 {
- c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
}
}
-// EnterDropstmt handles DROP TABLE, DROP SEQUENCE, DROP INDEX
-func (c *fullyQualifiedObjectNameChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+// handleDropstmt handles DROP TABLE, DROP SEQUENCE, DROP INDEX
+func (r *fullyQualifiedObjectNameRule) handleDropstmt(ctx *parser.DropstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -118,97 +177,97 @@ func (c *fullyQualifiedObjectNameChecker) EnterDropstmt(ctx *parser.DropstmtCont
// Check all qualified names in the drop statement
if ctx.Any_name_list() != nil {
for _, anyName := range ctx.Any_name_list().AllAny_name() {
- c.checkAnyName(anyName, ctx.GetStop().GetLine())
+ r.checkAnyName(anyName, ctx.GetStop().GetLine())
}
}
}
-// EnterAltertablestmt handles ALTER TABLE
-func (c *fullyQualifiedObjectNameChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+// 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 {
- c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
}
}
-// EnterAlterseqstmt handles ALTER SEQUENCE
-func (c *fullyQualifiedObjectNameChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {
+// handleAlterseqstmt handles ALTER SEQUENCE
+func (r *fullyQualifiedObjectNameRule) handleAlterseqstmt(ctx *parser.AlterseqstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
if ctx.Qualified_name() != nil {
- c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
}
}
-// EnterRenamestmt handles ALTER TABLE RENAME
-func (c *fullyQualifiedObjectNameChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+// 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 {
- c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
}
}
-// EnterInsertstmt handles INSERT
-func (c *fullyQualifiedObjectNameChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+// 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 {
- c.checkQualifiedName(ctx.Insert_target().Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Insert_target().Qualified_name(), ctx.GetStop().GetLine())
}
}
-// EnterUpdatestmt handles UPDATE
-func (c *fullyQualifiedObjectNameChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+// 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 {
- c.checkQualifiedName(ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ r.checkQualifiedName(ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
}
}
}
-// EnterSelectstmt handles SELECT
-func (c *fullyQualifiedObjectNameChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {
+// 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
- if c.dbSchema == nil {
+ if r.dbSchema == nil {
return
}
// Extract the statement text for this SELECT
startLine := ctx.GetStop().GetLine()
endLine := ctx.GetStop().GetLine()
- statementText := extractStatementText(c.statementsText, startLine, endLine)
+ statementText := extractStatementText(r.statementsText, startLine, endLine)
if statementText == "" {
return
}
// Find all table references in the SELECT statement
- for _, tableName := range c.findAllTablesInSelect(statementText) {
+ for _, tableName := range r.findAllTablesInSelect(statementText) {
objName := tableName.String()
- if !c.isFullyQualified(objName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if !r.isFullyQualified(objName) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: int32(advisor.NamingNotFullyQualifiedName),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("unqualified object name: '%s'", objName),
StartPosition: &storepb.Position{
Line: int32(startLine),
@@ -220,7 +279,7 @@ func (c *fullyQualifiedObjectNameChecker) EnterSelectstmt(ctx *parser.Selectstmt
}
// checkQualifiedName checks if a qualified name is fully qualified
-func (c *fullyQualifiedObjectNameChecker) checkQualifiedName(ctx parser.IQualified_nameContext, line int) {
+func (r *fullyQualifiedObjectNameRule) checkQualifiedName(ctx parser.IQualified_nameContext, line int) {
if ctx == nil {
return
}
@@ -228,11 +287,11 @@ func (c *fullyQualifiedObjectNameChecker) checkQualifiedName(ctx parser.IQualifi
parts := pgparser.NormalizePostgreSQLQualifiedName(ctx)
objName := strings.Join(parts, ".")
- if !c.isFullyQualified(objName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if !r.isFullyQualified(objName) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: int32(advisor.NamingNotFullyQualifiedName),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("unqualified object name: '%s'", objName),
StartPosition: &storepb.Position{
Line: int32(line),
@@ -243,7 +302,7 @@ func (c *fullyQualifiedObjectNameChecker) checkQualifiedName(ctx parser.IQualifi
}
// checkAnyName checks if an any_name is fully qualified
-func (c *fullyQualifiedObjectNameChecker) checkAnyName(ctx parser.IAny_nameContext, line int) {
+func (r *fullyQualifiedObjectNameRule) checkAnyName(ctx parser.IAny_nameContext, line int) {
if ctx == nil {
return
}
@@ -252,11 +311,11 @@ func (c *fullyQualifiedObjectNameChecker) checkAnyName(ctx parser.IAny_nameConte
parts := pgparser.NormalizePostgreSQLAnyName(ctx)
objName := strings.Join(parts, ".")
- if !c.isFullyQualified(objName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if !r.isFullyQualified(objName) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: int32(advisor.NamingNotFullyQualifiedName),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("unqualified object name: '%s'", objName),
StartPosition: &storepb.Position{
Line: int32(line),
@@ -267,7 +326,7 @@ func (c *fullyQualifiedObjectNameChecker) checkAnyName(ctx parser.IAny_nameConte
}
// isFullyQualified checks if an object name is fully qualified (contains a dot)
-func (*fullyQualifiedObjectNameChecker) isFullyQualified(objName string) bool {
+func (*fullyQualifiedObjectNameRule) isFullyQualified(objName string) bool {
if objName == "" {
return true
}
@@ -276,7 +335,7 @@ func (*fullyQualifiedObjectNameChecker) isFullyQualified(objName string) bool {
}
// findAllTablesInSelect finds all table references in a SELECT statement
-func (c *fullyQualifiedObjectNameChecker) findAllTablesInSelect(statement string) []base.ColumnResource {
+func (r *fullyQualifiedObjectNameRule) findAllTablesInSelect(statement string) []base.ColumnResource {
// Parse the statement to extract table references
result, err := pgparser.ParsePostgreSQL(statement)
if err != nil {
@@ -285,7 +344,7 @@ func (c *fullyQualifiedObjectNameChecker) findAllTablesInSelect(statement string
// Use a visitor to find all table references
collector := &tableReferenceCollector{
- schemaNameMap: c.getSchemaNameMapFromPublic(),
+ schemaNameMap: r.getSchemaNameMapFromPublic(),
}
if result.Tree != nil {
@@ -296,13 +355,13 @@ func (c *fullyQualifiedObjectNameChecker) findAllTablesInSelect(statement string
}
// getSchemaNameMapFromPublic creates a map of table names from the database schema
-func (c *fullyQualifiedObjectNameChecker) getSchemaNameMapFromPublic() map[string]bool {
- if c.dbSchema == nil || c.dbSchema.Schemas == nil {
+func (r *fullyQualifiedObjectNameRule) getSchemaNameMapFromPublic() map[string]bool {
+ if r.dbSchema == nil || r.dbSchema.Schemas == nil {
return nil
}
filterMap := map[string]bool{}
- for _, schema := range c.dbSchema.Schemas {
+ for _, schema := range r.dbSchema.Schemas {
// Tables
for _, tbl := range schema.Tables {
filterMap[tbl.Name] = true
diff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.go
index 65a5170bd1..f4e0d66873 100644
--- a/backend/plugin/advisor/pg/advisor_naming_index_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_index_convention.go
@@ -44,48 +44,74 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.C
return nil, err
}
- checker := &namingIndexConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- format: format,
- maxLength: maxLength,
- templateList: templateList,
- catalog: checkCtx.Catalog,
- }
-
+ rule := &namingIndexConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ catalog: checkCtx.Catalog,
+ }
+
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type namingIndexConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type namingIndexConventionRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
format string
maxLength int
templateList []string
catalog *catalog.Finder
}
-// EnterIndexstmt checks CREATE INDEX statements
-func (c *namingIndexConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// Name returns the rule name.
+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)
+ 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()) {
return
}
// Check if this is a UNIQUE index - if so, skip it
- if ctx.Opt_unique() != nil && ctx.Opt_unique().UNIQUE() != nil {
+ if indexstmtCtx.Opt_unique() != nil && indexstmtCtx.Opt_unique().UNIQUE() != nil {
return
}
// Get index name
indexName := ""
- if ctx.Name() != nil {
- indexName = pgparser.NormalizePostgreSQLName(ctx.Name())
+ if indexstmtCtx.Name() != nil {
+ indexName = pgparser.NormalizePostgreSQLName(indexstmtCtx.Name())
}
if indexName == "" {
return
@@ -93,8 +119,8 @@ func (c *namingIndexConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtConte
// Get table name
tableName := ""
- if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
- tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ if indexstmtCtx.Relation_expr() != nil && indexstmtCtx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(indexstmtCtx.Relation_expr().Qualified_name())
}
if tableName == "" {
return
@@ -102,8 +128,8 @@ func (c *namingIndexConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtConte
// Get column list
var columnList []string
- if ctx.Index_params() != nil {
- allParams := ctx.Index_params().AllIndex_elem()
+ if indexstmtCtx.Index_params() != nil {
+ allParams := indexstmtCtx.Index_params().AllIndex_elem()
for _, param := range allParams {
if param.Colid() != nil {
colName := pgparser.NormalizePostgreSQLColid(param.Colid())
@@ -112,26 +138,30 @@ func (c *namingIndexConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtConte
}
}
- c.checkIndexName(indexName, tableName, columnList, ctx.GetStart().GetLine())
+ r.checkIndexName(indexName, tableName, columnList, indexstmtCtx.GetStart().GetLine())
}
-// EnterRenamestmt checks ALTER INDEX ... RENAME TO statements
-func (c *namingIndexConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// 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 ctx.INDEX() != nil && ctx.TO() != nil {
- allNames := ctx.AllName()
+ if renamestmtCtx.INDEX() != nil && renamestmtCtx.TO() != nil {
+ allNames := renamestmtCtx.AllName()
if len(allNames) < 1 {
return
}
// Get old index name from qualified_name
var oldIndexName string
- if ctx.Qualified_name() != nil {
- parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Qualified_name())
+ if renamestmtCtx.Qualified_name() != nil {
+ parts := pgparser.NormalizePostgreSQLQualifiedName(renamestmtCtx.Qualified_name())
if len(parts) > 0 {
oldIndexName = parts[len(parts)-1]
}
@@ -141,28 +171,28 @@ func (c *namingIndexConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtCon
newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])
// Look up the index in catalog to determine if it's a regular index (not unique, not PK)
- if c.catalog != nil && oldIndexName != "" {
- tableName, index := c.findIndex("", "", oldIndexName)
+ if r.catalog != nil && oldIndexName != "" {
+ tableName, index := r.findIndex("", "", oldIndexName)
if index != nil {
// Only check if it's a regular index (not unique, not primary)
if !index.Unique() && !index.Primary() {
- c.checkIndexName(newIndexName, tableName, index.ExpressionList(), ctx.GetStart().GetLine())
+ r.checkIndexName(newIndexName, tableName, index.ExpressionList(), renamestmtCtx.GetStart().GetLine())
}
}
}
}
}
-func (c *namingIndexConventionChecker) checkIndexName(indexName, tableName string, columnList []string, line int) {
+func (r *namingIndexConventionRule) checkIndexName(indexName, tableName string, columnList []string, line int) {
metaData := map[string]string{
advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
advisor.TableNameTemplateToken: tableName,
}
- regex, err := getTemplateRegexp(c.format, c.templateList, metaData)
+ regex, err := getTemplateRegexp(r.format, r.templateList, metaData)
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.Internal.Int32(),
Title: "Internal error for index naming convention rule",
Content: fmt.Sprintf("Failed to compile regex: %v", err),
@@ -175,10 +205,10 @@ func (c *namingIndexConventionChecker) checkIndexName(indexName, tableName strin
}
if !regex.MatchString(indexName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingIndexConventionMismatch.Int32(),
- Title: c.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),
@@ -187,12 +217,12 @@ func (c *namingIndexConventionChecker) checkIndexName(indexName, tableName strin
})
}
- if c.maxLength > 0 && len(indexName) > c.maxLength {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.maxLength > 0 && len(indexName) > r.maxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingIndexConventionMismatch.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("Index %q in table %q mismatches the naming convention, its length should be within %d characters", indexName, tableName, c.maxLength),
+ 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),
Column: 0,
@@ -202,11 +232,11 @@ func (c *namingIndexConventionChecker) checkIndexName(indexName, tableName strin
}
// findIndex returns index found in catalogs, nil if not found.
-func (c *namingIndexConventionChecker) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {
- if c.catalog == nil {
+func (r *namingIndexConventionRule) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {
+ if r.catalog == nil {
return "", nil
}
- return c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ return r.catalog.Origin.FindIndex(&catalog.IndexFind{
SchemaName: normalizeSchemaName(schemaName),
TableName: tableName,
IndexName: indexName,
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 6b3d7039b9..d1c840f280 100644
--- a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
@@ -44,28 +44,28 @@ func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont
return nil, err
}
- checker := &namingPKConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- format: format,
- maxLength: maxLength,
- templateList: templateList,
- catalog: checkCtx.Catalog,
- statementsText: checkCtx.Statements,
+ rule := &namingPKConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ catalog: checkCtx.Catalog,
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type namingPKConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type namingPKConventionRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
format string
maxLength int
templateList []string
@@ -81,8 +81,30 @@ type pkMetaData struct {
metaData map[string]string
}
-// EnterCreatestmt handles CREATE TABLE with PRIMARY KEY constraints
-func (c *namingPKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+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))
+ 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
}
@@ -104,8 +126,8 @@ func (c *namingPKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContex
// Check table-level PRIMARY KEY constraint
if elem.Tableconstraint() != nil {
constraint := elem.Tableconstraint()
- if pkData := c.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {
- c.checkPKName(pkData)
+ if pkData := r.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {
+ r.checkPKName(pkData)
}
}
@@ -115,8 +137,8 @@ func (c *namingPKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContex
}
}
-// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT PRIMARY KEY
-func (c *namingPKConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+// handleAltertablestmt handles ALTER TABLE ADD CONSTRAINT PRIMARY KEY
+func (r *namingPKConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -137,16 +159,16 @@ func (c *namingPKConventionChecker) EnterAltertablestmt(ctx *parser.Altertablest
// ADD CONSTRAINT
if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
constraint := cmd.Tableconstraint()
- if pkData := c.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {
- c.checkPKName(pkData)
+ if pkData := r.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {
+ r.checkPKName(pkData)
}
}
}
}
}
-// EnterRenamestmt handles ALTER TABLE RENAME CONSTRAINT and ALTER INDEX RENAME TO
-func (c *namingPKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+// handleRenamestmt handles ALTER TABLE RENAME CONSTRAINT and ALTER INDEX RENAME TO
+func (r *namingPKConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -168,12 +190,12 @@ func (c *namingPKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContex
newName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])
// Check if old constraint is a primary key using catalog
- if c.catalog != nil {
+ if r.catalog != nil {
normalizedSchema := schemaName
if normalizedSchema == "" {
normalizedSchema = "public"
}
- _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ _, index := r.catalog.Origin.FindIndex(&catalog.IndexFind{
SchemaName: normalizedSchema,
TableName: tableName,
IndexName: oldName,
@@ -190,7 +212,7 @@ func (c *namingPKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContex
line: ctx.GetStart().GetLine(),
metaData: metaData,
}
- c.checkPKName(pkData)
+ r.checkPKName(pkData)
}
}
}
@@ -215,13 +237,13 @@ func (c *namingPKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContex
newIndexName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])
// Check if this index is a primary key using catalog
- if c.catalog != nil {
+ if r.catalog != nil {
normalizedSchema := schemaName
if normalizedSchema == "" {
normalizedSchema = "public"
}
// "ALTER INDEX name RENAME TO new_name" doesn't specify table name
- tableName, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ tableName, index := r.catalog.Origin.FindIndex(&catalog.IndexFind{
SchemaName: normalizedSchema,
TableName: "", // Empty table name for ALTER INDEX
IndexName: oldIndexName,
@@ -238,14 +260,14 @@ func (c *namingPKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContex
line: ctx.GetStart().GetLine(),
metaData: metaData,
}
- c.checkPKName(pkData)
+ r.checkPKName(pkData)
}
}
}
}
}
-func (c *namingPKConventionChecker) getPKMetaDataFromTableConstraint(constraint parser.ITableconstraintContext, tableName, schemaName string, line int) *pkMetaData {
+func (r *namingPKConventionRule) getPKMetaDataFromTableConstraint(constraint parser.ITableconstraintContext, tableName, schemaName string, line int) *pkMetaData {
if constraint == nil || constraint.Constraintelem() == nil {
return nil
}
@@ -291,12 +313,12 @@ func (c *namingPKConventionChecker) getPKMetaDataFromTableConstraint(constraint
// Extract index name properly
indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())
// Find the index in catalog to get column list
- if c.catalog != nil && indexName != "" {
+ if r.catalog != nil && indexName != "" {
normalizedSchema := schemaName
if normalizedSchema == "" {
normalizedSchema = "public"
}
- _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ _, index := r.catalog.Origin.FindIndex(&catalog.IndexFind{
SchemaName: normalizedSchema,
TableName: tableName,
IndexName: indexName,
@@ -325,11 +347,11 @@ func (c *namingPKConventionChecker) getPKMetaDataFromTableConstraint(constraint
return nil
}
-func (c *namingPKConventionChecker) checkPKName(pkData *pkMetaData) {
- regex, err := getTemplateRegexp(c.format, c.templateList, pkData.metaData)
+func (r *namingPKConventionRule) checkPKName(pkData *pkMetaData) {
+ regex, err := getTemplateRegexp(r.format, r.templateList, pkData.metaData)
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.Internal.Int32(),
Title: "Internal error for primary key naming convention rule",
Content: fmt.Sprintf("Failed to compile regex: %v", err),
@@ -342,10 +364,10 @@ func (c *namingPKConventionChecker) checkPKName(pkData *pkMetaData) {
}
if !regex.MatchString(pkData.pkName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingPKConventionMismatch.Int32(),
- Title: c.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),
@@ -354,12 +376,12 @@ func (c *namingPKConventionChecker) checkPKName(pkData *pkMetaData) {
})
}
- if c.maxLength > 0 && len(pkData.pkName) > c.maxLength {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.maxLength > 0 && len(pkData.pkName) > r.maxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingPKConventionMismatch.Int32(),
- Title: c.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, c.maxLength),
+ 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),
Column: 0,
diff --git a/backend/plugin/advisor/pg/advisor_naming_table.go b/backend/plugin/advisor/pg/advisor_naming_table.go
index c8331bd414..11d0c48ca6 100644
--- a/backend/plugin/advisor/pg/advisor_naming_table.go
+++ b/backend/plugin/advisor/pg/advisor_naming_table.go
@@ -43,31 +43,50 @@ func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.C
return nil, err
}
- checker := &namingTableConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- format: format,
- maxLength: maxLength,
+ rule := &namingTableConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ format: format,
+ maxLength: maxLength,
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
+}
+
+type namingTableConventionRule struct {
+ BaseRule
+
+ format *regexp.Regexp
+ maxLength int
}
-type namingTableConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+func (*namingTableConventionRule) Name() string {
+ return string(advisor.SchemaRuleTableNaming)
+}
+
+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
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- format *regexp.Regexp
- maxLength int
+func (*namingTableConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-// EnterCreatestmt handles CREATE TABLE
-func (c *namingTableConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+// handleCreatestmt handles CREATE TABLE
+func (r *namingTableConventionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -75,12 +94,12 @@ func (c *namingTableConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtCon
allQualifiedNames := ctx.AllQualified_name()
if len(allQualifiedNames) > 0 {
tableName := extractTableName(allQualifiedNames[0])
- c.checkTableName(tableName, ctx)
+ r.checkTableName(tableName, ctx)
}
}
-// EnterRenamestmt handles ALTER TABLE RENAME TO
-func (c *namingTableConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+// handleRenamestmt handles ALTER TABLE RENAME TO
+func (r *namingTableConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -91,30 +110,30 @@ func (c *namingTableConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtCon
if len(allNames) > 0 {
// The new table name is the last Name() in RENAME TO new_name
newTableName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])
- c.checkTableName(newTableName, ctx)
+ r.checkTableName(newTableName, ctx)
}
}
}
-func (c *namingTableConventionChecker) checkTableName(tableName string, ctx antlr.ParserRuleContext) {
- if !c.format.MatchString(tableName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+func (r *namingTableConventionRule) checkTableName(tableName string, ctx antlr.ParserRuleContext) {
+ if !r.format.MatchString(tableName) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingTableConventionMismatch.Int32(),
- Title: c.title,
- Content: fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, c.format),
+ 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()),
Column: 0,
},
})
}
- if c.maxLength > 0 && len(tableName) > c.maxLength {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.maxLength > 0 && len(tableName) > r.maxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingTableConventionMismatch.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, c.maxLength),
+ 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()),
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 da9d664807..b75861d7dc 100644
--- a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
@@ -44,27 +44,26 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Cont
return nil, err
}
- checker := &namingUKConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- format: format,
- maxLength: maxLength,
- templateList: templateList,
- catalog: checkCtx.Catalog,
- }
-
+ rule := &namingUKConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ catalog: checkCtx.Catalog,
+ }
+
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type namingUKConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type namingUKConventionRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
format string
maxLength int
templateList []string
@@ -79,8 +78,32 @@ type indexMetaData struct {
metaData map[string]string
}
-// EnterIndexstmt handles CREATE UNIQUE INDEX statements
-func (c *namingUKConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+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))
+ 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
}
@@ -117,11 +140,11 @@ func (c *namingUKConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtContext)
advisor.TableNameTemplateToken: tableName,
}
- c.checkUniqueKeyName(indexName, tableName, metaData, ctx.GetStart().GetLine())
+ r.checkUniqueKeyName(indexName, tableName, metaData, ctx.GetStart().GetLine())
}
-// EnterCreatestmt handles CREATE TABLE with UNIQUE constraints
-func (c *namingUKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+// handleCreatestmt handles CREATE TABLE with UNIQUE constraints
+func (r *namingUKConventionRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -141,18 +164,18 @@ func (c *namingUKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContex
allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
for _, elem := range allElements {
if elem.Tableconstraint() != nil {
- c.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())
+ r.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())
}
// Check column-level constraints
if elem.ColumnDef() != nil {
- c.checkColumnDef(elem.ColumnDef(), tableName)
+ r.checkColumnDef(elem.ColumnDef(), tableName)
}
}
}
}
-// EnterAltertablestmt handles ALTER TABLE statements
-func (c *namingUKConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+// handleAltertablestmt handles ALTER TABLE statements
+func (r *namingUKConventionRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -171,22 +194,22 @@ func (c *namingUKConventionChecker) EnterAltertablestmt(ctx *parser.Altertablest
for _, cmd := range allCmds {
// ADD CONSTRAINT
if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
- c.checkTableConstraint(cmd.Tableconstraint(), tableName, ctx.GetStart().GetLine())
+ r.checkTableConstraint(cmd.Tableconstraint(), tableName, ctx.GetStart().GetLine())
}
// ADD COLUMN with constraints
if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
- c.checkColumnDef(cmd.ColumnDef(), tableName)
+ r.checkColumnDef(cmd.ColumnDef(), tableName)
}
}
}
- // Note: ALTER TABLE ... RENAME CONSTRAINT is handled in EnterRenamestmt
+ // 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
}
-// EnterRenamestmt handles ALTER INDEX ... RENAME TO and ALTER TABLE ... RENAME CONSTRAINT statements
-func (c *namingUKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+// handleRenamestmt handles ALTER INDEX ... RENAME TO and ALTER TABLE ... RENAME CONSTRAINT statements
+func (r *namingUKConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -211,10 +234,10 @@ func (c *namingUKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContex
newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])
// Look up the index in catalog to determine if it's a unique key
- if c.catalog != nil && oldIndexName != "" {
- tableName, index := c.findIndex("", "", oldIndexName)
+ if r.catalog != nil && oldIndexName != "" {
+ tableName, index := r.findIndex("", "", oldIndexName)
if index != nil && index.Unique() && !index.Primary() {
- c.checkUniqueKeyName(newIndexName, tableName, map[string]string{
+ r.checkUniqueKeyName(newIndexName, tableName, map[string]string{
advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),
advisor.TableNameTemplateToken: tableName,
}, ctx.GetStart().GetLine())
@@ -223,7 +246,7 @@ func (c *namingUKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContex
}
// Check for ALTER TABLE ... RENAME CONSTRAINT
- if ctx.CONSTRAINT() != nil && ctx.TO() != nil && c.catalog != nil {
+ if ctx.CONSTRAINT() != nil && ctx.TO() != nil && r.catalog != nil {
allNames := ctx.AllName()
if len(allNames) >= 2 {
oldConstraintName := pgparser.NormalizePostgreSQLName(allNames[0])
@@ -237,19 +260,19 @@ func (c *namingUKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContex
}
// Check if this is a unique key constraint in catalog
- foundTableName, index := c.findIndex(schemaName, tableName, oldConstraintName)
+ foundTableName, index := r.findIndex(schemaName, tableName, oldConstraintName)
if index != nil && index.Unique() && !index.Primary() {
metaData := map[string]string{
advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),
advisor.TableNameTemplateToken: foundTableName,
}
- c.checkUniqueKeyName(newConstraintName, foundTableName, metaData, ctx.GetStart().GetLine())
+ r.checkUniqueKeyName(newConstraintName, foundTableName, metaData, ctx.GetStart().GetLine())
}
}
}
}
-func (c *namingUKConventionChecker) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {
+func (r *namingUKConventionRule) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {
if constraint == nil {
return
}
@@ -276,7 +299,7 @@ func (c *namingUKConventionChecker) checkTableConstraint(constraint parser.ITabl
} 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())
- foundTableName, index := c.findIndex("", tableName, indexName)
+ foundTableName, index := r.findIndex("", tableName, indexName)
if index != nil {
columnList = index.ExpressionList()
tableName = foundTableName
@@ -289,13 +312,13 @@ func (c *namingUKConventionChecker) checkTableConstraint(constraint parser.ITabl
advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
advisor.TableNameTemplateToken: tableName,
}
- c.checkUniqueKeyName(constraintName, tableName, metaData, line)
+ r.checkUniqueKeyName(constraintName, tableName, metaData, line)
}
}
}
}
-func (c *namingUKConventionChecker) checkColumnDef(columndef parser.IColumnDefContext, tableName string) {
+func (r *namingUKConventionRule) checkColumnDef(columndef parser.IColumnDefContext, tableName string) {
if columndef == nil {
return
}
@@ -325,7 +348,7 @@ func (c *namingUKConventionChecker) checkColumnDef(columndef parser.IColumnDefCo
advisor.ColumnListTemplateToken: colName,
advisor.TableNameTemplateToken: tableName,
}
- c.checkUniqueKeyName(constraintName, tableName, metaData, qual.GetStart().GetLine())
+ r.checkUniqueKeyName(constraintName, tableName, metaData, qual.GetStart().GetLine())
}
}
}
@@ -333,11 +356,11 @@ func (c *namingUKConventionChecker) checkColumnDef(columndef parser.IColumnDefCo
}
}
-func (c *namingUKConventionChecker) checkUniqueKeyName(indexName, tableName string, metaData map[string]string, line int) {
- regex, err := c.getTemplateRegexp(metaData)
+func (r *namingUKConventionRule) checkUniqueKeyName(indexName, tableName string, metaData map[string]string, line int) {
+ regex, err := r.getTemplateRegexp(metaData)
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.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),
@@ -346,10 +369,10 @@ func (c *namingUKConventionChecker) checkUniqueKeyName(indexName, tableName stri
}
if !regex.MatchString(indexName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingUKConventionMismatch.Int32(),
- Title: c.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),
@@ -358,12 +381,12 @@ func (c *namingUKConventionChecker) checkUniqueKeyName(indexName, tableName stri
})
}
- if c.maxLength > 0 && len(indexName) > c.maxLength {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.maxLength > 0 && len(indexName) > r.maxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.NamingUKConventionMismatch.Int32(),
- Title: c.title,
- Content: fmt.Sprintf(`Unique key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, indexName, tableName, c.maxLength),
+ 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),
Column: 0,
@@ -372,9 +395,9 @@ func (c *namingUKConventionChecker) checkUniqueKeyName(indexName, tableName stri
}
}
-func (c *namingUKConventionChecker) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {
- template := c.format
- for _, key := range c.templateList {
+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)
}
@@ -383,11 +406,11 @@ func (c *namingUKConventionChecker) getTemplateRegexp(tokens map[string]string)
}
// findIndex returns index found in catalogs, nil if not found.
-func (c *namingUKConventionChecker) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {
- if c.catalog == nil {
+func (r *namingUKConventionRule) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {
+ if r.catalog == nil {
return "", nil
}
- return c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ return r.catalog.Origin.FindIndex(&catalog.IndexFind{
SchemaName: normalizeSchemaName(schemaName),
TableName: tableName,
IndexName: indexName,
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 76a9afe629..67f7cc4d45 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
@@ -35,30 +35,53 @@ func (*StatementAddCheckNotValidAdvisor) Check(_ context.Context, checkCtx advis
return nil, err
}
- checker := &statementAddCheckNotValidChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &statementAddCheckNotValidRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
+}
+
+type statementAddCheckNotValidRule struct {
+ BaseRule
}
-type statementAddCheckNotValidChecker struct {
- *parser.BasePostgreSQLParserListener
+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
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+func (*statementAddCheckNotValidRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-// EnterColconstraint handles column-level constraints in ALTER TABLE ADD CONSTRAINT ... CHECK
+// 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 (c *statementAddCheckNotValidChecker) EnterColconstraint(ctx *parser.ColconstraintContext) {
+func (r *statementAddCheckNotValidRule) handleColconstraint(ctx antlr.ParserRuleContext) {
+ colCtx, ok := ctx.(*parser.ColconstraintContext)
+ if !ok {
+ return
+ }
+
// Check if this is within an ALTER TABLE statement
- parent := ctx.GetParent()
+ parent := colCtx.GetParent()
var alterTableCtx *parser.AltertablestmtContext
for parent != nil {
if altCtx, ok := parent.(*parser.AltertablestmtContext); ok {
@@ -77,16 +100,16 @@ func (c *statementAddCheckNotValidChecker) EnterColconstraint(ctx *parser.Colcon
}
// Check if this is a CHECK constraint
- if ctx.Colconstraintelem() != nil {
- constraintElem := ctx.Colconstraintelem()
+ 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)
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementAddCheckWithValidation.Int32(),
- Title: c.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()),
@@ -97,11 +120,16 @@ func (c *statementAddCheckNotValidChecker) EnterColconstraint(ctx *parser.Colcon
}
}
-// EnterTableconstraint handles table-level constraints in ALTER TABLE ADD CONSTRAINT ... CHECK
+// 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 (c *statementAddCheckNotValidChecker) EnterTableconstraint(ctx *parser.TableconstraintContext) {
+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 := ctx.GetParent()
+ parent := tableCtx.GetParent()
var alterTableCtx *parser.AltertablestmtContext
for parent != nil {
if altCtx, ok := parent.(*parser.AltertablestmtContext); ok {
@@ -120,8 +148,8 @@ func (c *statementAddCheckNotValidChecker) EnterTableconstraint(ctx *parser.Tabl
}
// Check if this is a CHECK constraint
- if ctx.Constraintelem() != nil {
- constraintElem := ctx.Constraintelem()
+ if tableCtx.Constraintelem() != nil {
+ constraintElem := tableCtx.Constraintelem()
if constraintElem.CHECK() != nil {
// Check if NOT VALID is specified
hasNotValid := false
@@ -137,10 +165,10 @@ func (c *statementAddCheckNotValidChecker) EnterTableconstraint(ctx *parser.Tabl
}
if !hasNotValid {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementAddCheckWithValidation.Int32(),
- Title: c.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()),
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 0038d45808..29c299dd1a 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
@@ -35,36 +35,56 @@ func (*StatementAddFKNotValidAdvisor) Check(_ context.Context, checkCtx advisor.
return nil, err
}
- checker := &statementAddFKNotValidChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &statementAddFKNotValidRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementAddFKNotValidChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementAddFKNotValidRule struct {
+ BaseRule
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+func (*statementAddFKNotValidRule) Name() string {
+ return "statement_add_fk_not_valid"
}
-// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT FOREIGN KEY
-func (c *statementAddFKNotValidChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+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)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(altertablestmtCtx.GetParent()) {
return
}
- if ctx.Alter_table_cmds() == nil {
+ if altertablestmtCtx.Alter_table_cmds() == nil {
return
}
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ allCmds := altertablestmtCtx.Alter_table_cmds().AllAlter_table_cmd()
for _, cmd := range allCmds {
// Check for ADD + something
if cmd.ADD_P() == nil {
@@ -102,13 +122,13 @@ func (c *statementAddFKNotValidChecker) EnterAltertablestmt(ctx *parser.Altertab
// If NOT VALID is not present, this is a problem
if !hasNotValid {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementAddFKWithValidation.Int32(),
- Title: c.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(ctx.GetStart().GetLine()),
+ Line: int32(altertablestmtCtx.GetStart().GetLine()),
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 0704312767..25f57d0f8b 100644
--- a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
+++ b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
@@ -43,31 +43,30 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx adv
return nil, err
}
- checker := &statementAffectedRowLimitChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- maxRow: payload.Number,
- ctx: ctx,
- driver: checkCtx.Driver,
- usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
- statementsText: checkCtx.Statements,
+ rule := &statementAffectedRowLimitRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ maxRow: payload.Number,
+ ctx: ctx,
+ driver: checkCtx.Driver,
+ usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
+ statementsText: checkCtx.Statements,
}
- // Only run EXPLAIN queries if we have a limit and database connection
- if payload.Number > 0 && checker.driver != nil {
+ if payload.Number > 0 && checkCtx.Driver != nil {
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ return checker.GetAdviceList(), nil
}
- return checker.adviceList, nil
+ return nil, nil
}
-type statementAffectedRowLimitChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementAffectedRowLimitRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
maxRow int
driver *sql.DB
ctx context.Context
@@ -77,8 +76,35 @@ type statementAffectedRowLimitChecker struct {
statementsText string
}
-// EnterVariablesetstmt handles SET ROLE statements
-func (c *statementAffectedRowLimitChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+func (*statementAffectedRowLimitRule) Name() string {
+ return "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)
+ }
+ 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
}
@@ -88,53 +114,51 @@ func (c *statementAffectedRowLimitChecker) EnterVariablesetstmt(ctx *parser.Vari
setRestMore := ctx.Set_rest().Set_rest_more()
if setRestMore.ROLE() != nil {
// Store the SET ROLE statement text
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.setRoles = append(c.setRoles, stmtText)
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ r.setRoles = append(r.setRoles, stmtText)
}
}
}
-// EnterUpdatestmt handles UPDATE statements
-func (c *statementAffectedRowLimitChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+func (r *statementAffectedRowLimitRule) handleUpdatestmt(ctx *parser.UpdatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.checkAffectedRows(ctx)
+ r.checkAffectedRows(ctx)
}
-// EnterDeletestmt handles DELETE statements
-func (c *statementAffectedRowLimitChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {
+func (r *statementAffectedRowLimitRule) handleDeletestmt(ctx *parser.DeletestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.checkAffectedRows(ctx)
+ r.checkAffectedRows(ctx)
}
-func (c *statementAffectedRowLimitChecker) checkAffectedRows(ctx antlr.ParserRuleContext) {
+func (r *statementAffectedRowLimitRule) checkAffectedRows(ctx antlr.ParserRuleContext) {
// Check if we've hit the maximum number of EXPLAIN queries
- if c.explainCount >= common.MaximumLintExplainSize {
+ if r.explainCount >= common.MaximumLintExplainSize {
return
}
- c.explainCount++
+ r.explainCount++
// Get the statement text
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
normalizedStmt := advisor.NormalizeStatement(stmtText)
// Run EXPLAIN to get estimated row count
- res, err := advisor.Query(c.ctx, advisor.QueryContext{
- UsePostgresDatabaseOwner: c.usePostgresDatabaseOwner,
- PreExecutions: c.setRoles,
- }, c.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))
+ res, err := advisor.Query(r.ctx, advisor.QueryContext{
+ UsePostgresDatabaseOwner: r.usePostgresDatabaseOwner,
+ PreExecutions: r.setRoles,
+ }, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.InsertTooManyRows.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" dry runs failed: %s", normalizedStmt, err.Error()),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -146,10 +170,10 @@ func (c *statementAffectedRowLimitChecker) checkAffectedRows(ctx antlr.ParserRul
rowCount, err := getAffectedRows(res)
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.Internal.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("failed to get row count for \"%s\": %s", normalizedStmt, err.Error()),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -159,12 +183,12 @@ func (c *statementAffectedRowLimitChecker) checkAffectedRows(ctx antlr.ParserRul
return
}
- if rowCount > int64(c.maxRow) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if rowCount > int64(r.maxRow) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementAffectedRowExceedsLimit.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("The statement \"%s\" affected %d rows (estimated). The count exceeds %d.", normalizedStmt, rowCount, c.maxRow),
+ Title: r.title,
+ Content: fmt.Sprintf("The statement \"%s\" affected %d rows (estimated). The count exceeds %d.", normalizedStmt, rowCount, r.maxRow),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
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 cf8d368c66..73abaec079 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
@@ -33,44 +33,65 @@ func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.
return nil, err
}
- checker := &statementCheckSetRoleVariableChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &StatementCheckSetRoleVariableRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- if !checker.hasSetRole {
- return []*storepb.Advice{{
+ if !rule.hasSetRole {
+ rule.AddAdvice(&storepb.Advice{
Status: level,
Code: advisor.StatementCheckSetRoleVariable.Int32(),
- Title: checker.title,
+ Title: rule.title,
Content: "No SET ROLE statement found.",
StartPosition: nil,
- }}, nil
+ })
}
- return nil, nil
+ return checker.GetAdviceList(), nil
}
-type statementCheckSetRoleVariableChecker struct {
- *parser.BasePostgreSQLParserListener
+type StatementCheckSetRoleVariableRule struct {
+ BaseRule
- level storepb.Advice_Status
- title string
hasSetRole bool
foundNonSetStmt bool
}
-// EnterVariablesetstmt handles SET statements
-func (c *statementCheckSetRoleVariableChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+// Name returns the rule name.
+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 c.foundNonSetStmt {
+ if r.foundNonSetStmt {
return
}
@@ -79,19 +100,19 @@ func (c *statementCheckSetRoleVariableChecker) EnterVariablesetstmt(ctx *parser.
if setRest != nil {
setRestMore := setRest.Set_rest_more()
if setRestMore != nil && setRestMore.ROLE() != nil {
- c.hasSetRole = true
+ r.hasSetRole = true
}
}
}
-// EnterEveryRule is called for every rule entry to detect non-SET statements
-func (c *statementCheckSetRoleVariableChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
+// 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 c.foundNonSetStmt {
+ if r.foundNonSetStmt {
return
}
@@ -105,7 +126,7 @@ func (c *statementCheckSetRoleVariableChecker) EnterEveryRule(ctx antlr.ParserRu
return
default:
// This is a non-SET statement
- c.foundNonSetStmt = true
+ 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 5630600ffb..a43eeb1773 100644
--- a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go
+++ b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go
@@ -33,42 +33,63 @@ func (*StatementCreateSpecifySchema) Check(_ context.Context, checkCtx advisor.C
return nil, err
}
- checker := &statementCreateSpecifySchemaChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &statementCreateSpecifySchemaRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementCreateSpecifySchemaChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementCreateSpecifySchemaRule struct {
+ BaseRule
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+func (*statementCreateSpecifySchemaRule) Name() string {
+ return "statement_create_specify_schema"
}
-// EnterCreatestmt handles CREATE TABLE
-func (c *statementCreateSpecifySchemaChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+func (r *statementCreateSpecifySchemaRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {
+ switch nodeType {
+ case "Createstmt":
+ r.handleCreatestmt(ctx)
+ 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 := ctx.AllQualified_name()
+ allQualifiedNames := createstmtCtx.AllQualified_name()
if len(allQualifiedNames) > 0 {
schemaName := extractSchemaName(allQualifiedNames[0])
if schemaName == "" {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementCreateWithoutSchemaName.Int32(),
- Title: c.title,
+ Title: r.title,
Content: "Table schema should be specified.",
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(createstmtCtx.GetStart().GetLine()),
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 3a01bf703c..b8d0e79afd 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
@@ -35,27 +35,45 @@ func (*StatementDisallowAddColumnWithDefaultAdvisor) Check(_ context.Context, ch
return nil, err
}
- checker := &statementDisallowAddColumnWithDefaultChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &statementDisallowAddColumnWithDefaultRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementDisallowAddColumnWithDefaultChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementDisallowAddColumnWithDefaultRule struct {
+ BaseRule
+}
+
+// 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
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+// OnExit is called when the parser exits a rule context.
+func (*statementDisallowAddColumnWithDefaultRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-// EnterAltertablestmt handles ALTER TABLE ADD COLUMN
-func (c *statementDisallowAddColumnWithDefaultChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *statementDisallowAddColumnWithDefaultRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -75,10 +93,10 @@ func (c *statementDisallowAddColumnWithDefaultChecker) EnterAltertablestmt(ctx *
constraintElem := constraint.Colconstraintelem()
// Check for DEFAULT constraint
if constraintElem.DEFAULT() != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementAddColumnWithDefault.Int32(),
- Title: c.title,
+ 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()),
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 cd39c59c63..9c11a37cff 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
@@ -37,34 +37,55 @@ func (*StatementDisallowAddNotNullAdvisor) Check(_ context.Context, checkCtx adv
return nil, err
}
- checker := &statementDisallowAddNotNullChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &statementDisallowAddNotNullRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementDisallowAddNotNullChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementDisallowAddNotNullRule struct {
+ BaseRule
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+func (*statementDisallowAddNotNullRule) Name() string {
+ return "statement_disallow_add_not_null"
}
-// EnterAltertablestmt handles ALTER TABLE ALTER COLUMN SET NOT NULL
-func (c *statementDisallowAddNotNullChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+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)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(altertablestmtCtx.GetParent()) {
return
}
// Check all alter table commands
- if ctx.Alter_table_cmds() != nil {
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ 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 {
@@ -72,13 +93,13 @@ func (c *statementDisallowAddNotNullChecker) EnterAltertablestmt(ctx *parser.Alt
allColIDs := cmd.AllColid()
if len(allColIDs) > 0 {
columnName := pgparser.NormalizePostgreSQLColid(allColIDs[0])
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementAddNotNull.Int32(),
- Title: c.title,
+ 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(ctx.GetStart().GetLine()),
+ Line: int32(altertablestmtCtx.GetStart().GetLine()),
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 5b15aa691a..7139d528b4 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go
@@ -36,47 +36,64 @@ func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor
return nil, err
}
- checker := &statementDisallowCommitChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &statementDisallowCommitRule{
+ BaseRule: BaseRule{level: level, title: string(checkCtx.Rule.Type)},
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementDisallowCommitChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementDisallowCommitRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
statementsText string
}
-// EnterTransactionstmt handles COMMIT statements
-func (c *statementDisallowCommitChecker) EnterTransactionstmt(ctx *parser.TransactionstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
- return
+// 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)
+ if !ok {
+ return nil
+ }
+
+ if !isTopLevel(transactionCtx.GetParent()) {
+ return nil
}
// Check if this is a COMMIT statement
- if ctx.COMMIT() == nil {
- return
+ if transactionCtx.COMMIT() == nil {
+ return nil
}
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, transactionCtx.GetStart().GetLine(), transactionCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementDisallowCommit.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Commit is not allowed, related statement: \"%s\"", stmtText),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(transactionCtx.GetStart().GetLine()),
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_mix_in_ddl.go b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go
index 4874cb19e1..81037ecb99 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go
@@ -6,8 +6,6 @@ import (
"github.com/antlr4-go/antlr/v4"
- parser "github.com/bytebase/parser/postgresql"
-
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/advisor"
)
@@ -43,89 +41,111 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advis
return nil, err
}
- checker := &statementDisallowMixInDDLChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &statementDisallowMixInDDLRule{
+ BaseRule: BaseRule{level: level, title: string(checkCtx.Rule.Type)},
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementDisallowMixInDDLChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementDisallowMixInDDLRule struct {
+ BaseRule
statementsText string
}
-// EnterSelectstmt handles SELECT statements (DML)
-func (c *statementDisallowMixInDDLChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {
+// Name returns the rule name for logging/debugging
+func (*statementDisallowMixInDDLRule) Name() string {
+ return "statement_disallow_mix_in_ddl"
+}
+
+// OnEnter is called when entering a parse tree node
+func (r *statementDisallowMixInDDLRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {
+ switch nodeType {
+ case "Selectstmt":
+ r.handleSelectstmt(ctx)
+ case "Insertstmt":
+ r.handleInsertstmt(ctx)
+ case "Updatestmt":
+ r.handleUpdatestmt(ctx)
+ case "Deletestmt":
+ r.handleDeletestmt(ctx)
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
+
+// OnExit is called when exiting a parse tree node
+func (*statementDisallowMixInDDLRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
+}
+
+// handleSelectstmt handles SELECT statements (DML)
+func (r *statementDisallowMixInDDLRule) handleSelectstmt(ctx antlr.ParserRuleContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDMLAdvice(ctx, "SELECT")
+ r.addDMLAdvice(ctx)
}
-// EnterInsertstmt handles INSERT statements (DML)
-func (c *statementDisallowMixInDDLChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+// handleInsertstmt handles INSERT statements (DML)
+func (r *statementDisallowMixInDDLRule) handleInsertstmt(ctx antlr.ParserRuleContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDMLAdvice(ctx, "INSERT")
+ r.addDMLAdvice(ctx)
}
-// EnterUpdatestmt handles UPDATE statements (DML)
-func (c *statementDisallowMixInDDLChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+// handleUpdatestmt handles UPDATE statements (DML)
+func (r *statementDisallowMixInDDLRule) handleUpdatestmt(ctx antlr.ParserRuleContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDMLAdvice(ctx, "UPDATE")
+ r.addDMLAdvice(ctx)
}
-// EnterDeletestmt handles DELETE statements (DML)
-func (c *statementDisallowMixInDDLChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {
+// handleDeletestmt handles DELETE statements (DML)
+func (r *statementDisallowMixInDDLRule) handleDeletestmt(ctx antlr.ParserRuleContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDMLAdvice(ctx, "DELETE")
+ r.addDMLAdvice(ctx)
}
-func (c *statementDisallowMixInDDLChecker) addDMLAdvice(ctx antlr.ParserRuleContext, _ string) {
+func (r *statementDisallowMixInDDLRule) addDMLAdvice(ctx antlr.ParserRuleContext) {
// Extract the statement text including semicolon using character positions
startPos := ctx.GetStart().GetStart()
stopPos := ctx.GetStop().GetStop()
// Find the semicolon after this statement
stmtText := ""
- if stopPos+1 < len(c.statementsText) {
+ if stopPos+1 < len(r.statementsText) {
// Look for semicolon
endPos := stopPos + 1
- for endPos < len(c.statementsText) && c.statementsText[endPos] != ';' {
+ for endPos < len(r.statementsText) && r.statementsText[endPos] != ';' {
endPos++
}
- if endPos < len(c.statementsText) {
- stmtText = c.statementsText[startPos : endPos+1]
+ if endPos < len(r.statementsText) {
+ stmtText = r.statementsText[startPos : endPos+1]
} else {
- stmtText = c.statementsText[startPos:stopPos+1] + ";"
+ stmtText = r.statementsText[startPos:stopPos+1] + ";"
}
} else {
- stmtText = c.statementsText[startPos:stopPos+1] + ";"
+ stmtText = r.statementsText[startPos:stopPos+1] + ";"
}
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementDisallowMixDDLDML.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Alter schema can only run DDL, %q is not DDL", stmtText),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go
index 584b2177fe..d0327ddb5c 100644
--- a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go
+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go
@@ -43,206 +43,307 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advis
return nil, err
}
- checker := &statementDisallowMixInDMLChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &statementDisallowMixInDMLRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
+
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementDisallowMixInDMLChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementDisallowMixInDMLRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
statementsText string
}
-// EnterCreatestmt handles CREATE TABLE statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (*statementDisallowMixInDMLRule) Name() string {
+ return "statement_disallow_mix_in_dml"
+}
+
+func (r *statementDisallowMixInDMLRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {
+ switch nodeType {
+ case "Createstmt":
+ r.handleCreatestmt(ctx)
+ case "Indexstmt":
+ r.handleIndexstmt(ctx)
+ case "Altertablestmt":
+ r.handleAltertablestmt(ctx)
+ case "Dropstmt":
+ r.handleDropstmt(ctx)
+ case "Createschemastmt":
+ r.handleCreateschemastmt(ctx)
+ case "Createseqstmt":
+ r.handleCreateseqstmt(ctx)
+ case "Alterseqstmt":
+ r.handleAlterseqstmt(ctx)
+ case "Viewstmt":
+ r.handleViewstmt(ctx)
+ case "Createfunctionstmt":
+ r.handleCreatefunctionstmt(ctx)
+ case "Createtrigstmt":
+ r.handleCreatetrigstmt(ctx)
+ case "Renamestmt":
+ r.handleRenamestmt(ctx)
+ case "Alterobjectschemastmt":
+ r.handleAlterobjectschemastmt(ctx)
+ case "Alterenumstmt":
+ r.handleAlterenumstmt(ctx)
+ case "Altercompositetypestmt":
+ r.handleAltercompositetypestmt(ctx)
+ case "Createextensionstmt":
+ r.handleCreateextensionstmt(ctx)
+ case "Createdbstmt":
+ r.handleCreatedbstmt(ctx)
+ case "Creatematviewstmt":
+ r.handleCreatematviewstmt(ctx)
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
+
+func (*statementDisallowMixInDMLRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
+}
+
+func (r *statementDisallowMixInDMLRule) handleCreatestmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreatestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE TABLE")
+ r.addDDLAdvice(createCtx, "CREATE TABLE")
}
-// EnterIndexstmt handles CREATE INDEX statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleIndexstmt(ctx antlr.ParserRuleContext) {
+ indexCtx, ok := ctx.(*parser.IndexstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE INDEX")
+ r.addDDLAdvice(indexCtx, "CREATE INDEX")
}
-// EnterAltertablestmt handles ALTER TABLE statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *statementDisallowMixInDMLRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AltertablestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "ALTER TABLE")
+ r.addDDLAdvice(alterCtx, "ALTER TABLE")
}
-// EnterDropstmt handles DROP statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleDropstmt(ctx antlr.ParserRuleContext) {
+ dropCtx, ok := ctx.(*parser.DropstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "DROP")
+ r.addDDLAdvice(dropCtx, "DROP")
}
-// EnterCreateschemastmt handles CREATE SCHEMA statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreateschemastmt(ctx *parser.CreateschemastmtContext) {
+func (r *statementDisallowMixInDMLRule) handleCreateschemastmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreateschemastmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE SCHEMA")
+ r.addDDLAdvice(createCtx, "CREATE SCHEMA")
}
-// EnterCreateseqstmt handles CREATE SEQUENCE statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleCreateseqstmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreateseqstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE SEQUENCE")
+ r.addDDLAdvice(createCtx, "CREATE SEQUENCE")
}
-// EnterAlterseqstmt handles ALTER SEQUENCE statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleAlterseqstmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AlterseqstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "ALTER SEQUENCE")
+ r.addDDLAdvice(alterCtx, "ALTER SEQUENCE")
}
-// EnterViewstmt handles CREATE VIEW statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterViewstmt(ctx *parser.ViewstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleViewstmt(ctx antlr.ParserRuleContext) {
+ viewCtx, ok := ctx.(*parser.ViewstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE VIEW")
+ r.addDDLAdvice(viewCtx, "CREATE VIEW")
}
-// EnterCreatefunctionstmt handles CREATE FUNCTION statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleCreatefunctionstmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreatefunctionstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE FUNCTION")
+ r.addDDLAdvice(createCtx, "CREATE FUNCTION")
}
-// EnterCreatetrigstmt handles CREATE TRIGGER statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleCreatetrigstmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreatetrigstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE TRIGGER")
+ r.addDDLAdvice(createCtx, "CREATE TRIGGER")
}
-// EnterRenamestmt handles RENAME statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+func (r *statementDisallowMixInDMLRule) handleRenamestmt(ctx antlr.ParserRuleContext) {
+ renameCtx, ok := ctx.(*parser.RenamestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "RENAME")
+ r.addDDLAdvice(renameCtx, "RENAME")
}
-// EnterAlterobjectschemastmt handles ALTER ... SET SCHEMA statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterAlterobjectschemastmt(ctx *parser.AlterobjectschemastmtContext) {
+func (r *statementDisallowMixInDMLRule) handleAlterobjectschemastmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AlterobjectschemastmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "ALTER SET SCHEMA")
+ r.addDDLAdvice(alterCtx, "ALTER SET SCHEMA")
}
-// EnterAlterenumstmt handles ALTER TYPE ... ADD VALUE statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterAlterenumstmt(ctx *parser.AlterenumstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleAlterenumstmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AlterenumstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "ALTER TYPE")
+ r.addDDLAdvice(alterCtx, "ALTER TYPE")
}
-// EnterAltercompositetypestmt handles ALTER TYPE (composite) statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterAltercompositetypestmt(ctx *parser.AltercompositetypestmtContext) {
+func (r *statementDisallowMixInDMLRule) handleAltercompositetypestmt(ctx antlr.ParserRuleContext) {
+ alterCtx, ok := ctx.(*parser.AltercompositetypestmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "ALTER TYPE")
+ r.addDDLAdvice(alterCtx, "ALTER TYPE")
}
-// EnterCreateextensionstmt handles CREATE EXTENSION statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleCreateextensionstmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreateextensionstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE EXTENSION")
+ r.addDDLAdvice(createCtx, "CREATE EXTENSION")
}
-// EnterCreatedbstmt handles CREATE DATABASE statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreatedbstmt(ctx *parser.CreatedbstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleCreatedbstmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreatedbstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE DATABASE")
+ r.addDDLAdvice(createCtx, "CREATE DATABASE")
}
-// EnterCreatematviewstmt handles CREATE MATERIALIZED VIEW statements (DDL)
-func (c *statementDisallowMixInDMLChecker) EnterCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {
+func (r *statementDisallowMixInDMLRule) handleCreatematviewstmt(ctx antlr.ParserRuleContext) {
+ createCtx, ok := ctx.(*parser.CreatematviewstmtContext)
+ if !ok {
+ return
+ }
if !isTopLevel(ctx.GetParent()) {
return
}
- c.addDDLAdvice(ctx, "CREATE MATERIALIZED VIEW")
+ r.addDDLAdvice(createCtx, "CREATE MATERIALIZED VIEW")
}
-func (c *statementDisallowMixInDMLChecker) addDDLAdvice(ctx antlr.ParserRuleContext, _ string) {
+func (r *statementDisallowMixInDMLRule) addDDLAdvice(ctx antlr.ParserRuleContext, _ string) {
// Extract the statement text including semicolon using character positions
startPos := ctx.GetStart().GetStart()
stopPos := ctx.GetStop().GetStop()
// Find the semicolon after this statement
stmtText := ""
- if stopPos+1 < len(c.statementsText) {
+ if stopPos+1 < len(r.statementsText) {
// Look for semicolon
endPos := stopPos + 1
- for endPos < len(c.statementsText) && c.statementsText[endPos] != ';' {
+ for endPos < len(r.statementsText) && r.statementsText[endPos] != ';' {
endPos++
}
- if endPos < len(c.statementsText) {
- stmtText = c.statementsText[startPos : endPos+1]
+ if endPos < len(r.statementsText) {
+ stmtText = r.statementsText[startPos : endPos+1]
} else {
- stmtText = c.statementsText[startPos:stopPos+1] + ";"
+ stmtText = r.statementsText[startPos:stopPos+1] + ";"
}
} else {
- stmtText = c.statementsText[startPos:stopPos+1] + ";"
+ stmtText = r.statementsText[startPos:stopPos+1] + ";"
}
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementDisallowMixDDLDML.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Data change can only run DML, %q is not DML", stmtText),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
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 fb3e9ba363..a6217a737b 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
@@ -36,29 +36,47 @@ func (*StatementDisallowOnDelCascadeAdvisor) Check(_ context.Context, checkCtx a
return nil, err
}
- checker := &statementDisallowOnDelCascadeChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &statementDisallowOnDelCascadeRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementDisallowOnDelCascadeChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementDisallowOnDelCascadeRule struct {
+ BaseRule
statementsText string
}
-// EnterKey_delete checks for ON DELETE CASCADE
-func (c *statementDisallowOnDelCascadeChecker) EnterKey_delete(ctx *parser.Key_deleteContext) {
+// 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))
+ 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()
@@ -87,15 +105,15 @@ func (c *statementDisallowOnDelCascadeChecker) EnterKey_delete(ctx *parser.Key_d
if line < 1 {
line = 1
}
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementDisallowCascade.Int32(),
- Title: c.title,
+ Title: r.title,
Content: "The CASCADE option is not permitted for ON DELETE clauses",
StartPosition: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
Line: int32(line),
Column: 0,
- }, c.statementsText),
+ }, r.statementsText),
})
}
}
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 e519761fe9..4977f6533c 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
@@ -35,27 +35,47 @@ func (*StatementDisallowRemoveTblCascadeAdvisor) Check(_ context.Context, checkC
return nil, err
}
- checker := &statementDisallowRemoveTblCascadeChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
+ rule := &statementDisallowRemoveTblCascadeRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementDisallowRemoveTblCascadeChecker struct {
- *parser.BasePostgreSQLParserListener
+type statementDisallowRemoveTblCascadeRule struct {
+ BaseRule
+}
+
+// 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))
+ default:
+ // Do nothing for other node types
+ }
+ return nil
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+// OnExit is called when the parser exits a rule context.
+func (*statementDisallowRemoveTblCascadeRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-// EnterDropstmt handles DROP TABLE statements with CASCADE
-func (c *statementDisallowRemoveTblCascadeChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+func (r *statementDisallowRemoveTblCascadeRule) handleDropstmt(ctx *parser.DropstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -66,11 +86,11 @@ func (c *statementDisallowRemoveTblCascadeChecker) EnterDropstmt(ctx *parser.Dro
}
// Check for CASCADE option
- if c.hasCascadeOption(ctx.Opt_drop_behavior()) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.hasCascadeOption(ctx.Opt_drop_behavior()) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementDisallowCascade.Int32(),
- Title: c.title,
+ Title: r.title,
Content: "The use of CASCADE is not permitted when removing a table",
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -80,18 +100,17 @@ func (c *statementDisallowRemoveTblCascadeChecker) EnterDropstmt(ctx *parser.Dro
}
}
-// EnterTruncatestmt handles TRUNCATE TABLE statements with CASCADE
-func (c *statementDisallowRemoveTblCascadeChecker) EnterTruncatestmt(ctx *parser.TruncatestmtContext) {
+func (r *statementDisallowRemoveTblCascadeRule) handleTruncatestmt(ctx *parser.TruncatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
// Check for CASCADE option
- if c.hasCascadeOption(ctx.Opt_drop_behavior()) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ if r.hasCascadeOption(ctx.Opt_drop_behavior()) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementDisallowCascade.Int32(),
- Title: c.title,
+ Title: r.title,
Content: "The use of CASCADE is not permitted when removing a table",
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -102,7 +121,7 @@ func (c *statementDisallowRemoveTblCascadeChecker) EnterTruncatestmt(ctx *parser
}
// hasCascadeOption checks if the drop behavior is CASCADE
-func (*statementDisallowRemoveTblCascadeChecker) hasCascadeOption(ctx parser.IOpt_drop_behaviorContext) bool {
+func (*statementDisallowRemoveTblCascadeRule) hasCascadeOption(ctx parser.IOpt_drop_behaviorContext) bool {
if ctx == nil {
return false
}
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 016eb3b3d3..eb730c077a 100644
--- a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
+++ b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
@@ -37,30 +37,29 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Co
return nil, err
}
- checker := &statementDMLDryRunChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- ctx: ctx,
- driver: checkCtx.Driver,
- usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
- statementsText: checkCtx.Statements,
+ rule := &statementDMLDryRunRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ ctx: ctx,
+ driver: checkCtx.Driver,
+ usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
+ statementsText: checkCtx.Statements,
}
// Only run EXPLAIN queries if we have a database connection
- if checker.driver != nil {
+ if rule.driver != nil {
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ return checker.GetAdviceList(), nil
}
- return checker.adviceList, nil
+ return nil, nil
}
-type statementDMLDryRunChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementDMLDryRunRule struct {
+ BaseRule
driver *sql.DB
ctx context.Context
explainCount int
@@ -69,8 +68,34 @@ type statementDMLDryRunChecker struct {
statementsText string
}
-// EnterVariablesetstmt handles SET ROLE statements
-func (c *statementDMLDryRunChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+// Name returns the rule name.
+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))
+ 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
}
@@ -80,62 +105,59 @@ func (c *statementDMLDryRunChecker) EnterVariablesetstmt(ctx *parser.Variableset
setRestMore := ctx.Set_rest().Set_rest_more()
if setRestMore.ROLE() != nil {
// Store the SET ROLE statement text
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.setRoles = append(c.setRoles, stmtText)
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ r.setRoles = append(r.setRoles, stmtText)
}
}
}
-// EnterInsertstmt handles INSERT statements
-func (c *statementDMLDryRunChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+func (r *statementDMLDryRunRule) handleInsertstmt(ctx *parser.InsertstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.checkDMLDryRun(ctx)
+ r.checkDMLDryRun(ctx)
}
-// EnterUpdatestmt handles UPDATE statements
-func (c *statementDMLDryRunChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+func (r *statementDMLDryRunRule) handleUpdatestmt(ctx *parser.UpdatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.checkDMLDryRun(ctx)
+ r.checkDMLDryRun(ctx)
}
-// EnterDeletestmt handles DELETE statements
-func (c *statementDMLDryRunChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {
+func (r *statementDMLDryRunRule) handleDeletestmt(ctx *parser.DeletestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- c.checkDMLDryRun(ctx)
+ r.checkDMLDryRun(ctx)
}
-func (c *statementDMLDryRunChecker) checkDMLDryRun(ctx antlr.ParserRuleContext) {
+func (r *statementDMLDryRunRule) checkDMLDryRun(ctx antlr.ParserRuleContext) {
// Check if we've hit the maximum number of EXPLAIN queries
- if c.explainCount >= common.MaximumLintExplainSize {
+ if r.explainCount >= common.MaximumLintExplainSize {
return
}
- c.explainCount++
+ r.explainCount++
// Get the statement text
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
normalizedStmt := advisor.NormalizeStatement(stmtText)
// Run EXPLAIN to perform dry run
- _, err := advisor.Query(c.ctx, advisor.QueryContext{
- UsePostgresDatabaseOwner: c.usePostgresDatabaseOwner,
- PreExecutions: c.setRoles,
- }, c.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))
+ _, err := advisor.Query(r.ctx, advisor.QueryContext{
+ UsePostgresDatabaseOwner: r.usePostgresDatabaseOwner,
+ PreExecutions: r.setRoles,
+ }, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))
if err != nil {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementDMLDryRunFailed.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" dry runs failed: %s", normalizedStmt, err.Error()),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
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 ab13e0a034..b0926cb978 100644
--- a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go
+++ b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go
@@ -41,71 +41,90 @@ func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advi
return nil, err
}
- checker := &statementMaximumLimitValueChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- limitMaxValue: payload.Number,
+ rule := &statementMaximumLimitValueRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ limitMaxValue: payload.Number,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementMaximumLimitValueChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementMaximumLimitValueRule struct {
+ BaseRule
limitMaxValue int
}
-// EnterSelectstmt handles SELECT statements with LIMIT clauses.
-func (c *statementMaximumLimitValueChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
- return
+// Name returns the rule name.
+func (*statementMaximumLimitValueRule) Name() string {
+ return "statement_maximum_limit_value"
+}
+
+// OnEnter handles node entry events.
+func (r *statementMaximumLimitValueRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {
+ if nodeType != "Selectstmt" {
+ return nil
+ }
+
+ selectstmtCtx, ok := ctx.(*parser.SelectstmtContext)
+ if !ok {
+ return nil
+ }
+
+ if !isTopLevel(selectstmtCtx.GetParent()) {
+ return nil
}
// Check for LIMIT clause in the SELECT statement
- limitValue := c.extractLimitValue(ctx)
- if limitValue > 0 && limitValue > c.limitMaxValue {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ limitValue := r.extractLimitValue(selectstmtCtx)
+ if limitValue > 0 && limitValue > r.limitMaxValue {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementExceedMaximumLimitValue.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("The limit value %d exceeds the maximum allowed value %d", limitValue, c.limitMaxValue),
+ Title: r.title,
+ Content: fmt.Sprintf("The limit value %d exceeds the maximum allowed value %d", limitValue, r.limitMaxValue),
StartPosition: &storepb.Position{
- Line: int32(ctx.GetStart().GetLine()),
+ Line: int32(selectstmtCtx.GetStart().GetLine()),
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 (c *statementMaximumLimitValueChecker) extractLimitValue(ctx *parser.SelectstmtContext) int {
+func (r *statementMaximumLimitValueRule) extractLimitValue(ctx *parser.SelectstmtContext) int {
if ctx == nil {
return 0
}
// Try select_no_parens
if ctx.Select_no_parens() != nil {
- return c.extractLimitFromSelectNoParens(ctx.Select_no_parens())
+ return r.extractLimitFromSelectNoParens(ctx.Select_no_parens())
}
// Try select_with_parens
if ctx.Select_with_parens() != nil {
- return c.extractLimitFromSelectWithParens(ctx.Select_with_parens())
+ return r.extractLimitFromSelectWithParens(ctx.Select_with_parens())
}
return 0
}
// extractLimitFromSelectNoParens extracts LIMIT value from select_no_parens.
-func (c *statementMaximumLimitValueChecker) extractLimitFromSelectNoParens(ctx parser.ISelect_no_parensContext) int {
+func (r *statementMaximumLimitValueRule) extractLimitFromSelectNoParens(ctx parser.ISelect_no_parensContext) int {
if ctx == nil {
return 0
}
@@ -120,32 +139,32 @@ func (c *statementMaximumLimitValueChecker) extractLimitFromSelectNoParens(ctx p
// Check for select_limit directly in select_no_parens
if selectLimit != nil {
- return c.extractLimitFromSelectLimit(selectLimit)
+ return r.extractLimitFromSelectLimit(selectLimit)
}
return 0
}
// extractLimitFromSelectWithParens extracts LIMIT value from select_with_parens.
-func (c *statementMaximumLimitValueChecker) extractLimitFromSelectWithParens(ctx parser.ISelect_with_parensContext) int {
+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 c.extractLimitFromSelectNoParens(ctx.Select_no_parens())
+ return r.extractLimitFromSelectNoParens(ctx.Select_no_parens())
}
if ctx.Select_with_parens() != nil {
- return c.extractLimitFromSelectWithParens(ctx.Select_with_parens())
+ return r.extractLimitFromSelectWithParens(ctx.Select_with_parens())
}
return 0
}
// extractLimitFromSelectLimit extracts LIMIT value from select_limit clause.
-func (c *statementMaximumLimitValueChecker) extractLimitFromSelectLimit(ctx parser.ISelect_limitContext) int {
+func (r *statementMaximumLimitValueRule) extractLimitFromSelectLimit(ctx parser.ISelect_limitContext) int {
if ctx == nil {
return 0
}
@@ -161,7 +180,7 @@ func (c *statementMaximumLimitValueChecker) extractLimitFromSelectLimit(ctx pars
limitClause := ctx.Limit_clause()
// Get the select_limit_value
if limitClause.Select_limit_value() != nil {
- return c.extractLimitValueFromLimitValue(limitClause.Select_limit_value())
+ return r.extractLimitValueFromLimitValue(limitClause.Select_limit_value())
}
}
@@ -170,7 +189,7 @@ func (c *statementMaximumLimitValueChecker) extractLimitFromSelectLimit(ctx pars
offsetClause := ctx.Offset_clause()
// Check for FETCH FIRST/NEXT syntax
if offsetClause.Select_fetch_first_value() != nil {
- return c.extractLimitValueFromFetchFirst(offsetClause.Select_fetch_first_value())
+ return r.extractLimitValueFromFetchFirst(offsetClause.Select_fetch_first_value())
}
}
@@ -178,7 +197,7 @@ func (c *statementMaximumLimitValueChecker) extractLimitFromSelectLimit(ctx pars
}
// extractLimitValueFromLimitValue extracts integer value from select_limit_value.
-func (c *statementMaximumLimitValueChecker) extractLimitValueFromLimitValue(ctx parser.ISelect_limit_valueContext) int {
+func (r *statementMaximumLimitValueRule) extractLimitValueFromLimitValue(ctx parser.ISelect_limit_valueContext) int {
if ctx == nil {
return 0
}
@@ -190,37 +209,37 @@ func (c *statementMaximumLimitValueChecker) extractLimitValueFromLimitValue(ctx
// Check for a_expr which contains the actual value
if ctx.A_expr() != nil {
- return c.extractIntFromAExpr(ctx.A_expr())
+ return r.extractIntFromAExpr(ctx.A_expr())
}
return 0
}
// extractLimitValueFromFetchFirst extracts integer value from FETCH FIRST/NEXT clause.
-func (c *statementMaximumLimitValueChecker) extractLimitValueFromFetchFirst(ctx parser.ISelect_fetch_first_valueContext) int {
+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 c.parseIntFromText(text)
+ return r.parseIntFromText(text)
}
// extractIntFromAExpr attempts to extract an integer constant from an a_expr.
-func (c *statementMaximumLimitValueChecker) extractIntFromAExpr(ctx parser.IA_exprContext) int {
+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 c.parseIntFromText(text)
+ return r.parseIntFromText(text)
}
// parseIntFromText attempts to parse an integer from text.
// This handles simple numeric literals and returns 0 if parsing fails.
-func (*statementMaximumLimitValueChecker) parseIntFromText(text string) int {
+func (*statementMaximumLimitValueRule) parseIntFromText(text string) int {
// Clean up the text (remove whitespace)
text = strings.TrimSpace(text)
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 d6c6f75a9c..ad25494c6a 100644
--- a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go
+++ b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go
@@ -36,23 +36,22 @@ func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx adviso
return nil, err
}
- checker := &statementMergeAlterTableChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- tableMap: make(tableMap),
+ rule := &statementMergeAlterTableRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ tableMap: make(tableMap),
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.generateAdvice(), nil
+ return rule.generateAdvice(), nil
}
-type statementMergeAlterTableChecker struct {
- *parser.BasePostgreSQLParserListener
-
- level storepb.Advice_Status
- title string
+type statementMergeAlterTableRule struct {
+ BaseRule
tableMap tableMap
}
@@ -87,41 +86,30 @@ func (t tableStatement) key() string {
return fmt.Sprintf("%s.%s", t.schema, t.name)
}
-func (checker *statementMergeAlterTableChecker) generateAdvice() []*storepb.Advice {
- var adviceList []*storepb.Advice
- var tableList []tableStatement
- for _, table := range checker.tableMap {
- tableList = append(tableList, table)
- }
- slices.SortFunc(tableList, func(i, j tableStatement) int {
- if i.line < j.line {
- return -1
- }
- if i.line > j.line {
- return 1
- }
- return 0
- })
- for _, table := range tableList {
- if table.count > 1 {
- adviceList = append(adviceList, &storepb.Advice{
- Status: checker.level,
- Code: advisor.StatementRedundantAlterTable.Int32(),
- Title: checker.title,
- Content: fmt.Sprintf("There are %d statements to modify table `%s`", table.count, table.name),
- StartPosition: &storepb.Position{
- Line: int32(table.line),
- Column: 0,
- },
- })
- }
- }
+// Name returns the rule name.
+func (*statementMergeAlterTableRule) Name() string {
+ return "statement.merge-alter-table"
+}
- return adviceList
+// 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))
+ 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
}
-// EnterCreatestmt is called when production createstmt is entered.
-func (checker *statementMergeAlterTableChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+func (r *statementMergeAlterTableRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -142,11 +130,10 @@ func (checker *statementMergeAlterTableChecker) EnterCreatestmt(ctx *parser.Crea
return
}
- checker.tableMap.set(schema, tableName, ctx.GetStop().GetLine())
+ r.tableMap.set(schema, tableName, ctx.GetStop().GetLine())
}
-// EnterAltertablestmt is called when production altertablestmt is entered.
-func (checker *statementMergeAlterTableChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+func (r *statementMergeAlterTableRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -171,5 +158,38 @@ func (checker *statementMergeAlterTableChecker) EnterAltertablestmt(ctx *parser.
return
}
- checker.tableMap.add(schema, tableName, ctx.GetStop().GetLine())
+ r.tableMap.add(schema, tableName, ctx.GetStop().GetLine())
+}
+
+func (r *statementMergeAlterTableRule) generateAdvice() []*storepb.Advice {
+ var adviceList []*storepb.Advice
+ var tableList []tableStatement
+ for _, table := range r.tableMap {
+ tableList = append(tableList, table)
+ }
+ slices.SortFunc(tableList, func(i, j tableStatement) int {
+ if i.line < j.line {
+ return -1
+ }
+ if i.line > j.line {
+ return 1
+ }
+ return 0
+ })
+ for _, table := range tableList {
+ if table.count > 1 {
+ adviceList = append(adviceList, &storepb.Advice{
+ Status: r.level,
+ Code: advisor.StatementRedundantAlterTable.Int32(),
+ 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),
+ Column: 0,
+ },
+ })
+ }
+ }
+
+ return adviceList
}
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 e9f384a640..157e5fe6d6 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
@@ -36,31 +36,49 @@ func (*StatementNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx
return nil, err
}
- checker := &statementNoLeadingWildcardLikeChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
- reportedStatements: make(map[antlr.ParserRuleContext]bool),
+ rule := &statementNoLeadingWildcardLikeRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
+ reportedStatements: make(map[antlr.ParserRuleContext]bool),
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementNoLeadingWildcardLikeChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementNoLeadingWildcardLikeRule struct {
+ BaseRule
statementsText string
reportedStatements map[antlr.ParserRuleContext]bool
}
-// EnterA_expr_like handles LIKE/ILIKE expressions
-func (c *statementNoLeadingWildcardLikeChecker) EnterA_expr_like(ctx *parser.A_expr_likeContext) {
+// 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
+}
+
+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
@@ -84,16 +102,16 @@ func (c *statementNoLeadingWildcardLikeChecker) EnterA_expr_like(ctx *parser.A_e
}
// Only report once per statement
- if c.reportedStatements[stmtCtx] {
+ if r.reportedStatements[stmtCtx] {
return
}
- c.reportedStatements[stmtCtx] = true
+ r.reportedStatements[stmtCtx] = true
- stmtText := extractStatementText(c.statementsText, stmtCtx.GetStart().GetLine(), stmtCtx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, stmtCtx.GetStart().GetLine(), stmtCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementLeadingWildcardLike.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" uses leading wildcard LIKE", stmtText),
StartPosition: &storepb.Position{
Line: int32(stmtCtx.GetStart().GetLine()),
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 3d3bd24cea..70e9b81762 100644
--- a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go
+++ b/backend/plugin/advisor/pg/advisor_statement_no_select_all.go
@@ -36,29 +36,47 @@ func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([
return nil, err
}
- checker := &noSelectAllChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &noSelectAllRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type noSelectAllChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type noSelectAllRule struct {
+ BaseRule
statementsText string
}
-// EnterSimple_select_pramary checks for SELECT * in simple select statements
-func (c *noSelectAllChecker) EnterSimple_select_pramary(ctx *parser.Simple_select_pramaryContext) {
+// Name returns the rule name.
+func (*noSelectAllRule) Name() string {
+ return "statement.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))
+ 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) handleSimpleSelectPramary(ctx *parser.Simple_select_pramaryContext) {
// Check if this is a SELECT statement with target list
if ctx.SELECT() == nil {
return
@@ -97,18 +115,18 @@ func (c *noSelectAllChecker) EnterSimple_select_pramary(ctx *parser.Simple_selec
var stmtText string
var line int
if stmtCtx != nil {
- stmtText = extractStatementText(c.statementsText, stmtCtx.GetStart().GetLine(), stmtCtx.GetStop().GetLine())
+ stmtText = extractStatementText(r.statementsText, stmtCtx.GetStart().GetLine(), stmtCtx.GetStop().GetLine())
line = stmtCtx.GetStart().GetLine()
} else {
// Fallback to the simple_select context
- stmtText = extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ stmtText = extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
line = ctx.GetStart().GetLine()
}
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementSelectAll.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" uses SELECT all", stmtText),
StartPosition: &storepb.Position{
Line: int32(line),
diff --git a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go
index 5bd69fb77c..60cef71c33 100644
--- a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go
+++ b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go
@@ -36,39 +36,80 @@ func (*NonTransactionalAdvisor) Check(_ context.Context, checkCtx advisor.Contex
return nil, err
}
- checker := &nonTransactionalChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &nonTransactionalRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type nonTransactionalChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type nonTransactionalRule struct {
+ BaseRule
statementsText string
}
+// 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))
+ 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 (c *nonTransactionalChecker) checkStatement(ctx antlr.ParserRuleContext) {
+func (r *nonTransactionalRule) checkStatement(ctx antlr.ParserRuleContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
if pg.IsNonTransactionStatement(stmtText) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementNonTransactional.Int32(),
- Title: c.title,
+ Title: r.title,
Content: "This statement is non-transactional",
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -77,23 +118,3 @@ func (c *nonTransactionalChecker) checkStatement(ctx antlr.ParserRuleContext) {
})
}
}
-
-// EnterDropdbstmt handles DROP DATABASE
-func (c *nonTransactionalChecker) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {
- c.checkStatement(ctx)
-}
-
-// EnterIndexstmt handles CREATE INDEX
-func (c *nonTransactionalChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
- c.checkStatement(ctx)
-}
-
-// EnterDropstmt handles DROP INDEX (and other DROP statements)
-func (c *nonTransactionalChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
- c.checkStatement(ctx)
-}
-
-// EnterVacuumstmt handles VACUUM
-func (c *nonTransactionalChecker) EnterVacuumstmt(ctx *parser.VacuumstmtContext) {
- c.checkStatement(ctx)
-}
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 150d9acd06..475fa5adf5 100644
--- a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
+++ b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
@@ -52,31 +52,80 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx adv
}
}
- checker := &statementObjectOwnerCheckChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- dbMetadata: dbMetadata,
- currentRole: currentRole,
+ rule := &statementObjectOwnerCheckRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ dbMetadata: dbMetadata,
+ currentRole: currentRole,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementObjectOwnerCheckChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementObjectOwnerCheckRule struct {
+ BaseRule
dbMetadata *model.DatabaseMetadata
currentRole string
}
-// EnterVariablesetstmt handles SET ROLE statements
-func (*statementObjectOwnerCheckChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+// Name returns the rule name.
+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))
+ 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
+}
+
+// handleVariablesetstmt handles SET ROLE statements
+func (*statementObjectOwnerCheckRule) handleVariablesetstmt(ctx *parser.VariablesetstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -87,25 +136,25 @@ func (*statementObjectOwnerCheckChecker) EnterVariablesetstmt(ctx *parser.Variab
// For now, we skip updating currentRole from SET ROLE to keep it simple
}
-func (c *statementObjectOwnerCheckChecker) checkSchemaOwnership(schemaName string, line int) {
+func (r *statementObjectOwnerCheckRule) checkSchemaOwnership(schemaName string, line int) {
if schemaName == "" {
schemaName = defaultSchema
}
- schemaMeta := c.dbMetadata.GetSchema(schemaName)
+ schemaMeta := r.dbMetadata.GetSchema(schemaName)
if schemaMeta == nil {
return
}
owner := schemaMeta.GetOwner()
if owner == pgDatabaseOwner {
- owner = c.dbMetadata.GetOwner()
+ owner = r.dbMetadata.GetOwner()
}
- if owner != c.currentRole {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
- Title: c.title,
- Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, c.currentRole),
+ if owner != r.currentRole {
+ r.AddAdvice(&storepb.Advice{
+ 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: advisor.StatementObjectOwnerCheck.Int32(),
StartPosition: &storepb.Position{
Line: int32(line),
@@ -115,12 +164,12 @@ func (c *statementObjectOwnerCheckChecker) checkSchemaOwnership(schemaName strin
}
}
-func (c *statementObjectOwnerCheckChecker) checkTableOwnership(schemaName, tableName string, line int) {
+func (r *statementObjectOwnerCheckRule) checkTableOwnership(schemaName, tableName string, line int) {
if schemaName == "" {
schemaName = defaultSchema
}
- schemaMeta := c.dbMetadata.GetSchema(schemaName)
+ schemaMeta := r.dbMetadata.GetSchema(schemaName)
if schemaMeta == nil {
return
}
@@ -132,13 +181,13 @@ func (c *statementObjectOwnerCheckChecker) checkTableOwnership(schemaName, table
owner := tableMeta.GetOwner()
if owner == pgDatabaseOwner {
- owner = c.dbMetadata.GetOwner()
+ owner = r.dbMetadata.GetOwner()
}
- if owner != c.currentRole {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
- Title: c.title,
- Content: fmt.Sprintf("Table \"%s\" is owned by \"%s\", but the current role is \"%s\".", tableName, owner, c.currentRole),
+ if owner != r.currentRole {
+ r.AddAdvice(&storepb.Advice{
+ 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: advisor.StatementObjectOwnerCheck.Int32(),
StartPosition: &storepb.Position{
Line: int32(line),
@@ -148,8 +197,8 @@ func (c *statementObjectOwnerCheckChecker) checkTableOwnership(schemaName, table
}
}
-// EnterAlterseqstmt handles ALTER SEQUENCE statements
-func (c *statementObjectOwnerCheckChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {
+// handleAlterseqstmt handles ALTER SEQUENCE statements
+func (r *statementObjectOwnerCheckRule) handleAlterseqstmt(ctx *parser.AlterseqstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -160,11 +209,11 @@ func (c *statementObjectOwnerCheckChecker) EnterAlterseqstmt(ctx *parser.Alterse
}
schemaName := extractSchemaName(qualName)
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterAltertablestmt handles ALTER TABLE statements
-func (c *statementObjectOwnerCheckChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+// handleAltertablestmt handles ALTER TABLE statements
+func (r *statementObjectOwnerCheckRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -177,11 +226,11 @@ func (c *statementObjectOwnerCheckChecker) EnterAltertablestmt(ctx *parser.Alter
schemaName := extractSchemaName(qualName)
tableName := extractTableName(qualName)
- c.checkTableOwnership(schemaName, tableName, ctx.GetStart().GetLine())
+ r.checkTableOwnership(schemaName, tableName, ctx.GetStart().GetLine())
}
-// EnterAltertypestmt handles ALTER TYPE statements
-func (c *statementObjectOwnerCheckChecker) EnterAltertypestmt(ctx *parser.AltertypestmtContext) {
+// handleAltertypestmt handles ALTER TYPE statements
+func (r *statementObjectOwnerCheckRule) handleAltertypestmt(ctx *parser.AltertypestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -198,11 +247,11 @@ func (c *statementObjectOwnerCheckChecker) EnterAltertypestmt(ctx *parser.Altert
schemaName = parts[0]
}
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterCreateextensionstmt handles CREATE EXTENSION statements
-func (c *statementObjectOwnerCheckChecker) EnterCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {
+// handleCreateextensionstmt handles CREATE EXTENSION statements
+func (r *statementObjectOwnerCheckRule) handleCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -218,11 +267,11 @@ func (c *statementObjectOwnerCheckChecker) EnterCreateextensionstmt(ctx *parser.
}
}
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterCreatefunctionstmt handles CREATE FUNCTION statements
-func (c *statementObjectOwnerCheckChecker) EnterCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {
+// handleCreatefunctionstmt handles CREATE FUNCTION statements
+func (r *statementObjectOwnerCheckRule) handleCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -231,12 +280,12 @@ func (c *statementObjectOwnerCheckChecker) EnterCreatefunctionstmt(ctx *parser.C
return
}
- schemaName := c.extractSchemaFromFuncName(ctx.Func_name())
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ schemaName := r.extractSchemaFromFuncName(ctx.Func_name())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterIndexstmt handles CREATE INDEX statements
-func (c *statementObjectOwnerCheckChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+// handleIndexstmt handles CREATE INDEX statements
+func (r *statementObjectOwnerCheckRule) handleIndexstmt(ctx *parser.IndexstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -248,21 +297,21 @@ func (c *statementObjectOwnerCheckChecker) EnterIndexstmt(ctx *parser.IndexstmtC
qualName := ctx.Relation_expr().Qualified_name()
schemaName := extractSchemaName(qualName)
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterCreateschemastmt handles CREATE SCHEMA statements
-func (c *statementObjectOwnerCheckChecker) EnterCreateschemastmt(ctx *parser.CreateschemastmtContext) {
+// handleCreateschemastmt handles CREATE SCHEMA statements
+func (r *statementObjectOwnerCheckRule) handleCreateschemastmt(ctx *parser.CreateschemastmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
- owner := c.dbMetadata.GetOwner()
- if owner != c.currentRole {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
- Title: c.title,
- Content: fmt.Sprintf("Database \"%s\" is owned by \"%s\", but the current role is \"%s\".", c.dbMetadata.GetName(), owner, c.currentRole),
+ owner := r.dbMetadata.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.GetName(), owner, r.currentRole),
Code: advisor.StatementObjectOwnerCheck.Int32(),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -272,8 +321,8 @@ func (c *statementObjectOwnerCheckChecker) EnterCreateschemastmt(ctx *parser.Cre
}
}
-// EnterCreateseqstmt handles CREATE SEQUENCE statements
-func (c *statementObjectOwnerCheckChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {
+// handleCreateseqstmt handles CREATE SEQUENCE statements
+func (r *statementObjectOwnerCheckRule) handleCreateseqstmt(ctx *parser.CreateseqstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -285,11 +334,11 @@ func (c *statementObjectOwnerCheckChecker) EnterCreateseqstmt(ctx *parser.Create
qualName := ctx.Qualified_name()
schemaName := extractSchemaName(qualName)
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterCreatestmt handles CREATE TABLE statements
-func (c *statementObjectOwnerCheckChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+// handleCreatestmt handles CREATE TABLE statements
+func (r *statementObjectOwnerCheckRule) handleCreatestmt(ctx *parser.CreatestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -302,11 +351,11 @@ func (c *statementObjectOwnerCheckChecker) EnterCreatestmt(ctx *parser.Createstm
qualName := allQualNames[0]
schemaName := extractSchemaName(qualName)
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterCreatetrigstmt handles CREATE TRIGGER statements
-func (c *statementObjectOwnerCheckChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {
+// handleCreatetrigstmt handles CREATE TRIGGER statements
+func (r *statementObjectOwnerCheckRule) handleCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -318,11 +367,11 @@ func (c *statementObjectOwnerCheckChecker) EnterCreatetrigstmt(ctx *parser.Creat
qualName := ctx.Qualified_name()
schemaName := extractSchemaName(qualName)
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterDefinestmt handles CREATE TYPE statements (via DEFINE)
-func (c *statementObjectOwnerCheckChecker) EnterDefinestmt(ctx *parser.DefinestmtContext) {
+// handleDefinestmt handles CREATE TYPE statements (via DEFINE)
+func (r *statementObjectOwnerCheckRule) handleDefinestmt(ctx *parser.DefinestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -345,11 +394,11 @@ func (c *statementObjectOwnerCheckChecker) EnterDefinestmt(ctx *parser.Definestm
schemaName = parts[0]
}
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterCreatematviewstmt handles CREATE VIEW / MATERIALIZED VIEW statements
-func (c *statementObjectOwnerCheckChecker) EnterCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {
+// handleCreatematviewstmt handles CREATE VIEW / MATERIALIZED VIEW statements
+func (r *statementObjectOwnerCheckRule) handleCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -361,11 +410,11 @@ func (c *statementObjectOwnerCheckChecker) EnterCreatematviewstmt(ctx *parser.Cr
qualName := ctx.Create_mv_target().Qualified_name()
schemaName := extractSchemaName(qualName)
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
-// EnterRemovefuncstmt handles DROP FUNCTION statements
-func (c *statementObjectOwnerCheckChecker) EnterRemovefuncstmt(ctx *parser.RemovefuncstmtContext) {
+// handleRemovefuncstmt handles DROP FUNCTION statements
+func (r *statementObjectOwnerCheckRule) handleRemovefuncstmt(ctx *parser.RemovefuncstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -379,32 +428,32 @@ func (c *statementObjectOwnerCheckChecker) EnterRemovefuncstmt(ctx *parser.Remov
continue
}
- schemaName := c.extractSchemaFromFuncName(funcWithArgs.Func_name())
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ schemaName := r.extractSchemaFromFuncName(funcWithArgs.Func_name())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
}
-// EnterDropstmt handles various DROP statements
+// 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 (c *statementObjectOwnerCheckChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+func (r *statementObjectOwnerCheckRule) handleDropstmt(ctx *parser.DropstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
// For DROP INDEX, check schema ownership
if ctx.INDEX() != nil {
- c.handleDropWithAnyNameList(ctx, false)
+ r.handleDropWithAnyNameList(ctx, false)
return
}
// For other DROP statements, check schema ownership
if ctx.Any_name_list() != nil {
- c.handleDropWithAnyNameList(ctx, false)
+ r.handleDropWithAnyNameList(ctx, false)
}
}
-func (c *statementObjectOwnerCheckChecker) handleDropWithAnyNameList(ctx *parser.DropstmtContext, checkTable bool) {
+func (r *statementObjectOwnerCheckRule) handleDropWithAnyNameList(ctx *parser.DropstmtContext, checkTable bool) {
if ctx.Any_name_list() == nil {
return
}
@@ -425,15 +474,15 @@ func (c *statementObjectOwnerCheckChecker) handleDropWithAnyNameList(ctx *parser
}
if checkTable && objectName != "" {
- c.checkTableOwnership(schemaName, objectName, ctx.GetStart().GetLine())
+ r.checkTableOwnership(schemaName, objectName, ctx.GetStart().GetLine())
} else {
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
}
}
-// EnterRenamestmt handles RENAME statements (including ALTER INDEX RENAME)
-func (c *statementObjectOwnerCheckChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+// handleRenamestmt handles RENAME statements (including ALTER INDEX RENAME)
+func (r *statementObjectOwnerCheckRule) handleRenamestmt(ctx *parser.RenamestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -441,17 +490,17 @@ func (c *statementObjectOwnerCheckChecker) EnterRenamestmt(ctx *parser.Renamestm
// Check if this is an ALTER SCHEMA RENAME
if ctx.SCHEMA() != nil && ctx.Name(0) != nil {
schemaName := ctx.Name(0).GetText()
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ 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)
- c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ r.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
}
}
// Helper method to extract schema name from function name
-func (*statementObjectOwnerCheckChecker) extractSchemaFromFuncName(funcName parser.IFunc_nameContext) string {
+func (*statementObjectOwnerCheckRule) extractSchemaFromFuncName(funcName parser.IFunc_nameContext) string {
if funcName.Type_function_name() != nil {
// Simple function name without schema
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 e7e5b7cf6e..cb3533ba87 100644
--- a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go
+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_select.go
@@ -35,48 +35,67 @@ func (*StatementWhereRequiredSelectAdvisor) Check(_ context.Context, checkCtx ad
return nil, err
}
- checker := &statementWhereRequiredSelectChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &statementWhereRequiredSelectRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementWhereRequiredSelectChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementWhereRequiredSelectRule struct {
+ BaseRule
statementsText string
}
-// EnterSelectstmt handles SELECT statements (including subqueries)
-func (c *statementWhereRequiredSelectChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {
- c.checkSelect(ctx, ctx.GetStart(), ctx.GetStop(), func() (bool, bool) {
- return c.checkSelectClauses(ctx)
+// Name returns the rule name.
+func (*statementWhereRequiredSelectRule) Name() string {
+ return "statement.where-required-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
+ }
+ return nil
+}
+
+// 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, ctx.GetStart(), ctx.GetStop(), func() (bool, bool) {
+ return r.checkSelectClauses(ctx)
})
}
-// EnterSelect_with_parens handles SELECT statements in parentheses (subqueries)
-func (c *statementWhereRequiredSelectChecker) EnterSelect_with_parens(ctx *parser.Select_with_parensContext) {
- // Skip if this is the top-level statement (already handled by EnterSelectstmt)
+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()) {
return
}
- c.checkSelect(ctx, ctx.GetStart(), ctx.GetStop(), func() (bool, bool) {
- return c.checkSelectWithParensForWhere(ctx)
+ r.checkSelect(ctx, ctx.GetStart(), ctx.GetStop(), func() (bool, bool) {
+ return r.checkSelectWithParensForWhere(ctx)
})
}
// checkSelect is a common function to check for WHERE clause requirement
-func (c *statementWhereRequiredSelectChecker) checkSelect(
+func (r *statementWhereRequiredSelectRule) checkSelect(
ctx antlr.ParserRuleContext,
_ antlr.Token,
_ antlr.Token,
@@ -98,13 +117,13 @@ func (c *statementWhereRequiredSelectChecker) checkSelect(
// Always use the full top-level statement text for the error message
// This matches the legacy behavior where violations in subqueries
// are reported with the full statement text
- stmtLine := c.findTopLevelLine(ctx)
- stmtText := extractStatementText(c.statementsText, stmtLine, stmtLine)
+ stmtLine := r.findTopLevelLine(ctx)
+ stmtText := extractStatementText(r.statementsText, stmtLine, stmtLine)
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementNoWhere.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),
StartPosition: &storepb.Position{
Line: int32(stmtLine),
@@ -114,7 +133,7 @@ func (c *statementWhereRequiredSelectChecker) checkSelect(
}
// findTopLevelLine finds the line number of the top-level statement
-func (*statementWhereRequiredSelectChecker) findTopLevelLine(ctx antlr.ParserRuleContext) int {
+func (*statementWhereRequiredSelectRule) findTopLevelLine(ctx antlr.ParserRuleContext) int {
for ctx != nil {
if isTopLevel(ctx.GetParent()) {
return ctx.GetStart().GetLine()
@@ -130,7 +149,7 @@ func (*statementWhereRequiredSelectChecker) findTopLevelLine(ctx antlr.ParserRul
}
// checkSelectWithParensForWhere checks a select_with_parens for WHERE and FROM
-func (c *statementWhereRequiredSelectChecker) checkSelectWithParensForWhere(ctx parser.ISelect_with_parensContext) (hasWhere bool, hasFrom bool) {
+func (r *statementWhereRequiredSelectRule) checkSelectWithParensForWhere(ctx parser.ISelect_with_parensContext) (hasWhere bool, hasFrom bool) {
if ctx == nil {
return false, false
}
@@ -139,24 +158,24 @@ func (c *statementWhereRequiredSelectChecker) checkSelectWithParensForWhere(ctx
if ctx.Select_no_parens() != nil {
selectNoParens := ctx.Select_no_parens()
if selectNoParens.Select_clause() != nil {
- return c.checkSelectClause(selectNoParens.Select_clause())
+ return r.checkSelectClause(selectNoParens.Select_clause())
}
}
if ctx.Select_with_parens() != nil {
- return c.checkSelectWithParensForWhere(ctx.Select_with_parens())
+ return r.checkSelectWithParensForWhere(ctx.Select_with_parens())
}
return false, false
}
// checkSelectClauses checks if a SELECT statement has WHERE and FROM clauses
-func (c *statementWhereRequiredSelectChecker) checkSelectClauses(ctx *parser.SelectstmtContext) (hasWhere bool, hasFrom bool) {
+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 c.checkSelectClause(selectNoParens.Select_clause())
+ return r.checkSelectClause(selectNoParens.Select_clause())
}
}
@@ -164,14 +183,14 @@ func (c *statementWhereRequiredSelectChecker) checkSelectClauses(ctx *parser.Sel
if ctx.Select_with_parens() != nil {
// For a selectstmt that directly contains select_with_parens,
// delegate to the recursive handler
- return c.checkSelectWithParensForWhere(ctx.Select_with_parens())
+ return r.checkSelectWithParensForWhere(ctx.Select_with_parens())
}
return false, false
}
// checkSelectClause checks a select_clause for WHERE and FROM
-func (*statementWhereRequiredSelectChecker) checkSelectClause(selectClause parser.ISelect_clauseContext) (hasWhere bool, hasFrom bool) {
+func (*statementWhereRequiredSelectRule) checkSelectClause(selectClause parser.ISelect_clauseContext) (hasWhere bool, hasFrom bool) {
if selectClause == nil {
return false, false
}
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 452cab6a15..51de7264e0 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
@@ -36,40 +36,60 @@ func (*StatementWhereRequiredUpdateDeleteAdvisor) Check(_ context.Context, check
return nil, err
}
- checker := &statementWhereRequiredChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &statementWhereRequiredRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type statementWhereRequiredChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type statementWhereRequiredRule struct {
+ BaseRule
statementsText string
}
-// EnterUpdatestmt handles UPDATE statements
-func (c *statementWhereRequiredChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+// 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
+}
+
+// OnExit is called when the parser exits a rule context.
+func (*statementWhereRequiredRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
+}
+
+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 := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementNoWhere.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -79,19 +99,18 @@ func (c *statementWhereRequiredChecker) EnterUpdatestmt(ctx *parser.UpdatestmtCo
}
}
-// EnterDeletestmt handles DELETE statements
-func (c *statementWhereRequiredChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {
+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 := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.StatementNoWhere.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
diff --git a/backend/plugin/advisor/pg/advisor_table_comment_convention.go b/backend/plugin/advisor/pg/advisor_table_comment_convention.go
index 1e43fa217c..043281f507 100644
--- a/backend/plugin/advisor/pg/advisor_table_comment_convention.go
+++ b/backend/plugin/advisor/pg/advisor_table_comment_convention.go
@@ -42,29 +42,31 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.
return nil, err
}
- checker := &tableCommentConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- payload: payload,
- classificationConfig: checkCtx.ClassificationConfig,
- statementsText: checkCtx.Statements,
- createdTables: make(map[string]*tableInfo),
- tableComments: make(map[string]*tableCommentInfo),
- }
-
+ rule := &tableCommentConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ payload: payload,
+ classificationConfig: checkCtx.ClassificationConfig,
+ statementsText: checkCtx.Statements,
+ createdTables: make(map[string]*tableInfo),
+ tableComments: make(map[string]*tableCommentInfo),
+ }
+
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
// Check each created table for comment requirements
- for tableKey, tableInfo := range checker.createdTables {
- tableCommentInfo, hasComment := checker.tableComments[tableKey]
+ for tableKey, tableInfo := range rule.createdTables {
+ tableCommentInfo, hasComment := rule.tableComments[tableKey]
if !hasComment || tableCommentInfo.comment == "" {
- if checker.payload.Required {
- checker.adviceList = append(checker.adviceList, &storepb.Advice{
- Status: checker.level,
+ if rule.payload.Required {
+ rule.AddAdvice(&storepb.Advice{
+ Status: rule.level,
Code: advisor.CommentEmpty.Int32(),
- Title: checker.title,
+ Title: rule.title,
Content: fmt.Sprintf("Comment is required for table `%s`", tableInfo.displayName),
StartPosition: &storepb.Position{
Line: int32(tableInfo.line),
@@ -74,24 +76,24 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.
}
} else {
comment := tableCommentInfo.comment
- if checker.payload.MaxLength > 0 && len(comment) > checker.payload.MaxLength {
- checker.adviceList = append(checker.adviceList, &storepb.Advice{
- Status: checker.level,
+ if rule.payload.MaxLength > 0 && len(comment) > rule.payload.MaxLength {
+ rule.AddAdvice(&storepb.Advice{
+ Status: rule.level,
Code: advisor.CommentTooLong.Int32(),
- Title: checker.title,
- Content: fmt.Sprintf("Table `%s` comment is too long. The length of comment should be within %d characters", tableInfo.displayName, checker.payload.MaxLength),
+ 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,
},
})
}
- if checker.payload.RequiredClassification {
- if classification, _ := common.GetClassificationAndUserComment(comment, checker.classificationConfig); classification == "" {
- checker.adviceList = append(checker.adviceList, &storepb.Advice{
- Status: checker.level,
+ if rule.payload.RequiredClassification {
+ if classification, _ := common.GetClassificationAndUserComment(comment, rule.classificationConfig); classification == "" {
+ rule.AddAdvice(&storepb.Advice{
+ Status: rule.level,
Code: advisor.CommentMissingClassification.Int32(),
- Title: checker.title,
+ Title: rule.title,
Content: fmt.Sprintf("Table `%s` comment requires classification", tableInfo.displayName),
StartPosition: &storepb.Position{
Line: int32(tableCommentInfo.line),
@@ -103,7 +105,7 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.
}
}
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
type tableInfo struct {
@@ -118,12 +120,9 @@ type tableCommentInfo struct {
line int
}
-type tableCommentConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type tableCommentConventionRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
payload *advisor.CommentConventionRulePayload
classificationConfig *storepb.DataClassificationSetting_DataClassificationConfig
statementsText string
@@ -132,14 +131,42 @@ type tableCommentConventionChecker struct {
tableComments map[string]*tableCommentInfo
}
-// EnterCreatestmt collects CREATE TABLE statements
-func (c *tableCommentConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// 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)
+ 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()) {
return
}
var tableName, schemaName string
- allQualifiedNames := ctx.AllQualified_name()
+ allQualifiedNames := createstmtCtx.AllQualified_name()
if len(allQualifiedNames) > 0 {
tableName = extractTableName(allQualifiedNames[0])
schemaName = extractSchemaName(allQualifiedNames[0])
@@ -155,31 +182,36 @@ func (c *tableCommentConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtCo
displayName = fmt.Sprintf("%s.%s", schemaName, tableName)
}
- c.createdTables[tableKey] = &tableInfo{
+ r.createdTables[tableKey] = &tableInfo{
schema: schemaName,
tableName: tableName,
displayName: displayName,
- line: ctx.GetStart().GetLine(),
+ line: createstmtCtx.GetStart().GetLine(),
}
}
-// EnterCommentstmt collects COMMENT ON TABLE statements
-func (c *tableCommentConventionChecker) EnterCommentstmt(ctx *parser.CommentstmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// handleCommentstmt collects COMMENT ON TABLE statements
+func (r *tableCommentConventionRule) handleCommentstmt(ctx antlr.ParserRuleContext) {
+ commentstmtCtx, ok := ctx.(*parser.CommentstmtContext)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(commentstmtCtx.GetParent()) {
return
}
// Check if this is COMMENT ON TABLE
- if ctx.Object_type_any_name() == nil || ctx.Object_type_any_name().TABLE() == nil {
+ if commentstmtCtx.Object_type_any_name() == nil || commentstmtCtx.Object_type_any_name().TABLE() == nil {
return
}
// Extract table name from Any_name
- if ctx.Any_name() == nil {
+ if commentstmtCtx.Any_name() == nil {
return
}
- parts := pgparser.NormalizePostgreSQLAnyName(ctx.Any_name())
+ parts := pgparser.NormalizePostgreSQLAnyName(commentstmtCtx.Any_name())
if len(parts) == 0 {
return
}
@@ -197,16 +229,16 @@ func (c *tableCommentConventionChecker) EnterCommentstmt(ctx *parser.Commentstmt
// Extract comment text
comment := ""
- if ctx.Comment_text() != nil && ctx.Comment_text().Sconst() != nil {
- commentText := ctx.Comment_text().Sconst().GetText()
+ 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]
}
}
- c.tableComments[tableKey] = &tableCommentInfo{
+ r.tableComments[tableKey] = &tableCommentInfo{
comment: comment,
- line: ctx.GetStart().GetLine(),
+ line: commentstmtCtx.GetStart().GetLine(),
}
}
diff --git a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go
index 8196ece341..874bdfa81f 100644
--- a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go
+++ b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go
@@ -20,11 +20,11 @@ func init() {
advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleTableDisallowPartition, &TableDisallowPartitionAdvisor{})
}
-// TableDisallowPartitionAdvisor is the advisor checking for disallow table partition.
+// TableDisallowPartitionAdvisor is the advisor checking for partitioned tables.
type TableDisallowPartitionAdvisor struct {
}
-// Check checks for disallow table partition.
+// Check checks for partitioned tables.
func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
tree, err := getANTLRTree(checkCtx)
if err != nil {
@@ -36,41 +36,62 @@ func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.
return nil, err
}
- checker := &tableDisallowPartitionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &tableDisallowPartitionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type tableDisallowPartitionChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type tableDisallowPartitionRule struct {
+ BaseRule
statementsText string
}
-// EnterCreatestmt handles CREATE TABLE statements
-func (c *tableDisallowPartitionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+// Name returns the rule name.
+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))
+ 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 CREATE TABLE has a PARTITION BY clause
- if ctx.Optpartitionspec() != nil && ctx.Optpartitionspec().Partitionspec() != nil {
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ // Check if this is a partitioned table
+ if ctx.Optpartitionspec() != nil {
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CreateTablePartition.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("Table partition is forbidden, but \"%s\" creates", stmtText),
+ Title: r.title,
+ Content: fmt.Sprintf("Table partition is forbidden, but %q creates", stmtText),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
Column: 0,
@@ -79,8 +100,7 @@ func (c *tableDisallowPartitionChecker) EnterCreatestmt(ctx *parser.CreatestmtCo
}
}
-// EnterPartition_cmd handles ALTER TABLE ... ATTACH PARTITION
-func (c *tableDisallowPartitionChecker) EnterPartition_cmd(ctx *parser.Partition_cmdContext) {
+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
@@ -92,18 +112,18 @@ func (c *tableDisallowPartitionChecker) EnterPartition_cmd(ctx *parser.Partition
parent := ctx.GetParent()
for parent != nil {
if alterTableCtx, ok := parent.(*parser.AltertablestmtContext); ok {
- stmtText := extractStatementText(c.statementsText, alterTableCtx.GetStart().GetLine(), alterTableCtx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ stmtText := extractStatementText(r.statementsText, alterTableCtx.GetStart().GetLine(), alterTableCtx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.CreateTablePartition.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("Table partition is forbidden, but \"%s\" creates", stmtText),
+ Title: r.title,
+ Content: fmt.Sprintf("Table partition is forbidden, but %q creates", stmtText),
StartPosition: &storepb.Position{
Line: int32(alterTableCtx.GetStart().GetLine()),
Column: 0,
},
})
- break
+ return
}
parent = parent.GetParent()
}
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 5713e1e0d6..a0845e22c4 100644
--- a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go
+++ b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go
@@ -43,29 +43,47 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advis
return nil, err
}
- checker := &tableDropNamingConventionChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- format: format,
+ rule := &tableDropNamingConventionRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ format: format,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type tableDropNamingConventionChecker struct {
- *parser.BasePostgreSQLParserListener
+type tableDropNamingConventionRule struct {
+ BaseRule
+ format *regexp.Regexp
+}
+
+// Name returns the rule name.
+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
+}
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
- format *regexp.Regexp
+// OnExit is called when the parser exits a rule context.
+func (*tableDropNamingConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {
+ return nil
}
-// EnterDropstmt handles DROP TABLE statements
-func (c *tableDropNamingConventionChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+func (r *tableDropNamingConventionRule) handleDropstmt(ctx *parser.DropstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -79,13 +97,13 @@ func (c *tableDropNamingConventionChecker) EnterDropstmt(ctx *parser.DropstmtCon
if ctx.Any_name_list() != nil {
allNames := ctx.Any_name_list().AllAny_name()
for _, nameCtx := range allNames {
- tableName := c.extractTableNameFromAnyName(nameCtx)
- if tableName != "" && !c.format.MatchString(tableName) {
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ tableName := r.extractTableNameFromAnyName(nameCtx)
+ if tableName != "" && !r.format.MatchString(tableName) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.TableDropNamingConventionMismatch.Int32(),
- Title: c.title,
- Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", tableName, c.format),
+ 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,
@@ -98,7 +116,7 @@ func (c *tableDropNamingConventionChecker) EnterDropstmt(ctx *parser.DropstmtCon
// extractTableNameFromAnyName extracts the table name from Any_name context.
// For schema.table, returns "table". For just "table", returns "table".
-func (*tableDropNamingConventionChecker) extractTableNameFromAnyName(ctx parser.IAny_nameContext) string {
+func (*tableDropNamingConventionRule) extractTableNameFromAnyName(ctx parser.IAny_nameContext) string {
parts := pg.NormalizePostgreSQLAnyName(ctx)
if len(parts) == 0 {
return ""
diff --git a/backend/plugin/advisor/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.go
index 6bbd44a4c4..42c94259dc 100644
--- a/backend/plugin/advisor/pg/advisor_table_no_fk.go
+++ b/backend/plugin/advisor/pg/advisor_table_no_fk.go
@@ -36,35 +36,59 @@ func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*
return nil, err
}
- checker := &tableNoFKChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
+ rule := &tableNoFKRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
-type tableNoFKChecker struct {
- *parser.BasePostgreSQLParserListener
+type tableNoFKRule struct {
+ BaseRule
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
statementsText string
}
-// EnterCreatestmt handles CREATE TABLE with FK constraints
-func (c *tableNoFKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+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)
+ 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(ctx antlr.ParserRuleContext) {
+ createstmtCtx, ok := ctx.(*parser.CreatestmtContext)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(createstmtCtx.GetParent()) {
return
}
var tableName, schemaName string
- allQualifiedNames := ctx.AllQualified_name()
+ allQualifiedNames := createstmtCtx.AllQualified_name()
if len(allQualifiedNames) > 0 {
tableName = extractTableName(allQualifiedNames[0])
schemaName = extractSchemaName(allQualifiedNames[0])
@@ -74,8 +98,8 @@ func (c *tableNoFKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
}
// Check table-level constraints
- if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
- allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ 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 {
@@ -84,7 +108,7 @@ func (c *tableNoFKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
constraintElem := constraint.Constraintelem()
// Check for FOREIGN KEY
if constraintElem.FOREIGN() != nil && constraintElem.KEY() != nil {
- c.addFKAdvice(schemaName, tableName, ctx)
+ r.addFKAdvice(schemaName, tableName, createstmtCtx)
return
}
}
@@ -100,7 +124,7 @@ func (c *tableNoFKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
constraintElem := qual.Colconstraintelem()
// Check for REFERENCES (column-level FK)
if constraintElem.REFERENCES() != nil {
- c.addFKAdvice(schemaName, tableName, ctx)
+ r.addFKAdvice(schemaName, tableName, createstmtCtx)
return
}
}
@@ -111,24 +135,29 @@ func (c *tableNoFKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
}
}
-// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT with FK
-func (c *tableNoFKChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
- if !isTopLevel(ctx.GetParent()) {
+// handleAltertablestmt handles ALTER TABLE ADD CONSTRAINT with FK
+func (r *tableNoFKRule) handleAltertablestmt(ctx antlr.ParserRuleContext) {
+ altertablestmtCtx, ok := ctx.(*parser.AltertablestmtContext)
+ if !ok {
+ return
+ }
+
+ if !isTopLevel(altertablestmtCtx.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 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 ctx.Alter_table_cmds() != nil {
- allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ 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()
@@ -136,7 +165,7 @@ func (c *tableNoFKChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext
constraintElem := constraint.Constraintelem()
// Check for FOREIGN KEY
if constraintElem.FOREIGN() != nil && constraintElem.KEY() != nil {
- c.addFKAdvice(schemaName, tableName, ctx)
+ r.addFKAdvice(schemaName, tableName, altertablestmtCtx)
return
}
}
@@ -145,12 +174,12 @@ func (c *tableNoFKChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext
}
}
-func (c *tableNoFKChecker) addFKAdvice(schemaName, tableName string, ctx antlr.ParserRuleContext) {
- stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+func (r *tableNoFKRule) addFKAdvice(schemaName, tableName string, ctx antlr.ParserRuleContext) {
+ stmtText := extractStatementText(r.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.TableHasFK.Int32(),
- Title: c.title,
+ Title: r.title,
Content: fmt.Sprintf("Foreign key is not allowed in the table %q.%q, related statement: \"%s\"", schemaName, tableName, stmtText),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.go
index 7806baae08..7bca05a484 100644
--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go
+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go
@@ -38,21 +38,23 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)
return nil, err
}
- checker := &tableRequirePKChecker{
- BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
- level: level,
- title: string(checkCtx.Rule.Type),
- statementsText: checkCtx.Statements,
- catalog: checkCtx.Catalog,
- tableMentions: make(map[string]*tableMention),
+ rule := &tableRequirePKRule{
+ BaseRule: BaseRule{
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ },
+ statementsText: checkCtx.Statements,
+ catalog: checkCtx.Catalog,
+ tableMentions: make(map[string]*tableMention),
}
+ checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
// Simple Solution: Validate final state after walking all statements
- checker.validateFinalState()
+ rule.validateFinalState()
- return checker.adviceList, nil
+ return checker.GetAdviceList(), nil
}
type tableMention struct {
@@ -60,12 +62,8 @@ type tableMention struct {
endLine int
}
-type tableRequirePKChecker struct {
- *parser.BasePostgreSQLParserListener
-
- adviceList []*storepb.Advice
- level storepb.Advice_Status
- title string
+type tableRequirePKRule struct {
+ BaseRule
statementsText string
catalog *catalog.Finder
@@ -73,8 +71,33 @@ type tableRequirePKChecker struct {
tableMentions map[string]*tableMention // key: "schema.table", value: last mention info
}
-// EnterCreatestmt records CREATE TABLE statements (Simple Solution)
-func (c *tableRequirePKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+// Name returns the rule name.
+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))
+ 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()) {
return
}
@@ -91,14 +114,14 @@ func (c *tableRequirePKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
// Simple Solution: Just record the table mention (ALWAYS update for last occurrence)
key := fmt.Sprintf("%s.%s", schemaName, tableName)
- c.tableMentions[key] = &tableMention{
+ r.tableMentions[key] = &tableMention{
startLine: ctx.GetStart().GetLine(),
endLine: ctx.GetStop().GetLine(),
}
}
-// EnterAltertablestmt records ALTER TABLE statements (Simple Solution)
-func (c *tableRequirePKChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+// handleAltertablestmt records ALTER TABLE statements (Simple Solution)
+func (r *tableRequirePKRule) handleAltertablestmt(ctx *parser.AltertablestmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -114,14 +137,14 @@ func (c *tableRequirePKChecker) EnterAltertablestmt(ctx *parser.AltertablestmtCo
// Simple Solution: Just record the table mention (ALWAYS update for last occurrence)
key := fmt.Sprintf("%s.%s", schemaName, tableName)
- c.tableMentions[key] = &tableMention{
+ r.tableMentions[key] = &tableMention{
startLine: ctx.GetStart().GetLine(),
endLine: ctx.GetStop().GetLine(),
}
}
-// EnterDropstmt handles DROP TABLE - remove from tracking
-func (c *tableRequirePKChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+// handleDropstmt handles DROP TABLE - remove from tracking
+func (r *tableRequirePKRule) handleDropstmt(ctx *parser.DropstmtContext) {
if !isTopLevel(ctx.GetParent()) {
return
}
@@ -141,7 +164,7 @@ func (c *tableRequirePKChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
// Simple table name (most common case)
name := pgparser.NormalizePostgreSQLColid(anyName.Colid())
key := fmt.Sprintf("public.%s", name)
- delete(c.tableMentions, key)
+ 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
@@ -150,13 +173,13 @@ func (c *tableRequirePKChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
}
// validateFinalState checks all mentioned tables against catalog.Final (Simple Solution)
-func (c *tableRequirePKChecker) validateFinalState() {
- for tableKey, mention := range c.tableMentions {
+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
- hasPK := c.catalog.Final.HasPrimaryKey(&catalog.PrimaryKeyFind{
+ hasPK := r.catalog.Final.HasPrimaryKey(&catalog.PrimaryKeyFind{
SchemaName: schemaName,
TableName: tableName,
})
@@ -165,15 +188,15 @@ func (c *tableRequirePKChecker) validateFinalState() {
content := fmt.Sprintf("Table %q.%q requires PRIMARY KEY", schemaName, tableName)
// Extract and include the related statement
- statement := extractStatementText(c.statementsText, mention.startLine, mention.endLine)
+ statement := extractStatementText(r.statementsText, mention.startLine, mention.endLine)
if statement != "" {
content = fmt.Sprintf("%s, related statement: %q", content, statement)
}
- c.adviceList = append(c.adviceList, &storepb.Advice{
- Status: c.level,
+ r.AddAdvice(&storepb.Advice{
+ Status: r.level,
Code: advisor.TableNoPK.Int32(),
- Title: c.title,
+ Title: r.title,
Content: content,
StartPosition: &storepb.Position{
Line: int32(mention.startLine),
diff --git a/backend/plugin/advisor/pg/generic_checker.go b/backend/plugin/advisor/pg/generic_checker.go
new file mode 100644
index 0000000000..b3f909ed58
--- /dev/null
+++ b/backend/plugin/advisor/pg/generic_checker.go
@@ -0,0 +1,107 @@
+package pg
+
+import (
+ "fmt"
+ "reflect"
+ "strings"
+
+ "github.com/antlr4-go/antlr/v4"
+ parser "github.com/bytebase/parser/postgresql"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+)
+
+// Rule defines the interface for individual SQL validation rules.
+// Each rule implements specific checking logic without embedding the base listener.
+type Rule interface {
+ // OnEnter is called when entering a parse tree node
+ OnEnter(ctx antlr.ParserRuleContext, nodeType string) error
+
+ // OnExit is called when exiting a parse tree node
+ OnExit(ctx antlr.ParserRuleContext, nodeType string) error
+
+ // Name returns the rule name for logging/debugging
+ Name() string
+
+ // GetAdviceList returns the accumulated advice from this rule
+ GetAdviceList() []*storepb.Advice
+}
+
+// GenericChecker embeds the base PostgreSQL parser listener and dispatches events to registered rules.
+// This design ensures only one copy of the listener type metadata in the binary.
+type GenericChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ rules []Rule
+}
+
+// NewGenericChecker creates a new instance of GenericChecker with the given rules.
+func NewGenericChecker(rules []Rule) *GenericChecker {
+ return &GenericChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ rules: rules,
+ }
+}
+
+// EnterEveryRule is called when any rule is entered.
+// It dispatches the event to all registered rules.
+func (g *GenericChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
+ nodeType := g.getNodeType(ctx)
+ for _, rule := range g.rules {
+ if err := rule.OnEnter(ctx, nodeType); err != nil {
+ // Log error if needed
+ fmt.Printf("Rule %s error on enter %s: %v\n", rule.Name(), nodeType, err)
+ }
+ }
+}
+
+// ExitEveryRule is called when any rule is exited.
+// It dispatches the event to all registered rules.
+func (g *GenericChecker) ExitEveryRule(ctx antlr.ParserRuleContext) {
+ nodeType := g.getNodeType(ctx)
+ for _, rule := range g.rules {
+ if err := rule.OnExit(ctx, nodeType); err != nil {
+ // Log error if needed
+ fmt.Printf("Rule %s error on exit %s: %v\n", rule.Name(), nodeType, err)
+ }
+ }
+}
+
+// GetAdviceList collects and returns all advice from registered rules.
+func (g *GenericChecker) GetAdviceList() []*storepb.Advice {
+ var allAdvice []*storepb.Advice
+ for _, rule := range g.rules {
+ allAdvice = append(allAdvice, rule.GetAdviceList()...)
+ }
+ return allAdvice
+}
+
+// getNodeType returns the type name of the parse tree node.
+func (*GenericChecker) getNodeType(ctx antlr.ParserRuleContext) string {
+ t := reflect.TypeOf(ctx)
+ if t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ }
+ name := t.Name()
+ // Remove "Context" suffix if present
+ name = strings.TrimSuffix(name, "Context")
+ return name
+}
+
+// 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
+}
+
+// GetAdviceList returns the accumulated advice.
+func (r *BaseRule) GetAdviceList() []*storepb.Advice {
+ return r.adviceList
+}
+
+// AddAdvice adds a new advice to the list.
+func (r *BaseRule) AddAdvice(advice *storepb.Advice) {
+ r.adviceList = append(r.adviceList, advice)
+}