Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat: 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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 legacyadvisor.SchemaRuleStatementInsertMustSpecifyColumn, // Migrated from legacyadvisor.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 legacyadvisor.SchemaRuleColumnNaming, // Migrated from legacyadvisor.SchemaRuleSchemaBackwardCompatibility, // Migrated from legacyadvisor.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.yamlnew file mode 100644index 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: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_merge_alter_table.yaml b/backend/plugin/advisor/pgantlr/test/statement_merge_alter_table.yamlnew file mode 100644index 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: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_object_owner_check.yaml b/backend/plugin/advisor/pgantlr/test/statement_object_owner_check.yamlnew file mode 100644index 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: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_select_no_select_all.yaml b/backend/plugin/advisor/pgantlr/test/statement_select_no_select_all.yamlnew file mode 100644index 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: nulldiff --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.yamlnew file mode 100644index 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: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_where_require_select.yaml b/backend/plugin/advisor/pgantlr/test/statement_where_require_select.yamlnew file mode 100644index 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: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_where_require_update_delete.yaml b/backend/plugin/advisor/pgantlr/test/statement_where_require_update_delete.yamlnew file mode 100644index 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