Skip to content

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

feat: migrate final 7 PostgreSQL advisors to ANTLR parser (#17865)

h3n4lf83a2867afc6
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_maximum_limit_value.go b/backend/plugin/advisor/pgantlr/advisor_statement_maximum_limit_value.go
new file mode 100644
index 0000000000..a2626ec587
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_maximum_limit_value.go
@@ -0,0 +1,234 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "strconv"
+ "strings"
+
+ "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"
+)
+
+var (
+ _ advisor.Advisor = (*StatementMaximumLimitValueAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementMaximumLimitValue, &StatementMaximumLimitValueAdvisor{})
+}
+
+// StatementMaximumLimitValueAdvisor is the advisor checking for maximum LIMIT value.
+type StatementMaximumLimitValueAdvisor struct {
+}
+
+// Check checks for maximum LIMIT value.
+func (*StatementMaximumLimitValueAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ payload, err := advisor.UnmarshalNumberTypeRulePayload(checkCtx.Rule.Payload)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &statementMaximumLimitValueChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ limitMaxValue: payload.Number,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementMaximumLimitValueChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ limitMaxValue int
+}
+
+// EnterSelectstmt handles SELECT statements with LIMIT clauses.
+func (c *statementMaximumLimitValueChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // 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,
+ Code: advisor.StatementExceedMaximumLimitValue.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("The limit value %d exceeds the maximum allowed value %d", limitValue, c.limitMaxValue),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// 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 {
+ if ctx == nil {
+ return 0
+ }
+
+ // Try select_no_parens
+ if ctx.Select_no_parens() != nil {
+ return c.extractLimitFromSelectNoParens(ctx.Select_no_parens())
+ }
+
+ // Try select_with_parens
+ if ctx.Select_with_parens() != nil {
+ return c.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 {
+ if ctx == nil {
+ return 0
+ }
+
+ var selectLimit parser.ISelect_limitContext
+ if ctx.Select_limit() != nil {
+ selectLimit = ctx.Select_limit()
+ }
+ if ctx.Opt_select_limit() != nil {
+ selectLimit = ctx.Opt_select_limit().Select_limit()
+ }
+
+ // Check for select_limit directly in select_no_parens
+ if selectLimit != nil {
+ return c.extractLimitFromSelectLimit(selectLimit)
+ }
+
+ return 0
+}
+
+// extractLimitFromSelectWithParens extracts LIMIT value from select_with_parens.
+func (c *statementMaximumLimitValueChecker) 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())
+ }
+
+ if ctx.Select_with_parens() != nil {
+ return c.extractLimitFromSelectWithParens(ctx.Select_with_parens())
+ }
+
+ return 0
+}
+
+// extractLimitFromSelectLimit extracts LIMIT value from select_limit clause.
+func (c *statementMaximumLimitValueChecker) extractLimitFromSelectLimit(ctx parser.ISelect_limitContext) int {
+ if ctx == nil {
+ return 0
+ }
+
+ // PostgreSQL supports several LIMIT formats:
+ // 1. LIMIT count
+ // 2. LIMIT count OFFSET start
+ // 3. OFFSET start (without LIMIT)
+ // 4. LIMIT ALL
+
+ // Check for limit_clause
+ if ctx.Limit_clause() != nil {
+ limitClause := ctx.Limit_clause()
+ // Get the select_limit_value
+ if limitClause.Select_limit_value() != nil {
+ return c.extractLimitValueFromLimitValue(limitClause.Select_limit_value())
+ }
+ }
+
+ // Check for offset_clause (which may have FETCH FIRST/NEXT)
+ if ctx.Offset_clause() != nil {
+ offsetClause := ctx.Offset_clause()
+ // Check for FETCH FIRST/NEXT syntax
+ if offsetClause.Select_fetch_first_value() != nil {
+ return c.extractLimitValueFromFetchFirst(offsetClause.Select_fetch_first_value())
+ }
+ }
+
+ return 0
+}
+
+// extractLimitValueFromLimitValue extracts integer value from select_limit_value.
+func (c *statementMaximumLimitValueChecker) extractLimitValueFromLimitValue(ctx parser.ISelect_limit_valueContext) int {
+ if ctx == nil {
+ return 0
+ }
+
+ // Check for ALL keyword (means no limit)
+ if ctx.ALL() != nil {
+ return 0
+ }
+
+ // Check for a_expr which contains the actual value
+ if ctx.A_expr() != nil {
+ return c.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 {
+ if ctx == nil {
+ return 0
+ }
+
+ // Try to extract the numeric value from the text
+ text := ctx.GetText()
+ return c.parseIntFromText(text)
+}
+
+// extractIntFromAExpr attempts to extract an integer constant from an a_expr.
+func (c *statementMaximumLimitValueChecker) 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)
+}
+
+// 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 {
+ // Clean up the text (remove whitespace)
+ text = strings.TrimSpace(text)
+
+ // Try to parse as integer
+ val, err := strconv.Atoi(text)
+ if err != nil {
+ return 0
+ }
+
+ return val
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_merge_alter_table.go b/backend/plugin/advisor/pgantlr/advisor_statement_merge_alter_table.go
new file mode 100644
index 0000000000..9c0c1029fb
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_merge_alter_table.go
@@ -0,0 +1,175 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "slices"
+
+ "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"
+)
+
+var (
+ _ advisor.Advisor = (*StatementMergeAlterTableAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementMergeAlterTable, &StatementMergeAlterTableAdvisor{})
+}
+
+// StatementMergeAlterTableAdvisor is the advisor checking for no redundant ALTER TABLE statements.
+type StatementMergeAlterTableAdvisor struct {
+}
+
+// Check checks for no redundant ALTER TABLE statements.
+func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &statementMergeAlterTableChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ tableMap: make(tableMap),
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.generateAdvice(), nil
+}
+
+type statementMergeAlterTableChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ level storepb.Advice_Status
+ title string
+ tableMap tableMap
+}
+
+type tableMap map[string]tableStatement
+
+type tableStatement struct {
+ schema string
+ name string
+ count int
+ line int
+}
+
+func (m tableMap) set(schema string, table string, line int) {
+ t := tableStatement{
+ schema: schema,
+ name: table,
+ count: 1,
+ line: line,
+ }
+ m[t.key()] = t
+}
+
+func (m tableMap) add(schema string, table string, line int) {
+ if t, exists := m[fmt.Sprintf("%s.%s", schema, table)]; exists {
+ t.count++
+ t.line = line
+ m[t.key()] = t
+ }
+}
+
+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,
+ },
+ })
+ }
+ }
+
+ return adviceList
+}
+
+// EnterCreatestmt is called when production createstmt is entered.
+func (checker *statementMergeAlterTableChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ allQualifiedNames := ctx.AllQualified_name()
+ if len(allQualifiedNames) == 0 {
+ return
+ }
+
+ qualifiedName := allQualifiedNames[0]
+ tableName := extractTableName(qualifiedName)
+ schema := extractSchemaName(qualifiedName)
+ if schema == "" {
+ schema = "public"
+ }
+
+ if tableName == "" {
+ return
+ }
+
+ checker.tableMap.set(schema, tableName, ctx.GetStop().GetLine())
+}
+
+// EnterAltertablestmt is called when production altertablestmt is entered.
+func (checker *statementMergeAlterTableChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ relationExpr := ctx.Relation_expr()
+ if relationExpr == nil {
+ return
+ }
+
+ qualifiedName := relationExpr.Qualified_name()
+ if qualifiedName == nil {
+ return
+ }
+
+ tableName := extractTableName(qualifiedName)
+ schema := extractSchemaName(qualifiedName)
+ if schema == "" {
+ schema = "public"
+ }
+
+ if tableName == "" {
+ return
+ }
+
+ checker.tableMap.add(schema, tableName, ctx.GetStop().GetLine())
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_no_leading_wildcard_like.go b/backend/plugin/advisor/pgantlr/advisor_statement_no_leading_wildcard_like.go
new file mode 100644
index 0000000000..0021bea17f
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_no_leading_wildcard_like.go
@@ -0,0 +1,167 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "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"
+)
+
+var (
+ _ advisor.Advisor = (*StatementNoLeadingWildcardLikeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementNoLeadingWildcardLike, &StatementNoLeadingWildcardLikeAdvisor{})
+}
+
+// StatementNoLeadingWildcardLikeAdvisor is the advisor checking for no leading wildcard LIKE.
+type StatementNoLeadingWildcardLikeAdvisor struct {
+}
+
+// Check checks for no leading wildcard LIKE.
+func (*StatementNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &statementNoLeadingWildcardLikeChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ reportedStatements: make(map[antlr.ParserRuleContext]bool),
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementNoLeadingWildcardLikeChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ 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) {
+ // Check if this is a LIKE or ILIKE expression (not SIMILAR TO)
+ if ctx.LIKE() == nil && ctx.ILIKE() == nil {
+ return
+ }
+
+ // Get the pattern (second A_expr_qual_op)
+ qualOps := ctx.AllA_expr_qual_op()
+ if len(qualOps) < 2 {
+ return
+ }
+
+ pattern := qualOps[1]
+ patternStr := extractPatternString(pattern)
+
+ // Check if pattern starts with wildcard
+ if patternStr != "" && (strings.HasPrefix(patternStr, "%") || strings.HasPrefix(patternStr, "_")) {
+ // Find the top-level statement for reporting
+ stmtCtx := findTopLevelStatement(ctx)
+ if stmtCtx == nil {
+ return
+ }
+
+ // Only report once per statement
+ if c.reportedStatements[stmtCtx] {
+ return
+ }
+ c.reportedStatements[stmtCtx] = true
+
+ stmtText := extractStatementText(c.statementsText, stmtCtx.GetStart().GetLine(), stmtCtx.GetStop().GetLine())
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.StatementLeadingWildcardLike.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\" uses leading wildcard LIKE", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(stmtCtx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// extractPatternString extracts the string literal from a LIKE pattern expression
+func extractPatternString(ctx parser.IA_expr_qual_opContext) string {
+ if ctx == nil {
+ return ""
+ }
+
+ // Walk down the expression tree to find the string constant
+ // The structure is: A_expr_qual_op -> ... -> Aexprconst -> Sconst -> Anysconst -> Terminal
+ var findSconst func(antlr.Tree) parser.ISconstContext
+ findSconst = func(node antlr.Tree) parser.ISconstContext {
+ if node == nil {
+ return nil
+ }
+
+ // Check if this is a Sconst context
+ if sconst, ok := node.(parser.ISconstContext); ok {
+ return sconst
+ }
+
+ // Recursively check children
+ if prCtx, ok := node.(antlr.ParserRuleContext); ok {
+ for i := 0; i < prCtx.GetChildCount(); i++ {
+ if result := findSconst(prCtx.GetChild(i)); result != nil {
+ return result
+ }
+ }
+ }
+
+ return nil
+ }
+
+ sconstCtx := findSconst(ctx)
+ if sconstCtx == nil {
+ return ""
+ }
+
+ // Extract the string value from the Sconst context
+ // The text includes quotes, so we need to remove them
+ text := sconstCtx.GetText()
+ if len(text) >= 2 && text[0] == '\'' && text[len(text)-1] == '\'' {
+ return text[1 : len(text)-1]
+ }
+
+ return text
+}
+
+// findTopLevelStatement finds the top-level statement containing the given context
+func findTopLevelStatement(ctx antlr.ParserRuleContext) antlr.ParserRuleContext {
+ current := ctx
+ for current != nil {
+ parent := current.GetParent()
+ if isTopLevel(parent) {
+ return current
+ }
+ if prCtx, ok := parent.(antlr.ParserRuleContext); ok {
+ current = prCtx
+ } else {
+ break
+ }
+ }
+ return current
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_no_select_all.go b/backend/plugin/advisor/pgantlr/advisor_statement_no_select_all.go
new file mode 100644
index 0000000000..56a1775101
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_no_select_all.go
@@ -0,0 +1,122 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+
+ "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"
+)
+
+var (
+ _ advisor.Advisor = (*NoSelectAllAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementNoSelectAll, &NoSelectAllAdvisor{})
+}
+
+// NoSelectAllAdvisor is the advisor checking for no "select *".
+type NoSelectAllAdvisor struct {
+}
+
+// Check checks for no "select *".
+func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &noSelectAllChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type noSelectAllChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ statementsText string
+}
+
+// EnterSimple_select_pramary checks for SELECT * in simple select statements
+func (c *noSelectAllChecker) EnterSimple_select_pramary(ctx *parser.Simple_select_pramaryContext) {
+ // Check if this is a SELECT statement with target list
+ if ctx.SELECT() == nil {
+ return
+ }
+
+ // Check the target list for * (asterisk)
+ if ctx.Opt_target_list() != nil && ctx.Opt_target_list().Target_list() != nil {
+ targetList := ctx.Opt_target_list().Target_list()
+ allTargets := targetList.AllTarget_el()
+
+ for _, target := range allTargets {
+ // Check if target is a Target_star (SELECT *)
+ if _, ok := target.(*parser.Target_starContext); ok {
+ // Find the top-level statement context to get the full statement text
+ var stmtCtx antlr.ParserRuleContext
+ parent := ctx.GetParent()
+ for parent != nil {
+ // Look for top-level statement contexts
+ switch p := parent.(type) {
+ case *parser.SelectstmtContext:
+ if isTopLevel(p.GetParent()) {
+ stmtCtx = p
+ }
+ case *parser.InsertstmtContext:
+ if isTopLevel(p.GetParent()) {
+ stmtCtx = p
+ }
+ }
+ if stmtCtx != nil {
+ break
+ }
+ parent = parent.GetParent()
+ }
+
+ // If we found a top-level statement, extract its text
+ var stmtText string
+ var line int
+ if stmtCtx != nil {
+ stmtText = extractStatementText(c.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())
+ line = ctx.GetStart().GetLine()
+ }
+
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.StatementSelectAll.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\" uses SELECT all", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ return
+ }
+ }
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_object_owner_check.go b/backend/plugin/advisor/pgantlr/advisor_statement_object_owner_check.go
new file mode 100644
index 0000000000..6a7d163729
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_object_owner_check.go
@@ -0,0 +1,484 @@
+package pgantlr
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+ "log/slog"
+
+ "github.com/antlr4-go/antlr/v4"
+ parser "github.com/bytebase/parser/postgresql"
+
+ "github.com/bytebase/bytebase/backend/common/log"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*StatementObjectOwnerCheckAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementObjectOwnerCheck, &StatementObjectOwnerCheckAdvisor{})
+}
+
+const (
+ pgDatabaseOwner = "pg_database_owner"
+)
+
+type StatementObjectOwnerCheckAdvisor struct {
+}
+
+func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ dbMetadata := model.NewDatabaseMetadata(checkCtx.DBSchema, checkCtx.IsObjectCaseSensitive, true /* IsDetailCaseSensitive */)
+ currentRole := checkCtx.DBSchema.Owner
+ if !checkCtx.UsePostgresDatabaseOwner {
+ currentRole, err = getCurrentUser(ctx, checkCtx.Driver)
+ if err != nil {
+ slog.Debug("Failed to get current user", log.BBError(err))
+ currentRole = checkCtx.DBSchema.Owner
+ }
+ }
+
+ checker := &statementObjectOwnerCheckChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ dbMetadata: dbMetadata,
+ currentRole: currentRole,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementObjectOwnerCheckChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ dbMetadata *model.DatabaseMetadata
+ currentRole string
+}
+
+// EnterVariablesetstmt handles SET ROLE statements
+func (*statementObjectOwnerCheckChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is SET ROLE
+ // Note: This is a simplified version that doesn't extract and update the role
+ // The actual role name extraction would require parsing the var_list
+ // For now, we skip updating currentRole from SET ROLE to keep it simple
+}
+
+func (c *statementObjectOwnerCheckChecker) checkSchemaOwnership(schemaName string, line int) {
+ if schemaName == "" {
+ schemaName = defaultSchema
+ }
+
+ schemaMeta := c.dbMetadata.GetSchema(schemaName)
+ if schemaMeta == nil {
+ return
+ }
+
+ owner := schemaMeta.GetOwner()
+ if owner == pgDatabaseOwner {
+ owner = c.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),
+ Code: advisor.StatementObjectOwnerCheck.Int32(),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+}
+
+func (c *statementObjectOwnerCheckChecker) checkTableOwnership(schemaName, tableName string, line int) {
+ if schemaName == "" {
+ schemaName = defaultSchema
+ }
+
+ schemaMeta := c.dbMetadata.GetSchema(schemaName)
+ if schemaMeta == nil {
+ return
+ }
+
+ tableMeta := schemaMeta.GetTable(tableName)
+ if tableMeta == nil {
+ return
+ }
+
+ owner := tableMeta.GetOwner()
+ if owner == pgDatabaseOwner {
+ owner = c.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),
+ Code: advisor.StatementObjectOwnerCheck.Int32(),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// EnterAlterseqstmt handles ALTER SEQUENCE statements
+func (c *statementObjectOwnerCheckChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ qualName := ctx.Qualified_name()
+ if qualName == nil {
+ return
+ }
+
+ schemaName := extractSchemaName(qualName)
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterAltertablestmt handles ALTER TABLE statements
+func (c *statementObjectOwnerCheckChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+
+ qualName := ctx.Relation_expr().Qualified_name()
+ schemaName := extractSchemaName(qualName)
+ tableName := extractTableName(qualName)
+
+ c.checkTableOwnership(schemaName, tableName, ctx.GetStart().GetLine())
+}
+
+// EnterAltertypestmt handles ALTER TYPE statements
+func (c *statementObjectOwnerCheckChecker) EnterAltertypestmt(ctx *parser.AltertypestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Any_name() == nil {
+ return
+ }
+
+ anyName := ctx.Any_name()
+ parts := pg.NormalizePostgreSQLAnyName(anyName)
+
+ var schemaName string
+ if len(parts) >= 2 {
+ schemaName = parts[0]
+ }
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterCreateextensionstmt handles CREATE EXTENSION statements
+func (c *statementObjectOwnerCheckChecker) EnterCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Extract schema name from create_extension_opt_list
+ schemaName := defaultSchema
+ if optList := ctx.Create_extension_opt_list(); optList != nil {
+ for _, opt := range optList.AllCreate_extension_opt_item() {
+ if opt.SCHEMA() != nil && opt.Name() != nil {
+ schemaName = opt.Name().GetText()
+ break
+ }
+ }
+ }
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterCreatefunctionstmt handles CREATE FUNCTION statements
+func (c *statementObjectOwnerCheckChecker) EnterCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Func_name() == nil {
+ return
+ }
+
+ schemaName := c.extractSchemaFromFuncName(ctx.Func_name())
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterIndexstmt handles CREATE INDEX statements
+func (c *statementObjectOwnerCheckChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+
+ qualName := ctx.Relation_expr().Qualified_name()
+ schemaName := extractSchemaName(qualName)
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterCreateschemastmt handles CREATE SCHEMA statements
+func (c *statementObjectOwnerCheckChecker) EnterCreateschemastmt(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),
+ Code: advisor.StatementObjectOwnerCheck.Int32(),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// EnterCreateseqstmt handles CREATE SEQUENCE statements
+func (c *statementObjectOwnerCheckChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Qualified_name() == nil {
+ return
+ }
+
+ qualName := ctx.Qualified_name()
+ schemaName := extractSchemaName(qualName)
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterCreatestmt handles CREATE TABLE statements
+func (c *statementObjectOwnerCheckChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ allQualNames := ctx.AllQualified_name()
+ if len(allQualNames) == 0 {
+ return
+ }
+
+ qualName := allQualNames[0]
+ schemaName := extractSchemaName(qualName)
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterCreatetrigstmt handles CREATE TRIGGER statements
+func (c *statementObjectOwnerCheckChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Qualified_name() == nil {
+ return
+ }
+
+ qualName := ctx.Qualified_name()
+ schemaName := extractSchemaName(qualName)
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterDefinestmt handles CREATE TYPE statements (via DEFINE)
+func (c *statementObjectOwnerCheckChecker) EnterDefinestmt(ctx *parser.DefinestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is a CREATE TYPE statement
+ if ctx.TYPE_P() == nil {
+ return
+ }
+
+ // Any_name(0) gets the first any_name
+ if ctx.Any_name(0) == nil {
+ return
+ }
+
+ anyName := ctx.Any_name(0)
+ parts := pg.NormalizePostgreSQLAnyName(anyName)
+
+ var schemaName string
+ if len(parts) >= 2 {
+ schemaName = parts[0]
+ }
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterCreatematviewstmt handles CREATE VIEW / MATERIALIZED VIEW statements
+func (c *statementObjectOwnerCheckChecker) EnterCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Create_mv_target() == nil || ctx.Create_mv_target().Qualified_name() == nil {
+ return
+ }
+
+ qualName := ctx.Create_mv_target().Qualified_name()
+ schemaName := extractSchemaName(qualName)
+
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+}
+
+// EnterRemovefuncstmt handles DROP FUNCTION statements
+func (c *statementObjectOwnerCheckChecker) EnterRemovefuncstmt(ctx *parser.RemovefuncstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Function_with_argtypes_list() == nil {
+ return
+ }
+
+ for _, funcWithArgs := range ctx.Function_with_argtypes_list().AllFunction_with_argtypes() {
+ if funcWithArgs.Func_name() == nil {
+ continue
+ }
+
+ schemaName := c.extractSchemaFromFuncName(funcWithArgs.Func_name())
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ }
+}
+
+// EnterDropstmt 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) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // For DROP INDEX, check schema ownership
+ if ctx.INDEX() != nil {
+ c.handleDropWithAnyNameList(ctx, false)
+ return
+ }
+
+ // For other DROP statements, check schema ownership
+ if ctx.Any_name_list() != nil {
+ c.handleDropWithAnyNameList(ctx, false)
+ }
+}
+
+func (c *statementObjectOwnerCheckChecker) handleDropWithAnyNameList(ctx *parser.DropstmtContext, checkTable bool) {
+ if ctx.Any_name_list() == nil {
+ return
+ }
+
+ for _, anyName := range ctx.Any_name_list().AllAny_name() {
+ parts := pg.NormalizePostgreSQLAnyName(anyName)
+ if len(parts) == 0 {
+ continue
+ }
+
+ var schemaName, objectName string
+ if len(parts) == 1 {
+ schemaName = ""
+ objectName = parts[0]
+ } else {
+ schemaName = parts[0]
+ objectName = parts[1]
+ }
+
+ if checkTable && objectName != "" {
+ c.checkTableOwnership(schemaName, objectName, ctx.GetStart().GetLine())
+ } else {
+ c.checkSchemaOwnership(schemaName, ctx.GetStart().GetLine())
+ }
+ }
+}
+
+// EnterRenamestmt handles RENAME statements (including ALTER INDEX RENAME)
+func (c *statementObjectOwnerCheckChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is an ALTER SCHEMA RENAME
+ if ctx.SCHEMA() != nil && ctx.Name(0) != nil {
+ schemaName := ctx.Name(0).GetText()
+ c.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())
+ }
+}
+
+// Helper method to extract schema name from function name
+func (*statementObjectOwnerCheckChecker) extractSchemaFromFuncName(funcName parser.IFunc_nameContext) string {
+ if funcName.Type_function_name() != nil {
+ // Simple function name without schema
+ return ""
+ }
+ if funcName.Indirection() != nil {
+ // Qualified function name with schema
+ parts := []string{}
+ if funcName.Colid() != nil {
+ parts = append(parts, pg.NormalizePostgreSQLColid(funcName.Colid()))
+ }
+ for _, attr := range funcName.Indirection().AllIndirection_el() {
+ if attr.Attr_name() != nil {
+ parts = append(parts, attr.Attr_name().GetText())
+ }
+ }
+ if len(parts) >= 2 {
+ return parts[0]
+ }
+ }
+ return ""
+}
+
+func getCurrentUser(ctx context.Context, driver *sql.DB) (string, error) {
+ var user string
+ err := driver.QueryRowContext(ctx, "SELECT CURRENT_USER").Scan(&user)
+ if err != nil {
+ return "", err
+ }
+ return user, nil
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_where_required_select.go b/backend/plugin/advisor/pgantlr/advisor_statement_where_required_select.go
new file mode 100644
index 0000000000..fa95a3ce32
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_where_required_select.go
@@ -0,0 +1,203 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+
+ "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"
+)
+
+var (
+ _ advisor.Advisor = (*StatementWhereRequiredSelectAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementRequireWhereForSelect, &StatementWhereRequiredSelectAdvisor{})
+}
+
+// StatementWhereRequiredSelectAdvisor is the advisor checking for WHERE clause requirement in SELECT statements.
+type StatementWhereRequiredSelectAdvisor struct {
+}
+
+// Check checks for WHERE clause requirement in SELECT statements.
+func (*StatementWhereRequiredSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &statementWhereRequiredSelectChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementWhereRequiredSelectChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ 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)
+ })
+}
+
+// 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)
+ if isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.checkSelect(ctx, ctx.GetStart(), ctx.GetStop(), func() (bool, bool) {
+ return c.checkSelectWithParensForWhere(ctx)
+ })
+}
+
+// checkSelect is a common function to check for WHERE clause requirement
+func (c *statementWhereRequiredSelectChecker) checkSelect(
+ ctx antlr.ParserRuleContext,
+ _ antlr.Token,
+ _ antlr.Token,
+ checkFunc func() (hasWhere bool, hasFrom bool),
+) {
+ // Check if this SELECT has a WHERE clause and FROM clause
+ hasWhere, hasFrom := checkFunc()
+
+ // Allow SELECT queries without a FROM clause to proceed, e.g. SELECT 1
+ if !hasFrom {
+ return
+ }
+
+ // If there's a WHERE clause, all good
+ if hasWhere {
+ return
+ }
+
+ // 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)
+
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.StatementNoWhere.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(stmtLine),
+ Column: 0,
+ },
+ })
+}
+
+// findTopLevelLine finds the line number of the top-level statement
+func (*statementWhereRequiredSelectChecker) findTopLevelLine(ctx antlr.ParserRuleContext) int {
+ for ctx != nil {
+ if isTopLevel(ctx.GetParent()) {
+ return ctx.GetStart().GetLine()
+ }
+ parent := ctx.GetParent()
+ if ruleCtx, ok := parent.(antlr.ParserRuleContext); ok {
+ ctx = ruleCtx
+ } else {
+ break
+ }
+ }
+ return ctx.GetStart().GetLine()
+}
+
+// checkSelectWithParensForWhere checks a select_with_parens for WHERE and FROM
+func (c *statementWhereRequiredSelectChecker) checkSelectWithParensForWhere(ctx parser.ISelect_with_parensContext) (hasWhere bool, hasFrom bool) {
+ if ctx == nil {
+ return false, false
+ }
+
+ // select_with_parens can contain either select_no_parens or another select_with_parens
+ if ctx.Select_no_parens() != nil {
+ selectNoParens := ctx.Select_no_parens()
+ if selectNoParens.Select_clause() != nil {
+ return c.checkSelectClause(selectNoParens.Select_clause())
+ }
+ }
+
+ if ctx.Select_with_parens() != nil {
+ return c.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) {
+ // 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())
+ }
+ }
+
+ // Try Select_with_parens
+ if ctx.Select_with_parens() != nil {
+ // For a selectstmt that directly contains select_with_parens,
+ // delegate to the recursive handler
+ return c.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) {
+ if selectClause == nil {
+ return false, false
+ }
+
+ // Get all simple_select_intersect
+ allIntersects := selectClause.AllSimple_select_intersect()
+ for _, intersect := range allIntersects {
+ if intersect == nil {
+ continue
+ }
+ // Get all simple_select_pramary (note: typo in parser, it's "pramary" not "primary")
+ allPrimary := intersect.AllSimple_select_pramary()
+ for _, primary := range allPrimary {
+ if primary == nil {
+ continue
+ }
+ // Check for WHERE clause
+ if primary.Where_clause() != nil {
+ hasWhere = true
+ }
+ // Check for FROM clause
+ if primary.From_clause() != nil {
+ hasFrom = true
+ }
+ }
+ }
+
+ return hasWhere, hasFrom
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_where_required_update_delete.go b/backend/plugin/advisor/pgantlr/advisor_statement_where_required_update_delete.go
new file mode 100644
index 0000000000..633aa09c24
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_where_required_update_delete.go
@@ -0,0 +1,102 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+
+ "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"
+)
+
+var (
+ _ advisor.Advisor = (*StatementWhereRequiredUpdateDeleteAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementRequireWhereForUpdateDelete, &StatementWhereRequiredUpdateDeleteAdvisor{})
+}
+
+// StatementWhereRequiredUpdateDeleteAdvisor is the advisor checking for WHERE clause requirement in UPDATE/DELETE.
+type StatementWhereRequiredUpdateDeleteAdvisor struct {
+}
+
+// Check checks for WHERE clause requirement in UPDATE/DELETE statements.
+func (*StatementWhereRequiredUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &statementWhereRequiredChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementWhereRequiredChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ statementsText string
+}
+
+// EnterUpdatestmt handles UPDATE statements
+func (c *statementWhereRequiredChecker) EnterUpdatestmt(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,
+ Code: advisor.StatementNoWhere.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// EnterDeletestmt handles DELETE statements
+func (c *statementWhereRequiredChecker) EnterDeletestmt(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,
+ Code: advisor.StatementNoWhere.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/pgantlr_test.go b/backend/plugin/advisor/pgantlr/pgantlr_test.go
index e06ebb844a..5900857897 100644
--- a/backend/plugin/advisor/pgantlr/pgantlr_test.go
+++ b/backend/plugin/advisor/pgantlr/pgantlr_test.go
@@ -34,6 +34,13 @@ func TestPostgreSQLANTLRRules(t *testing.T) {
advisor.SchemaRuleStatementInsertDisallowOrderByRand, // Migrated from legacy
advisor.SchemaRuleStatementInsertMustSpecifyColumn, // Migrated from legacy
advisor.SchemaRuleStatementInsertRowLimit, // Migrated from legacy
+ advisor.SchemaRuleStatementMaximumLimitValue, // Migrated from legacy
+ advisor.SchemaRuleStatementMergeAlterTable, // Migrated from legacy
+ advisor.SchemaRuleStatementNoLeadingWildcardLike, // Migrated from legacy
+ advisor.SchemaRuleStatementNoSelectAll, // Migrated from legacy
+ advisor.SchemaRuleStatementObjectOwnerCheck, // Migrated from legacy
+ advisor.SchemaRuleStatementRequireWhereForSelect, // Migrated from legacy
+ advisor.SchemaRuleStatementRequireWhereForUpdateDelete, // Migrated from legacy
advisor.SchemaRuleColumnNaming, // Migrated from legacy
advisor.SchemaRuleSchemaBackwardCompatibility, // Migrated from legacy
advisor.SchemaRuleStatementAddCheckNotValid, // Migrated from legacy
@@ -66,12 +73,13 @@ func TestPostgreSQLANTLRRules(t *testing.T) {
// Add SQL review type here if you need metadata for test.
var advisorNeedMockData = map[advisor.SQLReviewRuleType]bool{
- advisor.BuiltinRulePriorBackupCheck: true,
- advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case
- advisor.SchemaRuleFullyQualifiedObjectName: true, // Needs metadata for SELECT statement checks
- advisor.SchemaRuleIDXNaming: true, // Needs catalog for ALTER INDEX RENAME
- advisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes
- advisor.SchemaRulePKNaming: true, // Needs catalog for PRIMARY KEY USING INDEX
- advisor.SchemaRuleTableRequirePK: true, // Needs catalog for DROP CONSTRAINT/COLUMN checks
- advisor.SchemaRuleUKNaming: true, // Needs catalog for UNIQUE USING INDEX
+ advisor.BuiltinRulePriorBackupCheck: true,
+ advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case
+ advisor.SchemaRuleFullyQualifiedObjectName: true, // Needs metadata for SELECT statement checks
+ advisor.SchemaRuleIDXNaming: true, // Needs catalog for ALTER INDEX RENAME
+ advisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes
+ advisor.SchemaRulePKNaming: true, // Needs catalog for PRIMARY KEY USING INDEX
+ advisor.SchemaRuleStatementObjectOwnerCheck: true, // Needs catalog for ownership checks
+ advisor.SchemaRuleTableRequirePK: true, // Needs catalog for DROP CONSTRAINT/COLUMN checks
+ advisor.SchemaRuleUKNaming: true, // Needs catalog for UNIQUE USING INDEX
}
diff --git a/backend/plugin/advisor/pgantlr/test/statement_maximum_limit_value.yaml b/backend/plugin/advisor/pgantlr/test/statement_maximum_limit_value.yaml
new file mode 100644
index 0000000000..3b0124f5ea
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_maximum_limit_value.yaml
@@ -0,0 +1,12 @@
+- statement: |
+ SELECT * FROM employee LIMIT 1000000;
+ changeType: 1
+ want:
+ - status: 2
+ code: 222
+ title: statement.maximum-limit-value
+ content: The limit value 1000000 exceeds the maximum allowed value 1000
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_merge_alter_table.yaml b/backend/plugin/advisor/pgantlr/test/statement_merge_alter_table.yaml
new file mode 100644
index 0000000000..88e5ef986d
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_merge_alter_table.yaml
@@ -0,0 +1,16 @@
+- statement: ALTER TABLE tech_book ADD COLUMN a int
+ changeType: 1
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE tech_book ADD COLUMN a int;
+ ALTER TABLE t ADD COLUMN b int;
+ changeType: 1
+ want:
+ - status: 2
+ code: 207
+ title: statement.merge-alter-table
+ content: There are 2 statements to modify table `t`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_object_owner_check.yaml b/backend/plugin/advisor/pgantlr/test/statement_object_owner_check.yaml
new file mode 100644
index 0000000000..8ddd9dce80
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_object_owner_check.yaml
@@ -0,0 +1,14 @@
+# Basic test cases for statement.object-owner-check advisor
+# Since this advisor requires metadata and owner information, we use simple statements
+# that will pass when the owner matches the current role
+
+- statement: CREATE TABLE public.t(id int);
+ changeType: 1
+- statement: CREATE SCHEMA s1;
+ changeType: 1
+- statement: CREATE SEQUENCE public.seq1;
+ changeType: 1
+- statement: CREATE INDEX idx_t_id ON public.tech_book(id);
+ changeType: 1
+- statement: CREATE TYPE public.mood AS ENUM ('sad', 'happy');
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/test/statement_select_no_select_all.yaml b/backend/plugin/advisor/pgantlr/test/statement_select_no_select_all.yaml
new file mode 100644
index 0000000000..be1d9ece14
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_select_no_select_all.yaml
@@ -0,0 +1,35 @@
+- statement: SELECT * FROM t
+ changeType: 1
+ want:
+ - status: 2
+ code: 203
+ title: statement.select.no-select-all
+ content: '"SELECT * FROM t" uses SELECT all'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: SELECT a, b FROM t
+ changeType: 1
+- statement: SELECT a, b FROM (SELECT * from t1, t2) t
+ changeType: 1
+ want:
+ - status: 2
+ code: 203
+ title: statement.select.no-select-all
+ content: '"SELECT a, b FROM (SELECT * from t1, t2) t" uses SELECT all'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: INSERT INTO t SELECT * FROM t1
+ changeType: 1
+ want:
+ - status: 2
+ code: 203
+ title: statement.select.no-select-all
+ content: '"INSERT INTO t SELECT * FROM t1" uses SELECT all'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_where_no_leading_wildcard_like.yaml b/backend/plugin/advisor/pgantlr/test/statement_where_no_leading_wildcard_like.yaml
new file mode 100644
index 0000000000..1e2a33d904
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_where_no_leading_wildcard_like.yaml
@@ -0,0 +1,46 @@
+- statement: SELECT * FROM t WHERE a LIKE 'abc%'
+ changeType: 1
+- statement: SELECT * FROM t WHERE a LIKE '%abc'
+ changeType: 1
+ want:
+ - status: 2
+ code: 204
+ title: statement.where.no-leading-wildcard-like
+ content: '"SELECT * FROM t WHERE a LIKE ''%abc''" uses leading wildcard LIKE'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: SELECT * FROM t WHERE a LIKE 'abc' OR a LIKE '%abc'
+ changeType: 1
+ want:
+ - status: 2
+ code: 204
+ title: statement.where.no-leading-wildcard-like
+ content: '"SELECT * FROM t WHERE a LIKE ''abc'' OR a LIKE ''%abc''" uses leading wildcard LIKE'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: SELECT * FROM t WHERE a LIKE '%acc' OR a LIKE '%abc'
+ changeType: 1
+ want:
+ - status: 2
+ code: 204
+ title: statement.where.no-leading-wildcard-like
+ content: '"SELECT * FROM t WHERE a LIKE ''%acc'' OR a LIKE ''%abc''" uses leading wildcard LIKE'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: SELECT * FROM (SELECT * FROM t WHERE a LIKE '%acc' OR a LIKE '%abc') t1
+ changeType: 1
+ want:
+ - status: 2
+ code: 204
+ title: statement.where.no-leading-wildcard-like
+ content: '"SELECT * FROM (SELECT * FROM t WHERE a LIKE ''%acc'' OR a LIKE ''%abc'') t1" uses leading wildcard LIKE'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_where_require_select.yaml b/backend/plugin/advisor/pgantlr/test/statement_where_require_select.yaml
new file mode 100644
index 0000000000..9d01185a66
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_where_require_select.yaml
@@ -0,0 +1,26 @@
+- statement: SELECT a FROM t
+ changeType: 1
+ want:
+ - status: 2
+ code: 202
+ title: statement.where.require.select
+ content: '"SELECT a FROM t" requires WHERE clause'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: SELECT a FROM t WHERE a > 0
+ changeType: 1
+- statement: SELECT a FROM t WHERE a > (SELECT max(id) FROM user)
+ changeType: 1
+ want:
+ - status: 2
+ code: 202
+ title: statement.where.require.select
+ content: '"SELECT a FROM t WHERE a > (SELECT max(id) FROM user)" requires WHERE clause'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: SELECT 1
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/test/statement_where_require_update_delete.yaml b/backend/plugin/advisor/pgantlr/test/statement_where_require_update_delete.yaml
new file mode 100644
index 0000000000..0feac1472f
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_where_require_update_delete.yaml
@@ -0,0 +1,26 @@
+- statement: DELETE FROM t1
+ changeType: 1
+ want:
+ - status: 2
+ code: 202
+ title: statement.where.require.update-delete
+ content: '"DELETE FROM t1" requires WHERE clause'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: UPDATE t1 SET a = 1
+ changeType: 1
+ want:
+ - status: 2
+ code: 202
+ title: statement.where.require.update-delete
+ content: '"UPDATE t1 SET a = 1" requires WHERE clause'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: DELETE FROM t1 WHERE a > 0
+ changeType: 1
+- statement: UPDATE t1 SET a = 1 WHERE a > 10
+ changeType: 1