Skip to content

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

feat: migrate 5 PostgreSQL advisors to ANTLR (#17830)

h3n4l81a777759ec7
diff --git a/backend/plugin/advisor/pgantlr/advisor_index_total_number_limit.go b/backend/plugin/advisor/pgantlr/advisor_index_total_number_limit.go
new file mode 100644
index 0000000000..13b6f37e91
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_index_total_number_limit.go
@@ -0,0 +1,267 @@
+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"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"
+)
+
+var (
+ _ advisor.Advisor = (*IndexTotalNumberLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleIndexTotalNumberLimit, &IndexTotalNumberLimitAdvisor{})
+}
+
+// IndexTotalNumberLimitAdvisor is the advisor checking for index total number limit.
+type IndexTotalNumberLimitAdvisor struct {
+}
+
+// Check checks for index total number limit.
+func (*IndexTotalNumberLimitAdvisor) 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 := &indexTotalNumberLimitChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ max: payload.Number,
+ catalog: checkCtx.Catalog,
+ tableLine: make(tableLineMap),
+ }
+
+ if checker.catalog.Final.Usable() {
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ }
+
+ return checker.generateAdvice(), nil
+}
+
+type tableLine struct {
+ schema string
+ table string
+ line int
+}
+
+type tableLineMap map[string]tableLine
+
+func (m tableLineMap) set(schema string, table string, line int) {
+ if schema == "" {
+ schema = "public"
+ }
+ m[fmt.Sprintf("%q.%q", schema, table)] = tableLine{
+ schema: schema,
+ table: table,
+ line: line,
+ }
+}
+
+type indexTotalNumberLimitChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ max int
+ catalog *catalog.Finder
+ tableLine tableLineMap
+}
+
+func (c *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice {
+ var tableList []tableLine
+ for _, table := range c.tableLine {
+ tableList = append(tableList, table)
+ }
+ slices.SortFunc(tableList, func(i, j tableLine) int {
+ if i.line < j.line {
+ return -1
+ }
+ if i.line > j.line {
+ return 1
+ }
+ return 0
+ })
+
+ for _, table := range tableList {
+ tableInfo := c.catalog.Final.FindTable(&catalog.TableFind{
+ SchemaName: table.schema,
+ TableName: table.table,
+ })
+ if tableInfo != nil && tableInfo.CountIndex() > c.max {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.IndexCountExceedsLimit.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("The count of index in table %q.%q should be no more than %d, but found %d", table.schema, table.table, c.max, tableInfo.CountIndex()),
+ StartPosition: &storepb.Position{
+ Line: int32(table.line),
+ Column: 0,
+ },
+ })
+ }
+ }
+
+ return c.adviceList
+}
+
+func (c *indexTotalNumberLimitChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ qualifiedNames := ctx.AllQualified_name()
+ if len(qualifiedNames) == 0 {
+ return
+ }
+
+ tableName := extractTableName(qualifiedNames[0])
+ if tableName == "" {
+ return
+ }
+
+ schemaName := extractSchemaName(qualifiedNames[0])
+
+ // Check if this CREATE TABLE statement creates any indexes
+ // (PRIMARY KEY or UNIQUE constraints)
+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ for _, elem := range allElements {
+ // Check column-level constraints
+ if elem.ColumnDef() != nil {
+ if hasIndexConstraint(elem.ColumnDef()) {
+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ return
+ }
+ }
+
+ // Check table-level constraints
+ if elem.Tableconstraint() != nil && hasTableIndexConstraint(elem.Tableconstraint()) {
+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ return
+ }
+ }
+ }
+}
+
+func (c *indexTotalNumberLimitChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+
+ tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+ if tableName == "" {
+ return
+ }
+
+ schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())
+
+ // Check ALTER TABLE commands that create indexes
+ if ctx.Alter_table_cmds() != nil {
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // ADD COLUMN with PRIMARY KEY or UNIQUE
+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
+ if hasIndexConstraint(cmd.ColumnDef()) {
+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ return
+ }
+ }
+
+ // ADD CONSTRAINT (PRIMARY KEY or UNIQUE)
+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
+ if hasTableIndexConstraint(cmd.Tableconstraint()) {
+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+ return
+ }
+ }
+ }
+ }
+}
+
+func (c *indexTotalNumberLimitChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+
+ tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+ if tableName == "" {
+ return
+ }
+
+ schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())
+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())
+}
+
+// hasIndexConstraint checks if a column definition has PRIMARY KEY or UNIQUE constraint
+func hasIndexConstraint(colDef parser.IColumnDefContext) bool {
+ if colDef.Colquallist() == nil {
+ return false
+ }
+
+ allConstraints := colDef.Colquallist().AllColconstraint()
+ for _, constraint := range allConstraints {
+ if constraint.Colconstraintelem() != nil {
+ elem := constraint.Colconstraintelem()
+ // PRIMARY KEY creates an index
+ if elem.PRIMARY() != nil && elem.KEY() != nil {
+ return true
+ }
+ // UNIQUE creates an index
+ if elem.UNIQUE() != nil {
+ return true
+ }
+ }
+ }
+
+ return false
+}
+
+// hasTableIndexConstraint checks if a table constraint is PRIMARY KEY or UNIQUE
+func hasTableIndexConstraint(constraint parser.ITableconstraintContext) bool {
+ if constraint == nil || constraint.Constraintelem() == nil {
+ return false
+ }
+
+ elem := constraint.Constraintelem()
+
+ // PRIMARY KEY creates an index
+ if elem.PRIMARY() != nil && elem.KEY() != nil {
+ return true
+ }
+
+ // UNIQUE creates an index
+ if elem.UNIQUE() != nil {
+ return true
+ }
+
+ return false
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_insert_disallow_order_by_rand.go b/backend/plugin/advisor/pgantlr/advisor_insert_disallow_order_by_rand.go
new file mode 100644
index 0000000000..ccd9095ca1
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_insert_disallow_order_by_rand.go
@@ -0,0 +1,153 @@
+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 = (*InsertDisallowOrderByRandAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementInsertDisallowOrderByRand, &InsertDisallowOrderByRandAdvisor{})
+}
+
+// InsertDisallowOrderByRandAdvisor is the advisor checking for to disallow order by rand in INSERT statements.
+type InsertDisallowOrderByRandAdvisor struct {
+}
+
+// Check checks for to disallow order by rand in INSERT statements.
+func (*InsertDisallowOrderByRandAdvisor) 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 := &insertDisallowOrderByRandChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type insertDisallowOrderByRandChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ statementsText string
+}
+
+func (c *insertDisallowOrderByRandChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is INSERT...SELECT
+ if ctx.Insert_rest() == nil || ctx.Insert_rest().Selectstmt() == nil {
+ return
+ }
+
+ // Check for ORDER BY random() in the SELECT statement
+ if c.hasOrderByRandom(ctx.Insert_rest().Selectstmt()) {
+ // Extract the statement text from the original statements
+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.InsertUseOrderByRand.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("The INSERT statement uses ORDER BY random() or random_between(), related statement \"%s\"", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// hasOrderByRandom checks if a SELECT statement has ORDER BY random() or random_between()
+func (*insertDisallowOrderByRandChecker) hasOrderByRandom(selectCtx parser.ISelectstmtContext) bool {
+ if selectCtx == nil {
+ return false
+ }
+
+ // Check both Select_no_parens and Select_with_parens
+ if selectCtx.Select_no_parens() != nil {
+ if hasOrderByRandomInSelect(selectCtx.Select_no_parens()) {
+ return true
+ }
+ }
+
+ if selectCtx.Select_with_parens() != nil {
+ // Select_with_parens might contain another Selectstmt
+ // We need to recursively check
+ return hasOrderByRandomInParens(selectCtx.Select_with_parens())
+ }
+
+ return false
+}
+
+// hasOrderByRandomInSelect checks Select_no_parens for ORDER BY random()
+func hasOrderByRandomInSelect(selectCtx parser.ISelect_no_parensContext) bool {
+ if selectCtx == nil {
+ return false
+ }
+
+ // Check Opt_sort_clause (ORDER BY clause)
+ if selectCtx.Opt_sort_clause() != nil && selectCtx.Opt_sort_clause().Sort_clause() != nil {
+ sortClause := selectCtx.Opt_sort_clause().Sort_clause()
+ // Get all sort by items via Sortby_list
+ if sortClause.Sortby_list() != nil {
+ allSortBy := sortClause.Sortby_list().AllSortby()
+ for _, sortBy := range allSortBy {
+ if sortBy.A_expr() != nil {
+ text := strings.ToLower(sortBy.A_expr().GetText())
+ if strings.Contains(text, "random()") || strings.Contains(text, "random_between()") {
+ return true
+ }
+ }
+ }
+ }
+ }
+
+ return false
+}
+
+// hasOrderByRandomInParens checks Select_with_parens recursively
+func hasOrderByRandomInParens(selectCtx parser.ISelect_with_parensContext) bool {
+ if selectCtx == nil {
+ return false
+ }
+
+ // Select_with_parens can contain Select_no_parens or another Select_with_parens
+ if selectCtx.Select_no_parens() != nil {
+ return hasOrderByRandomInSelect(selectCtx.Select_no_parens())
+ }
+
+ if selectCtx.Select_with_parens() != nil {
+ return hasOrderByRandomInParens(selectCtx.Select_with_parens())
+ }
+
+ return false
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_insert_must_specify_column.go b/backend/plugin/advisor/pgantlr/advisor_insert_must_specify_column.go
new file mode 100644
index 0000000000..850001baa4
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_insert_must_specify_column.go
@@ -0,0 +1,91 @@
+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 = (*InsertMustSpecifyColumnAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementInsertMustSpecifyColumn, &InsertMustSpecifyColumnAdvisor{})
+}
+
+// InsertMustSpecifyColumnAdvisor is the advisor checking for to enforce column specified.
+type InsertMustSpecifyColumnAdvisor struct {
+}
+
+// Check checks for to enforce column specified.
+func (*InsertMustSpecifyColumnAdvisor) 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 := &insertMustSpecifyColumnChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type insertMustSpecifyColumnChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ statementsText string
+}
+
+func (c *insertMustSpecifyColumnChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if column list is specified
+ // In PostgreSQL, INSERT has an optional insert_column_list
+ // If insert_column_list is not specified or empty, we should report it
+ if ctx.Insert_rest() == nil {
+ return
+ }
+
+ // Check if there's an insert_column_list
+ // Insert_column_list exists, which means columns are specified
+ hasColumnList := ctx.Insert_rest().Insert_column_list() != nil
+
+ if !hasColumnList {
+ // Extract the statement text from the original statements
+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.InsertNotSpecifyColumn.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_insert_row_limit.go b/backend/plugin/advisor/pgantlr/advisor_insert_row_limit.go
new file mode 100644
index 0000000000..7afc80480b
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_insert_row_limit.go
@@ -0,0 +1,308 @@
+package pgantlr
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+ "regexp"
+ "strconv"
+
+ "github.com/antlr4-go/antlr/v4"
+ "github.com/pkg/errors"
+
+ parser "github.com/bytebase/parser/postgresql"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+)
+
+var (
+ _ advisor.Advisor = (*InsertRowLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementInsertRowLimit, &InsertRowLimitAdvisor{})
+}
+
+// InsertRowLimitAdvisor is the advisor checking for to limit INSERT rows.
+type InsertRowLimitAdvisor struct {
+}
+
+// Check checks for the INSERT row limit.
+func (*InsertRowLimitAdvisor) 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
+ }
+ payload, err := advisor.UnmarshalNumberTypeRulePayload(checkCtx.Rule.Payload)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &insertRowLimitChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ maxRow: payload.Number,
+ driver: checkCtx.Driver,
+ ctx: ctx,
+ statementsText: checkCtx.Statements,
+ UsePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
+ }
+
+ if payload.Number > 0 {
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ }
+
+ return checker.adviceList, nil
+}
+
+type insertRowLimitChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ maxRow int
+ driver *sql.DB
+ ctx context.Context
+ statementsText string
+ explainCount int
+ setRoles []string
+ UsePostgresDatabaseOwner bool
+}
+
+func (c *insertRowLimitChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Track SET ROLE statements
+ if ctx.Set_rest() != nil && ctx.Set_rest().Set_rest_more() != nil {
+ setRestMore := ctx.Set_rest().Set_rest_more()
+ // Check if this is SET ROLE
+ if setRestMore.ROLE() != nil {
+ c.setRoles = append(c.setRoles, ctx.GetText())
+ }
+ }
+}
+
+func (c *insertRowLimitChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ code := advisor.Ok
+ rows := int64(0)
+
+ // Check if this is INSERT ... VALUES or INSERT ... SELECT
+ if ctx.Insert_rest() != nil && ctx.Insert_rest().Selectstmt() != nil {
+ // Count the number of value lists if this is VALUES
+ rowCount := countValueLists(ctx.Insert_rest().Selectstmt())
+ if rowCount > 0 {
+ // This is INSERT ... VALUES
+ if rowCount > c.maxRow {
+ code = advisor.InsertTooManyRows
+ rows = int64(rowCount)
+ }
+ } else if c.driver != nil {
+ // For INSERT ... SELECT, use EXPLAIN
+ if c.explainCount >= common.MaximumLintExplainSize {
+ return
+ }
+ c.explainCount++
+
+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ res, err := advisor.Query(c.ctx, advisor.QueryContext{
+ UsePostgresDatabaseOwner: c.UsePostgresDatabaseOwner,
+ PreExecutions: c.setRoles,
+ }, c.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))
+
+ if err != nil {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.InsertTooManyRows.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\" dry runs failed: %s", stmtText, err.Error()),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ return
+ }
+
+ rowCount, err := getAffectedRows(res)
+ if err != nil {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.Internal.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("failed to get row count for \"%s\": %s", stmtText, err.Error()),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ return
+ }
+
+ if rowCount > int64(c.maxRow) {
+ code = advisor.InsertTooManyRows
+ rows = rowCount
+ }
+ }
+ }
+
+ if code != advisor.Ok {
+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: code.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("The statement \"%s\" inserts %d rows. The count exceeds %d.", stmtText, rows, c.maxRow),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// countValueLists counts the number of value lists in an INSERT ... VALUES statement
+// Returns 0 if this is not a VALUES statement (e.g., INSERT ... SELECT)
+func countValueLists(selectStmt parser.ISelectstmtContext) int {
+ if selectStmt == nil {
+ return 0
+ }
+
+ // Navigate to the values_clause
+ // SELECT can be select_no_parens or select_with_parens
+ if selectStmt.Select_no_parens() != nil {
+ return countValuesInSelectNoParens(selectStmt.Select_no_parens())
+ }
+
+ if selectStmt.Select_with_parens() != nil {
+ return countValuesInSelectWithParens(selectStmt.Select_with_parens())
+ }
+
+ return 0
+}
+
+// countValuesInSelectNoParens counts VALUES rows in a select_no_parens
+func countValuesInSelectNoParens(selectCtx parser.ISelect_no_parensContext) int {
+ if selectCtx == nil || selectCtx.Select_clause() == nil {
+ return 0
+ }
+
+ // Check if this is a values_clause
+ return countValuesInSelectClause(selectCtx.Select_clause())
+}
+
+// countValuesInSelectWithParens counts VALUES rows in a select_with_parens
+func countValuesInSelectWithParens(selectCtx parser.ISelect_with_parensContext) int {
+ if selectCtx == nil {
+ return 0
+ }
+
+ if selectCtx.Select_no_parens() != nil {
+ return countValuesInSelectNoParens(selectCtx.Select_no_parens())
+ }
+
+ if selectCtx.Select_with_parens() != nil {
+ return countValuesInSelectWithParens(selectCtx.Select_with_parens())
+ }
+
+ return 0
+}
+
+// countValuesInSelectClause counts VALUES rows in a select_clause
+func countValuesInSelectClause(selectClause parser.ISelect_clauseContext) int {
+ if selectClause == nil {
+ return 0
+ }
+
+ // select_clause has AllSimple_select_intersect
+ allIntersect := selectClause.AllSimple_select_intersect()
+ if len(allIntersect) == 0 {
+ return 0
+ }
+
+ // Check the first one for values_clause
+ return countValuesInSimpleSelectIntersect(allIntersect[0])
+}
+
+// countValuesInSimpleSelectIntersect counts VALUES rows in simple_select_intersect
+func countValuesInSimpleSelectIntersect(intersect parser.ISimple_select_intersectContext) int {
+ if intersect == nil {
+ return 0
+ }
+
+ // Get all simple_select_pramary
+ allPrimary := intersect.AllSimple_select_pramary()
+ if len(allPrimary) == 0 {
+ return 0
+ }
+
+ // Check the first one for values_clause
+ return countValuesInPrimary(allPrimary[0])
+}
+
+// countValuesInPrimary counts VALUES rows in simple_select_pramary
+func countValuesInPrimary(primary parser.ISimple_select_pramaryContext) int {
+ if primary == nil || primary.Values_clause() == nil {
+ return 0
+ }
+
+ // values_clause: VALUES (expr_list) (, (expr_list))*
+ // Count the number of COMMA tokens + 1
+ valuesClause := primary.Values_clause()
+ commaCount := len(valuesClause.AllCOMMA())
+ return commaCount + 1
+}
+
+func getAffectedRows(res []any) (int64, error) {
+ // the res struct is []any{columnName, columnTable, rowDataList}
+ if len(res) != 3 {
+ return 0, errors.Errorf("expected 3 but got %d", len(res))
+ }
+ rowList, ok := res[2].([]any)
+ if !ok {
+ return 0, errors.Errorf("expected []any but got %t", res[2])
+ }
+ // EXPLAIN output has at least 2 rows
+ if len(rowList) < 2 {
+ return 0, errors.Errorf("not found any data")
+ }
+ // We need row 2
+ rowTwo, ok := rowList[1].([]any)
+ if !ok {
+ return 0, errors.Errorf("expected []any but got %t", rowList[0])
+ }
+ // PostgreSQL EXPLAIN result has one column
+ if len(rowTwo) != 1 {
+ return 0, errors.Errorf("expected one but got %d", len(rowTwo))
+ }
+ // Get the string value
+ text, ok := rowTwo[0].(string)
+ if !ok {
+ return 0, errors.Errorf("expected string but got %t", rowTwo[0])
+ }
+
+ rowsRegexp := regexp.MustCompile("rows=([0-9]+)")
+ matches := rowsRegexp.FindStringSubmatch(text)
+ if len(matches) != 2 {
+ return 0, errors.Errorf("failed to find rows in %q", text)
+ }
+ value, err := strconv.ParseInt(matches[1], 10, 64)
+ if err != nil {
+ return 0, errors.Errorf("failed to get integer from %q", matches[1])
+ }
+ return value, nil
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_column.go b/backend/plugin/advisor/pgantlr/advisor_naming_column.go
new file mode 100644
index 0000000000..4f3b55eb40
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_naming_column.go
@@ -0,0 +1,188 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+
+ "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"
+ "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+)
+
+var (
+ _ advisor.Advisor = (*NamingColumnConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleColumnNaming, &NamingColumnConventionAdvisor{})
+}
+
+// NamingColumnConventionAdvisor is the advisor checking for column naming convention.
+type NamingColumnConventionAdvisor struct {
+}
+
+// Check checks for column naming convention.
+func (*NamingColumnConventionAdvisor) 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
+ }
+
+ format, maxLength, err := advisor.UnmarshalNamingRulePayloadAsRegexp(checkCtx.Rule.Payload)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &namingColumnConventionChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ format: format,
+ maxLength: maxLength,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type namingColumnConventionChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ format *regexp.Regexp
+ maxLength int
+}
+
+// EnterCreatestmt handles CREATE TABLE statements
+func (c *namingColumnConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Get table name
+ qualifiedNames := ctx.AllQualified_name()
+ if len(qualifiedNames) == 0 {
+ return
+ }
+ tableName := extractTableName(qualifiedNames[0])
+
+ // Get OptTableElementList which contains column definitions
+ if ctx.Opttableelementlist() == nil || ctx.Opttableelementlist().Tableelementlist() == nil {
+ return
+ }
+
+ // Iterate through all table elements
+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ for _, elem := range allElements {
+ // Check if this is a column definition
+ if elem.ColumnDef() != nil {
+ colDef := elem.ColumnDef()
+ if colDef.Colid() != nil {
+ columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
+ c.checkColumnName(tableName, columnName, elem.GetStart().GetLine())
+ }
+ }
+ }
+}
+
+// EnterAltertablestmt handles ALTER TABLE ADD COLUMN statements
+func (c *namingColumnConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Get table name
+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+ tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+
+ // Get ALTER TABLE commands
+ if ctx.Alter_table_cmds() == nil {
+ return
+ }
+
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // Check for ADD COLUMN
+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
+ colDef := cmd.ColumnDef()
+ if colDef.Colid() != nil {
+ columnName := pg.NormalizePostgreSQLColid(colDef.Colid())
+ c.checkColumnName(tableName, columnName, cmd.GetStart().GetLine())
+ }
+ }
+ }
+}
+
+// EnterRenamestmt handles RENAME COLUMN statements
+func (c *namingColumnConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is RENAME COLUMN
+ if ctx.Opt_column() == nil || ctx.Opt_column().COLUMN() == nil {
+ return
+ }
+
+ // Get table name
+ var tableName string
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ }
+ if tableName == "" {
+ return
+ }
+
+ // Get new column name
+ allNames := ctx.AllName()
+ if len(allNames) < 2 {
+ return
+ }
+
+ newColumnName := pg.NormalizePostgreSQLName(allNames[1])
+ c.checkColumnName(tableName, newColumnName, ctx.GetStart().GetLine())
+}
+
+// checkColumnName validates a column name against the format and max length rules
+func (c *namingColumnConventionChecker) checkColumnName(tableName, columnName string, line int) {
+ if !c.format.MatchString(columnName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingColumnConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, naming format should be %q", tableName, columnName, c.format),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+
+ if c.maxLength > 0 && len(columnName) > c.maxLength {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingColumnConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, its length should be within %d characters", tableName, columnName, c.maxLength),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/pgantlr_test.go b/backend/plugin/advisor/pgantlr/pgantlr_test.go
index 5cd5969463..86458d8e14 100644
--- a/backend/plugin/advisor/pgantlr/pgantlr_test.go
+++ b/backend/plugin/advisor/pgantlr/pgantlr_test.go
@@ -9,23 +9,28 @@ import (
func TestPostgreSQLANTLRRules(t *testing.T) {
antlrRules := []advisor.SQLReviewRuleType{
- HelloWorldRule, // Test advisor to verify framework works
- advisor.BuiltinRulePriorBackupCheck, // Migrated from legacy
- advisor.SchemaRuleCharsetAllowlist, // Migrated from legacy
- advisor.SchemaRuleCollationAllowlist, // Migrated from legacy
- advisor.SchemaRuleColumnCommentConvention, // Migrated from legacy
- advisor.SchemaRuleColumnDefaultDisallowVolatile, // Migrated from legacy
- advisor.SchemaRuleColumnDisallowChangeType, // Migrated from legacy
- advisor.SchemaRuleColumnMaximumCharacterLength, // Migrated from legacy
- advisor.SchemaRuleColumnNotNull, // Migrated from legacy
- advisor.SchemaRuleColumnRequireDefault, // Migrated from legacy
- advisor.SchemaRuleColumnTypeDisallowList, // Migrated from legacy
- advisor.SchemaRuleCommentLength, // Migrated from legacy
- advisor.SchemaRuleCreateIndexConcurrently, // Migrated from legacy
- advisor.SchemaRuleIndexKeyNumberLimit, // Migrated from legacy
- advisor.SchemaRuleIndexNoDuplicateColumn, // Migrated from legacy
- advisor.SchemaRuleIndexPrimaryKeyTypeAllowlist, // Migrated from legacy
- advisor.SchemaRuleRequiredColumn, // Migrated from legacy
+ HelloWorldRule, // Test advisor to verify framework works
+ advisor.BuiltinRulePriorBackupCheck, // Migrated from legacy
+ advisor.SchemaRuleCharsetAllowlist, // Migrated from legacy
+ advisor.SchemaRuleCollationAllowlist, // Migrated from legacy
+ advisor.SchemaRuleColumnCommentConvention, // Migrated from legacy
+ advisor.SchemaRuleColumnDefaultDisallowVolatile, // Migrated from legacy
+ advisor.SchemaRuleColumnDisallowChangeType, // Migrated from legacy
+ advisor.SchemaRuleColumnMaximumCharacterLength, // Migrated from legacy
+ advisor.SchemaRuleColumnNotNull, // Migrated from legacy
+ advisor.SchemaRuleColumnRequireDefault, // Migrated from legacy
+ advisor.SchemaRuleColumnTypeDisallowList, // Migrated from legacy
+ advisor.SchemaRuleCommentLength, // Migrated from legacy
+ advisor.SchemaRuleCreateIndexConcurrently, // Migrated from legacy
+ advisor.SchemaRuleIndexKeyNumberLimit, // Migrated from legacy
+ advisor.SchemaRuleIndexNoDuplicateColumn, // Migrated from legacy
+ advisor.SchemaRuleIndexPrimaryKeyTypeAllowlist, // Migrated from legacy
+ advisor.SchemaRuleIndexTotalNumberLimit, // Migrated from legacy
+ advisor.SchemaRuleRequiredColumn, // Migrated from legacy
+ advisor.SchemaRuleStatementInsertDisallowOrderByRand, // Migrated from legacy
+ advisor.SchemaRuleStatementInsertMustSpecifyColumn, // Migrated from legacy
+ advisor.SchemaRuleStatementInsertRowLimit, // Migrated from legacy
+ advisor.SchemaRuleColumnNaming, // Migrated from legacy
// Add real rules here as you migrate them from legacy pg/ folder
// Example:
// advisor.SchemaRuleStatementDisallowCommit,
@@ -43,7 +48,8 @@ func TestPostgreSQLANTLRRules(t *testing.T) {
// Add SQL review type here if you need metadata for test.
var advisorNeedMockData = map[advisor.SQLReviewRuleType]bool{
// advisor.SchemaRuleFullyQualifiedObjectName: true,
- advisor.BuiltinRulePriorBackupCheck: true,
- advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case
+ advisor.BuiltinRulePriorBackupCheck: true,
+ advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case
+ advisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes
// Other advisors don't need mock data
}
diff --git a/backend/plugin/advisor/pgantlr/test/index_total_number_limit.yaml b/backend/plugin/advisor/pgantlr/test/index_total_number_limit.yaml
new file mode 100644
index 0000000000..0da89ace7c
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/index_total_number_limit.yaml
@@ -0,0 +1,57 @@
+- statement: CREATE TABLE t(a int, b int, c int, unique (a, b, c))
+ changeType: 1
+- statement: CREATE INDEX idx_id_name on tech_book(id, name)
+ changeType: 1
+- statement: |-
+ CREATE INDEX idx_id_name_1 on tech_book(id, name);
+ CREATE INDEX idx_id_name_2 on tech_book(id, name);
+ CREATE INDEX idx_id_name_3 on tech_book(id, name);
+ CREATE INDEX idx_id_name_4 on tech_book(id, name);
+ CREATE INDEX idx_id_name_5 on tech_book(id, name);
+ changeType: 1
+ want:
+ - status: 2
+ code: 813
+ title: index.total-number-limit
+ content: The count of index in table "public"."tech_book" should be no more than 5, but found 8
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int PRIMARY KEY, b int, c int);
+ CREATE INDEX idx_a_b_1 on t(a, b);
+ CREATE INDEX idx_a_b_2 on t(a, b);
+ CREATE INDEX idx_a_b_3 on t(a, b);
+ CREATE INDEX idx_a_b_4 on t(a, b);
+ CREATE INDEX idx_a_b_5 on t(a, b);
+ changeType: 1
+ want:
+ - status: 2
+ code: 813
+ title: index.total-number-limit
+ content: The count of index in table "public"."t" should be no more than 5, but found 6
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(
+ a int PRIMARY KEY,
+ b int,
+ c int,
+ CONSTRAINT idx_a_b_1 UNIQUE (a, b),
+ CONSTRAINT idx_a_b_2 UNIQUE (a, b),
+ CONSTRAINT idx_a_b_3 UNIQUE (a, b),
+ CONSTRAINT idx_a_b_4 UNIQUE (a, b),
+ CONSTRAINT idx_a_b_5 UNIQUE (a, b));
+ changeType: 1
+ want:
+ - status: 2
+ code: 813
+ title: index.total-number-limit
+ content: The count of index in table "public"."t" should be no more than 5, but found 6
+ startposition:
+ line: 9
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/naming_column.yaml b/backend/plugin/advisor/pgantlr/test/naming_column.yaml
new file mode 100644
index 0000000000..476da7f842
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/naming_column.yaml
@@ -0,0 +1,51 @@
+- statement: CREATE TABLE book(id int, "creatorId" int)
+ changeType: 1
+ want:
+ - status: 2
+ code: 302
+ title: naming.column
+ content: '"book"."creatorId" mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int, qavszgslczmsacubtvyymzhojfytkcmon int)
+ changeType: 1
+- statement: CREATE TABLE book(id int, creator_Id int)
+ changeType: 1
+- statement: CREATE TABLE book(id int, creator_id int)
+ changeType: 1
+- statement: |-
+ CREATE TABLE book(id int, creator_id int);
+ ALTER TABLE book ADD COLUMN "creatorId" int
+ changeType: 1
+ want:
+ - status: 2
+ code: 302
+ title: naming.column
+ content: '"book"."creatorId" mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(id int, creator_id int);
+ ALTER TABLE book ADD COLUMN "creator" int
+ changeType: 1
+- statement: |-
+ CREATE TABLE book(id int, creator_id int);
+ ALTER TABLE book RENAME COLUMN creator_id TO "creatorId"
+ changeType: 1
+ want:
+ - status: 2
+ code: 302
+ title: naming.column
+ content: '"book"."creatorId" mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(id int, creator_id int);
+ ALTER TABLE book RENAME COLUMN creator_id TO "creator"
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/test/statement_insert_disallow_order_by_rand.yaml b/backend/plugin/advisor/pgantlr/test/statement_insert_disallow_order_by_rand.yaml
new file mode 100644
index 0000000000..1a68ee82e8
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_insert_disallow_order_by_rand.yaml
@@ -0,0 +1,13 @@
+- statement: INSERT INTO tech_book VALUES(1, "a")
+ changeType: 1
+- statement: INSERT INTO tech_book SELECT * FROM tech_book ORDER BY random()
+ changeType: 1
+ want:
+ - status: 2
+ code: 1108
+ title: statement.insert.disallow-order-by-rand
+ content: The INSERT statement uses ORDER BY random() or random_between(), related statement "INSERT INTO tech_book SELECT * FROM tech_book ORDER BY random()"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_insert_must_specify_column.yaml b/backend/plugin/advisor/pgantlr/test/statement_insert_must_specify_column.yaml
new file mode 100644
index 0000000000..b089a7fc59
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_insert_must_specify_column.yaml
@@ -0,0 +1,13 @@
+- statement: INSERT INTO tech_book(id, name) VALUES (1, '1')
+ changeType: 1
+- statement: INSERT INTO tech_book VALUES (1, '1')
+ changeType: 1
+ want:
+ - status: 2
+ code: 1107
+ title: statement.insert.must-specify-column
+ content: The INSERT statement must specify columns but "INSERT INTO tech_book VALUES (1, '1')" does not
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_insert_row_limit.yaml b/backend/plugin/advisor/pgantlr/test/statement_insert_row_limit.yaml
new file mode 100644
index 0000000000..ff6a96ce06
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_insert_row_limit.yaml
@@ -0,0 +1,15 @@
+- statement: INSERT INTO tech_book values(1, 'a')
+ changeType: 1
+- statement: INSERT INTO tech_book values(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')
+ changeType: 1
+ want:
+ - status: 2
+ code: 1101
+ title: statement.insert.row-limit
+ content: The statement "INSERT INTO tech_book values(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')" inserts 6 rows. The count exceeds 5.
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: INSERT INTO tech_book SELECT * FROM tech_book;
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/test_helper.go b/backend/plugin/advisor/pgantlr/test_helper.go
index 83e4dfafdb..952e1c71d3 100644
--- a/backend/plugin/advisor/pgantlr/test_helper.go
+++ b/backend/plugin/advisor/pgantlr/test_helper.go
@@ -16,6 +16,7 @@ import (
"github.com/bytebase/bytebase/backend/plugin/advisor"
"github.com/bytebase/bytebase/backend/plugin/advisor/catalog"
"github.com/bytebase/bytebase/backend/plugin/parser/pg"
+ pglegacy "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy"
)
// TestCase is the data struct for test.
@@ -74,6 +75,14 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
tree, err := pg.ParsePostgreSQL(tc.Statement)
require.NoError(t, err, "Failed to parse SQL: %s", tc.Statement)
+ // Also parse with legacy parser for catalog WalkThrough
+ if needMetaData {
+ legacyAST, err := pglegacy.Parse(pglegacy.ParseContext{}, tc.Statement)
+ require.NoError(t, err, "Failed to parse SQL with legacy parser: %s", tc.Statement)
+ err = finder.WalkThrough(legacyAST)
+ require.NoError(t, err, "Failed to walk through catalog: %s", tc.Statement)
+ }
+
ruleList := []*storepb.SQLReviewRule{
{
Type: string(rule),
diff --git a/backend/plugin/advisor/pgantlr/utils.go b/backend/plugin/advisor/pgantlr/utils.go
index 3b12202b24..1ad3db8da3 100644
--- a/backend/plugin/advisor/pgantlr/utils.go
+++ b/backend/plugin/advisor/pgantlr/utils.go
@@ -2,6 +2,7 @@ package pgantlr
import (
"strconv"
+ "strings"
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/postgresql"
@@ -54,6 +55,16 @@ func extractTableName(ctx parser.IQualified_nameContext) string {
return parts[len(parts)-1]
}
+// extractSchemaName extracts the schema name (first component) from a qualified name.
+// Returns empty string if only table name is provided (implying default schema).
+func extractSchemaName(ctx parser.IQualified_nameContext) string {
+ parts := pg.NormalizePostgreSQLQualifiedName(ctx)
+ if len(parts) <= 1 {
+ return ""
+ }
+ return parts[0]
+}
+
// extractIntegerConstant extracts an integer value from an Iconst context.
// Returns the integer value and an error if parsing fails.
func extractIntegerConstant(ctx parser.IIconstContext) (int, error) {
@@ -82,3 +93,28 @@ func extractStringConstant(ctx parser.ISconstContext) string {
}
return text
}
+
+// extractStatementText extracts a statement from the full statements text using line numbers.
+// Handles multi-line statements by extracting all lines from startLine to endLine.
+func extractStatementText(statementsText string, startLine, endLine int) string {
+ lines := strings.Split(statementsText, "\n")
+ if startLine < 1 || startLine > len(lines) {
+ return ""
+ }
+
+ // Convert to 0-indexed
+ startIdx := startLine - 1
+ endIdx := endLine - 1
+
+ if endIdx >= len(lines) {
+ endIdx = len(lines) - 1
+ }
+
+ // Extract the lines for this statement
+ var stmtLines []string
+ for i := startIdx; i <= endIdx; i++ {
+ stmtLines = append(stmtLines, lines[i])
+ }
+
+ return strings.TrimSpace(strings.Join(stmtLines, " "))
+}