Skip to content

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

feat: migrate some postgresql advisors (#17815)

h3n4l38df624574d4
diff --git a/backend/plugin/advisor/pgantlr/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/pgantlr/advisor_builtin_prior_backup_check.go
index 3f2a20cd53..52f1864f24 100644
--- a/backend/plugin/advisor/pgantlr/advisor_builtin_prior_backup_check.go
+++ b/backend/plugin/advisor/pgantlr/advisor_builtin_prior_backup_check.go
@@ -48,9 +48,9 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisor
var adviceList []*storepb.Advice
// Check for DDL statements in DML context
- tree, err := pg.ParsePostgreSQL(checkCtx.Statements)
+ tree, err := getANTLRTree(checkCtx)
if err != nil {
- return nil, errors.Wrap(err, "failed to parse statement")
+ return nil, err
}
ddlChecker := &ddlChecker{
@@ -221,19 +221,8 @@ type ddlChecker struct {
adviceList []*storepb.Advice
}
-func (c *ddlChecker) getStatementTextWithSemicolon(ctx antlr.ParserRuleContext) string {
- text := c.tokens.GetTextFromRuleContext(ctx)
-
- // Check if the next token after the context is a semicolon
- stopIndex := ctx.GetStop().GetTokenIndex()
- if stopIndex+1 < c.tokens.Size() {
- nextToken := c.tokens.Get(stopIndex + 1)
- if nextToken.GetText() == ";" {
- text += ";"
- }
- }
-
- return text
+func (c *ddlChecker) getStatementText(ctx antlr.ParserRuleContext) string {
+ return c.tokens.GetTextFromRuleContext(ctx)
}
func (c *ddlChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
@@ -246,7 +235,7 @@ func (c *ddlChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
c.adviceList = append(c.adviceList, &storepb.Advice{
Status: c.level,
Title: c.title,
- Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", c.getStatementTextWithSemicolon(ctx)),
+ Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", c.getStatementText(ctx)),
Code: advisor.BuiltinPriorBackupCheck.Int32(),
StartPosition: &storepb.Position{
Line: int32(ctx.GetStart().GetLine()),
@@ -299,21 +288,6 @@ type dmlExtractor struct {
offset int
}
-func isTopLevel(ctx antlr.Tree) bool {
- if ctx == nil {
- return true
- }
-
- switch ctx := ctx.(type) {
- case *parser.RootContext, *parser.StmtblockContext:
- return true
- case *parser.StmtmultiContext, *parser.StmtContext:
- return isTopLevel(ctx.GetParent())
- default:
- return false
- }
-}
-
func (e *dmlExtractor) ExitStmt(ctx *parser.StmtContext) {
if isTopLevel(ctx) {
e.offset++
diff --git a/backend/plugin/advisor/pgantlr/advisor_collation_allowlist.go b/backend/plugin/advisor/pgantlr/advisor_collation_allowlist.go
index ac9e52efb7..eeda5b182a 100644
--- a/backend/plugin/advisor/pgantlr/advisor_collation_allowlist.go
+++ b/backend/plugin/advisor/pgantlr/advisor_collation_allowlist.go
@@ -5,13 +5,11 @@ import (
"fmt"
"github.com/antlr4-go/antlr/v4"
- "github.com/pkg/errors"
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 (
@@ -28,9 +26,9 @@ type CollationAllowlistAdvisor struct {
// Check checks for collation allowlist.
func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := pg.ParsePostgreSQL(checkCtx.Statements)
+ tree, err := getANTLRTree(checkCtx)
if err != nil {
- return nil, errors.Wrap(err, "failed to parse statement")
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -169,15 +167,6 @@ func (*collationAllowlistChecker) extractCollationNameFromAnyName(anyName parser
func (c *collationAllowlistChecker) addAdvice(collation string, ctx antlr.ParserRuleContext) {
text := c.tokens.GetTextFromRuleContext(ctx)
- // Check if the next token after the context is a semicolon
- stopIndex := ctx.GetStop().GetTokenIndex()
- if stopIndex+1 < c.tokens.Size() {
- nextToken := c.tokens.Get(stopIndex + 1)
- if nextToken.GetText() == ";" {
- text += ";"
- }
- }
-
c.adviceList = append(c.adviceList, &storepb.Advice{
Status: c.level,
Code: advisor.DisabledCollation.Int32(),
diff --git a/backend/plugin/advisor/pgantlr/advisor_column_comment_convention.go b/backend/plugin/advisor/pgantlr/advisor_column_comment_convention.go
index 491e0ed2a5..25bfdc70da 100644
--- a/backend/plugin/advisor/pgantlr/advisor_column_comment_convention.go
+++ b/backend/plugin/advisor/pgantlr/advisor_column_comment_convention.go
@@ -5,14 +5,12 @@ import (
"fmt"
"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"
- "github.com/bytebase/bytebase/backend/plugin/parser/pg"
)
var (
@@ -28,9 +26,9 @@ type ColumnCommentConventionAdvisor struct {
}
func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := pg.ParsePostgreSQL(checkCtx.Statements)
+ tree, err := getANTLRTree(checkCtx)
if err != nil {
- return nil, errors.Wrap(err, "failed to parse statement")
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
@@ -199,33 +197,6 @@ func (*columnCommentConventionChecker) extractTableName(qualifiedNames []parser.
return parts[len(parts)-1]
}
-// splitIdentifier splits a qualified identifier by dots, handling quoted parts
-func splitIdentifier(s string) []string {
- var parts []string
- var current string
- inQuote := false
-
- for i := 0; i < len(s); i++ {
- ch := s[i]
- if ch == '"' {
- inQuote = !inQuote
- } else if ch == '.' && !inQuote {
- if current != "" {
- parts = append(parts, current)
- current = ""
- }
- } else {
- current += string(ch)
- }
- }
-
- if current != "" {
- parts = append(parts, current)
- }
-
- return parts
-}
-
func (*columnCommentConventionChecker) extractStringConstant(sconst parser.ISconstContext) string {
if sconst == nil {
return ""
diff --git a/backend/plugin/advisor/pgantlr/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pgantlr/advisor_column_default_disallow_volatile.go
index ebb01bb81f..e7b2c8ddf8 100644
--- a/backend/plugin/advisor/pgantlr/advisor_column_default_disallow_volatile.go
+++ b/backend/plugin/advisor/pgantlr/advisor_column_default_disallow_volatile.go
@@ -6,13 +6,11 @@ import (
"slices"
"github.com/antlr4-go/antlr/v4"
- "github.com/pkg/errors"
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 (
@@ -29,9 +27,9 @@ type ColumnDefaultDisallowVolatileAdvisor struct {
// Check checks for column default volatile functions.
func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
- tree, err := pg.ParsePostgreSQL(checkCtx.Statements)
+ tree, err := getANTLRTree(checkCtx)
if err != nil {
- return nil, errors.Wrap(err, "failed to parse statement")
+ return nil, err
}
level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
diff --git a/backend/plugin/advisor/pgantlr/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/pgantlr/advisor_column_disallow_changing_type.go
new file mode 100644
index 0000000000..f82e63f757
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_column_disallow_changing_type.go
@@ -0,0 +1,90 @@
+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 = (*ColumnDisallowChangingTypeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleColumnDisallowChangeType, &ColumnDisallowChangingTypeAdvisor{})
+}
+
+// ColumnDisallowChangingTypeAdvisor is the advisor checking for disallow changing column type.
+type ColumnDisallowChangingTypeAdvisor struct {
+}
+
+// Check checks for disallow changing column type.
+func (*ColumnDisallowChangingTypeAdvisor) 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 := &columnDisallowChangingTypeChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ tokens: tree.Tokens,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type columnDisallowChangingTypeChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ tokens *antlr.CommonTokenStream
+}
+
+func (c *columnDisallowChangingTypeChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check for ALTER COLUMN TYPE statements
+ if ctx.Alter_table_cmds() == nil {
+ return
+ }
+
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // ALTER opt_column? colid opt_set_data? TYPE_P typename ...
+ if cmd.ALTER() != nil && cmd.TYPE_P() != nil {
+ // This is an ALTER COLUMN TYPE statement
+ text := c.tokens.GetTextFromRuleContext(ctx)
+
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.ChangeColumnType.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("The statement \"%s\" changes column type", text),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: int32(ctx.GetStart().GetColumn()),
+ },
+ })
+ break // Only report once per ALTER TABLE statement
+ }
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_column_maximum_character_length.go b/backend/plugin/advisor/pgantlr/advisor_column_maximum_character_length.go
new file mode 100644
index 0000000000..c472276621
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_column_maximum_character_length.go
@@ -0,0 +1,229 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "strconv"
+
+ "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 = (*ColumnMaximumCharacterLengthAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleColumnMaximumCharacterLength, &ColumnMaximumCharacterLengthAdvisor{})
+}
+
+// ColumnMaximumCharacterLengthAdvisor is the advisor checking for maximum character length.
+type ColumnMaximumCharacterLengthAdvisor struct {
+}
+
+// Check checks for maximum character length.
+func (*ColumnMaximumCharacterLengthAdvisor) 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
+ }
+
+ if payload.Number <= 0 {
+ return nil, nil
+ }
+
+ checker := &columnMaximumCharacterLengthChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ maximum: payload.Number,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type columnMaximumCharacterLengthChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ maximum int
+}
+
+func (c *columnMaximumCharacterLengthChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ tableName := c.extractTableName(ctx.AllQualified_name())
+
+ // Check all columns
+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ for _, elem := range allElements {
+ if elem.ColumnDef() != nil {
+ colDef := elem.ColumnDef()
+ if colDef.Colid() != nil && colDef.Typename() != nil {
+ columnName := colDef.Colid().GetText()
+ charLength := c.getCharLength(colDef.Typename())
+ if charLength > c.maximum {
+ c.addAdvice(tableName, columnName, ctx.GetStart().GetLine())
+ return // Only report first violation
+ }
+ }
+ }
+ }
+ }
+}
+
+func (c *columnMaximumCharacterLengthChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+
+ text := ctx.Relation_expr().Qualified_name().GetText()
+ parts := splitIdentifier(text)
+ if len(parts) == 0 {
+ return
+ }
+
+ var tableName string
+ // Format: schema.table or just table (always with quotes)
+ if len(parts) == 1 {
+ tableName = fmt.Sprintf("%q", parts[0])
+ } else {
+ tableName = fmt.Sprintf("%q.%q", parts[0], parts[1])
+ }
+
+ // Check ALTER TABLE commands
+ if ctx.Alter_table_cmds() != nil {
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // ADD COLUMN
+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
+ colDef := cmd.ColumnDef()
+ if colDef.Colid() != nil && colDef.Typename() != nil {
+ columnName := colDef.Colid().GetText()
+ charLength := c.getCharLength(colDef.Typename())
+ if charLength > c.maximum {
+ c.addAdvice(tableName, columnName, ctx.GetStart().GetLine())
+ return
+ }
+ }
+ }
+
+ // ALTER COLUMN TYPE
+ if cmd.ALTER() != nil && cmd.TYPE_P() != nil && cmd.Typename() != nil {
+ // Get column name
+ allColids := cmd.AllColid()
+ if len(allColids) > 0 {
+ columnName := allColids[0].GetText()
+ charLength := c.getCharLength(cmd.Typename())
+ if charLength > c.maximum {
+ c.addAdvice(tableName, columnName, ctx.GetStart().GetLine())
+ return
+ }
+ }
+ }
+ }
+ }
+}
+
+func (*columnMaximumCharacterLengthChecker) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
+ if len(qualifiedNames) == 0 {
+ return ""
+ }
+
+ text := qualifiedNames[0].GetText()
+ parts := splitIdentifier(text)
+ if len(parts) == 0 {
+ return ""
+ }
+
+ // Format: schema.table or just table (always with quotes)
+ if len(parts) == 1 {
+ return fmt.Sprintf("%q", parts[0])
+ }
+ return fmt.Sprintf("%q.%q", parts[0], parts[1])
+}
+
+func (*columnMaximumCharacterLengthChecker) getCharLength(typename parser.ITypenameContext) int {
+ if typename == nil {
+ return 0
+ }
+
+ // Check if this is a character type
+ if typename.Simpletypename() == nil {
+ return 0
+ }
+
+ simpleType := typename.Simpletypename()
+
+ // Check if it's a character type
+ if simpleType.Character() == nil {
+ return 0
+ }
+
+ character := simpleType.Character()
+ if character.Character_c() == nil {
+ return 0
+ }
+
+ characterC := character.Character_c()
+
+ // Skip VARCHAR - we only check CHAR types
+ if characterC.VARCHAR() != nil {
+ return 0
+ }
+
+ // Skip CHARACTER VARYING, CHAR VARYING, etc.
+ // Only check CHAR/CHARACTER/NCHAR without VARYING
+ if (characterC.CHARACTER() != nil || characterC.CHAR_P() != nil || characterC.NCHAR() != nil) && characterC.Opt_varying() != nil {
+ return 0
+ }
+
+ // Now check if it has a size
+ if character.Iconst() != nil {
+ sizeText := character.Iconst().GetText()
+ size, err := strconv.Atoi(sizeText)
+ if err != nil {
+ return 0
+ }
+ return size
+ }
+
+ return 0
+}
+
+func (c *columnMaximumCharacterLengthChecker) addAdvice(tableName, columnName string, line int) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.CharLengthExceedsLimit.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("The length of the CHAR column %q in table %s is bigger than %d, please use VARCHAR instead", columnName, tableName, c.maximum),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_column_no_null.go b/backend/plugin/advisor/pgantlr/advisor_column_no_null.go
new file mode 100644
index 0000000000..1bf9867c7a
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_column_no_null.go
@@ -0,0 +1,307 @@
+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 = (*ColumnNoNullAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleColumnNotNull, &ColumnNoNullAdvisor{})
+}
+
+// ColumnNoNullAdvisor is the advisor checking for column no NULL value.
+type ColumnNoNullAdvisor struct {
+}
+
+// Check checks for column no NULL value.
+func (*ColumnNoNullAdvisor) 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 := &columnNoNullChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ catalog: checkCtx.Catalog,
+ nullableColumns: make(columnMap),
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.generateAdviceList(), nil
+}
+
+type columnName struct {
+ schema string
+ table string
+ column string
+}
+
+func (c columnName) normalizeTableName() string {
+ if c.schema == "" || c.schema == "public" {
+ return fmt.Sprintf("%q.%q", "public", c.table)
+ }
+ return fmt.Sprintf("%q.%q", c.schema, c.table)
+}
+
+type columnMap map[columnName]int
+
+type columnNoNullChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ level storepb.Advice_Status
+ title string
+ catalog *catalog.Finder
+ nullableColumns columnMap
+}
+
+func (c *columnNoNullChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ tableName := c.extractTableName(ctx.AllQualified_name())
+ if tableName == "" {
+ return
+ }
+
+ // Track all columns and their line numbers
+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ for _, elem := range allElements {
+ // Column definition
+ if elem.ColumnDef() != nil {
+ colDef := elem.ColumnDef()
+ if colDef.Colid() != nil {
+ columnName := colDef.Colid().GetText()
+ // Add column as nullable by default
+ c.addColumn("public", tableName, columnName, elem.GetStart().GetLine())
+
+ // Check column constraints for NOT NULL or PRIMARY KEY
+ c.removeColumnByColConstraints("public", tableName, colDef)
+ }
+ }
+
+ // Table constraint (like PRIMARY KEY (id))
+ if elem.Tableconstraint() != nil {
+ c.removeColumnByTableConstraint("public", tableName, elem.Tableconstraint())
+ }
+ }
+ }
+}
+
+func (c *columnNoNullChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {
+ return
+ }
+
+ tableName := ctx.Relation_expr().Qualified_name().GetText()
+
+ // Check ALTER TABLE commands
+ if ctx.Alter_table_cmds() != nil {
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // ADD COLUMN
+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
+ colDef := cmd.ColumnDef()
+ if colDef.Colid() != nil {
+ columnName := colDef.Colid().GetText()
+ c.addColumn("public", tableName, columnName, ctx.GetStart().GetLine())
+ c.removeColumnByColConstraints("public", tableName, colDef)
+ }
+ }
+
+ // ALTER COLUMN SET NOT NULL
+ if cmd.ALTER() != nil && cmd.SET() != nil && cmd.NOT() != nil && cmd.NULL_P() != nil {
+ allColids := cmd.AllColid()
+ if len(allColids) > 0 {
+ columnName := allColids[0].GetText()
+ c.removeColumn("public", tableName, columnName)
+ }
+ }
+
+ // ALTER COLUMN DROP NOT NULL
+ if cmd.ALTER() != nil && cmd.DROP() != nil && cmd.NOT() != nil && cmd.NULL_P() != nil {
+ allColids := cmd.AllColid()
+ if len(allColids) > 0 {
+ columnName := allColids[0].GetText()
+ c.addColumn("public", tableName, columnName, ctx.GetStart().GetLine())
+ }
+ }
+
+ // ADD table constraint
+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
+ c.removeColumnByTableConstraint("public", tableName, cmd.Tableconstraint())
+ }
+ }
+ }
+}
+
+func (*columnNoNullChecker) extractTableName(qualifiedNames []parser.IQualified_nameContext) string {
+ if len(qualifiedNames) == 0 {
+ return ""
+ }
+
+ text := qualifiedNames[0].GetText()
+ parts := splitIdentifier(text)
+ if len(parts) == 0 {
+ return ""
+ }
+
+ return parts[len(parts)-1]
+}
+
+func (c *columnNoNullChecker) addColumn(schema, table, column string, line int) {
+ if schema == "" {
+ schema = "public"
+ }
+ c.nullableColumns[columnName{schema: schema, table: table, column: column}] = line
+}
+
+func (c *columnNoNullChecker) removeColumn(schema, table, column string) {
+ if schema == "" {
+ schema = "public"
+ }
+ delete(c.nullableColumns, columnName{schema: schema, table: table, column: column})
+}
+
+func (c *columnNoNullChecker) removeColumnByColConstraints(schema, table string, colDef parser.IColumnDefContext) {
+ if colDef.Colquallist() == nil {
+ return
+ }
+
+ columnName := colDef.Colid().GetText()
+ allConstraints := colDef.Colquallist().AllColconstraint()
+ for _, constraint := range allConstraints {
+ if constraint.Colconstraintelem() == nil {
+ continue
+ }
+
+ elem := constraint.Colconstraintelem()
+
+ // NOT NULL constraint
+ if elem.NOT() != nil && elem.NULL_P() != nil {
+ c.removeColumn(schema, table, columnName)
+ return
+ }
+
+ // PRIMARY KEY constraint
+ if elem.PRIMARY() != nil && elem.KEY() != nil {
+ c.removeColumn(schema, table, columnName)
+ return
+ }
+ }
+}
+
+func (c *columnNoNullChecker) removeColumnByTableConstraint(schema, table string, constraint parser.ITableconstraintContext) {
+ if constraint.Constraintelem() == nil {
+ return
+ }
+
+ elem := constraint.Constraintelem()
+
+ // PRIMARY KEY (col1, col2, ...)
+ if elem.PRIMARY() != nil && elem.KEY() != nil && elem.Columnlist() != nil {
+ allColumnElems := elem.Columnlist().AllColumnElem()
+ for _, columnElem := range allColumnElems {
+ if columnElem.Colid() != nil {
+ c.removeColumn(schema, table, columnElem.Colid().GetText())
+ }
+ }
+ return
+ }
+
+ // PRIMARY KEY USING INDEX
+ if elem.PRIMARY() != nil && elem.KEY() != nil && elem.Existingindex() != nil {
+ existingIndex := elem.Existingindex()
+ if existingIndex.Name() != nil {
+ indexName := existingIndex.Name().GetText()
+ // Try to find index in catalog
+ if c.catalog != nil {
+ _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ SchemaName: schema,
+ TableName: table,
+ IndexName: indexName,
+ })
+ if index != nil {
+ for _, expression := range index.ExpressionList() {
+ c.removeColumn(schema, table, expression)
+ }
+ }
+ }
+ }
+ }
+}
+
+func (c *columnNoNullChecker) generateAdviceList() []*storepb.Advice {
+ var adviceList []*storepb.Advice
+ var columnList []columnName
+
+ for column := range c.nullableColumns {
+ columnList = append(columnList, column)
+ }
+
+ if len(columnList) > 0 {
+ // Order it cause the random iteration order in Go
+ slices.SortFunc(columnList, func(i, j columnName) int {
+ if i.schema != j.schema {
+ if i.schema < j.schema {
+ return -1
+ }
+ return 1
+ }
+ if i.table != j.table {
+ if i.table < j.table {
+ return -1
+ }
+ return 1
+ }
+ if i.column < j.column {
+ return -1
+ }
+ if i.column > j.column {
+ return 1
+ }
+ return 0
+ })
+ }
+
+ for _, column := range columnList {
+ adviceList = append(adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.ColumnCannotNull.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("Column %q in %s cannot have NULL value", column.column, column.normalizeTableName()),
+ StartPosition: &storepb.Position{
+ Line: int32(c.nullableColumns[column]),
+ Column: 0,
+ },
+ })
+ }
+
+ return adviceList
+}
diff --git a/backend/plugin/advisor/pgantlr/pgantlr_test.go b/backend/plugin/advisor/pgantlr/pgantlr_test.go
index 65ec1d624c..8c86570299 100644
--- a/backend/plugin/advisor/pgantlr/pgantlr_test.go
+++ b/backend/plugin/advisor/pgantlr/pgantlr_test.go
@@ -14,6 +14,9 @@ func TestPostgreSQLANTLRRules(t *testing.T) {
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
// Add real rules here as you migrate them from legacy pg/ folder
// Example:
// advisor.SchemaRuleStatementDisallowCommit,
@@ -32,5 +35,6 @@ func TestPostgreSQLANTLRRules(t *testing.T) {
var advisorNeedMockData = map[advisor.SQLReviewRuleType]bool{
// advisor.SchemaRuleFullyQualifiedObjectName: true,
advisor.BuiltinRulePriorBackupCheck: true,
- // New advisors don't need mock data
+ advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case
+ // Other advisors don't need mock data
}
diff --git a/backend/plugin/advisor/pgantlr/test/builtin_prior_backup_check.yaml b/backend/plugin/advisor/pgantlr/test/builtin_prior_backup_check.yaml
index 0ece15a37d..6927bf5a11 100644
--- a/backend/plugin/advisor/pgantlr/test/builtin_prior_backup_check.yaml
+++ b/backend/plugin/advisor/pgantlr/test/builtin_prior_backup_check.yaml
@@ -34,7 +34,7 @@
- status: 2
code: 2001
title: builtin.prior-backup-check
- content: Data change can only run DML, "CREATE TABLE t_test_backup(a int);" is not DML
+ content: Data change can only run DML, "CREATE TABLE t_test_backup(a int)" is not DML
startposition:
line: 1
column: 0
diff --git a/backend/plugin/advisor/pgantlr/test/column_disallow_change_type.yaml b/backend/plugin/advisor/pgantlr/test/column_disallow_change_type.yaml
new file mode 100644
index 0000000000..4541a807e6
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/column_disallow_change_type.yaml
@@ -0,0 +1,13 @@
+- statement: ALTER TABLE tech_book ALTER COLUMN id SET DATA TYPE INTEGER
+ changeType: 1
+ want:
+ - status: 2
+ code: 403
+ title: column.disallow-change-type
+ content: The statement "ALTER TABLE tech_book ALTER COLUMN id SET DATA TYPE INTEGER" changes column type
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD COLUMN c1 int
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/test/column_maximum_character_length.yaml b/backend/plugin/advisor/pgantlr/test/column_maximum_character_length.yaml
new file mode 100644
index 0000000000..d6eeec361b
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/column_maximum_character_length.yaml
@@ -0,0 +1,37 @@
+- statement: CREATE TABLE t(name char(20));
+ changeType: 1
+- statement: CREATE TABLE t(name varchar(225));
+ changeType: 1
+- statement: CREATE TABLE t(name char(225));
+ changeType: 1
+ want:
+ - status: 2
+ code: 415
+ title: column.maximum-character-length
+ content: The length of the CHAR column "name" in table "t" is bigger than 20, please use VARCHAR instead
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE public.tech_book ADD COLUMN name_2 char(225)
+ changeType: 1
+ want:
+ - status: 2
+ code: 415
+ title: column.maximum-character-length
+ content: The length of the CHAR column "name_2" in table "public"."tech_book" is bigger than 20, please use VARCHAR instead
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ALTER COLUMN name SET DATA TYPE char(225)
+ changeType: 1
+ want:
+ - status: 2
+ code: 415
+ title: column.maximum-character-length
+ content: The length of the CHAR column "name" in table "tech_book" is bigger than 20, please use VARCHAR instead
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/column_no_null.yaml b/backend/plugin/advisor/pgantlr/test/column_no_null.yaml
new file mode 100644
index 0000000000..895f757eb0
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/column_no_null.yaml
@@ -0,0 +1,89 @@
+- statement: |-
+ CREATE TABLE book (
+ id int,
+ name varchar(255)
+ )
+ changeType: 1
+ want:
+ - status: 2
+ code: 402
+ title: column.no-null
+ content: Column "id" in "public"."book" cannot have NULL value
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 402
+ title: column.no-null
+ content: Column "name" in "public"."book" cannot have NULL value
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int, name varchar(255), PRIMARY KEY (id))
+ changeType: 1
+ want:
+ - status: 2
+ code: 402
+ title: column.no-null
+ content: Column "name" in "public"."book" cannot have NULL value
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int PRIMARY KEY, name varchar(255))
+ changeType: 1
+ want:
+ - status: 2
+ code: 402
+ title: column.no-null
+ content: Column "name" in "public"."book" cannot have NULL value
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int NOT NULL, name varchar(255))
+ changeType: 1
+ want:
+ - status: 2
+ code: 402
+ title: column.no-null
+ content: Column "name" in "public"."book" cannot have NULL value
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int PRIMARY KEY, name varchar(255) NOT NULL)
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD COLUMN reader int
+ changeType: 1
+ want:
+ - status: 2
+ code: 402
+ title: column.no-null
+ content: Column "reader" in "public"."tech_book" cannot have NULL value
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book DROP COLUMN id;
+ ALTER TABLE tech_book DROP COLUMN name;
+ ALTER TABLE tech_book ADD COLUMN id int PRIMARY KEY, ADD COLUMN name varchar(255) NOT NULL;
+ changeType: 1
+- statement: ALTER TABLE tech_book ALTER COLUMN id SET NOT NULL
+ changeType: 1
+- statement: ALTER TABLE tech_book ALTER COLUMN name DROP NOT NULL
+ changeType: 1
+ want:
+ - status: 2
+ code: 402
+ title: column.no-null
+ content: Column "name" in "public"."tech_book" cannot have NULL value
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: /* this is a comment */
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/test_helper.go b/backend/plugin/advisor/pgantlr/test_helper.go
index cbebfd13c8..83e4dfafdb 100644
--- a/backend/plugin/advisor/pgantlr/test_helper.go
+++ b/backend/plugin/advisor/pgantlr/test_helper.go
@@ -12,10 +12,10 @@ import (
"github.com/stretchr/testify/require"
"gopkg.in/yaml.v3"
- "github.com/bytebase/bytebase/backend/component/sheet"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/advisor"
"github.com/bytebase/bytebase/backend/plugin/advisor/catalog"
+ "github.com/bytebase/bytebase/backend/plugin/parser/pg"
)
// TestCase is the data struct for test.
@@ -48,7 +48,6 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
err = yaml.Unmarshal(byteValue, &tests)
require.NoError(t, err, rule)
- sm := sheet.NewManager(nil)
for i, tc := range tests {
// Add engine types here for mocked database metadata.
var schemaMetadata *storepb.DatabaseSchemaMetadata
@@ -71,6 +70,10 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
payload = ""
}
+ // Parse SQL using ANTLR for pgantlr advisors
+ tree, err := pg.ParsePostgreSQL(tc.Statement)
+ require.NoError(t, err, "Failed to parse SQL: %s", tc.Statement)
+
ruleList := []*storepb.SQLReviewRule{
{
Type: string(rule),
@@ -79,21 +82,24 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
},
}
- checkCtx := advisor.SQLReviewCheckContext{
- Charset: "",
- Collation: "",
- DBType: dbType,
- Catalog: &testCatalog{finder: finder},
- Driver: nil,
- CurrentDatabase: "TEST_DB",
- DBSchema: schemaMetadata,
- ChangeType: tc.ChangeType,
- EnablePriorBackup: true,
- NoAppendBuiltin: true,
- UsePostgresDatabaseOwner: true,
- }
-
- adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, tc.Statement, ruleList, checkCtx)
+ // Call the advisor directly with ANTLR AST
+ adviceList, err := advisor.Check(
+ context.Background(),
+ dbType,
+ rule,
+ advisor.Context{
+ DBSchema: schemaMetadata,
+ ChangeType: tc.ChangeType,
+ EnablePriorBackup: true,
+ AST: tree, // Pass ANTLR parse result
+ Statements: tc.Statement,
+ Rule: ruleList[0],
+ Catalog: finder,
+ Driver: nil,
+ CurrentDatabase: "TEST_DB",
+ UsePostgresDatabaseOwner: true,
+ },
+ )
// Sort adviceList by (line, content) for consistent comparison
slices.SortFunc(adviceList, func(x, y *storepb.Advice) int {
@@ -136,11 +142,3 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
require.NoError(t, err)
}
}
-
-type testCatalog struct {
- finder *catalog.Finder
-}
-
-func (c *testCatalog) GetFinder() *catalog.Finder {
- return c.finder
-}
diff --git a/backend/plugin/advisor/pgantlr/utils.go b/backend/plugin/advisor/pgantlr/utils.go
new file mode 100644
index 0000000000..9f85bd96e6
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/utils.go
@@ -0,0 +1,74 @@
+package pgantlr
+
+import (
+ "github.com/antlr4-go/antlr/v4"
+ parser "github.com/bytebase/parser/postgresql"
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+)
+
+// isTopLevel checks if the context is at the top level of the parse tree.
+// Top level contexts are: RootContext, StmtblockContext, StmtmultiContext, or StmtContext.
+func isTopLevel(ctx antlr.Tree) bool {
+ if ctx == nil {
+ return true
+ }
+
+ switch ctx := ctx.(type) {
+ case *parser.RootContext, *parser.StmtblockContext:
+ return true
+ case *parser.StmtmultiContext, *parser.StmtContext:
+ return isTopLevel(ctx.GetParent())
+ default:
+ return false
+ }
+}
+
+// splitIdentifier splits a qualified identifier by dots, handling quoted parts.
+// For example:
+// - "public.table" -> ["public", "table"]
+// - "\"public\".\"table\"" -> ["public", "table"]
+// - "table" -> ["table"]
+func splitIdentifier(s string) []string {
+ var parts []string
+ var current string
+ inQuote := false
+
+ for i := 0; i < len(s); i++ {
+ ch := s[i]
+ if ch == '"' {
+ inQuote = !inQuote
+ } else if ch == '.' && !inQuote {
+ if current != "" {
+ parts = append(parts, current)
+ current = ""
+ }
+ } else {
+ current += string(ch)
+ }
+ }
+
+ if current != "" {
+ parts = append(parts, current)
+ }
+
+ return parts
+}
+
+// getANTLRTree extracts the ANTLR parse tree from the advisor context.
+// The AST must be pre-parsed and passed via checkCtx.AST (e.g., in tests or by the framework).
+// This enforces proper AST caching and makes any missing cache obvious.
+func getANTLRTree(checkCtx advisor.Context) (*pg.ParseResult, error) {
+ if checkCtx.AST == nil {
+ return nil, errors.New("AST is not provided in context - must be parsed before calling advisor")
+ }
+
+ parseResult, ok := checkCtx.AST.(*pg.ParseResult)
+ if !ok {
+ return nil, errors.Errorf("AST type mismatch: expected *pg.ParseResult, got %T", checkCtx.AST)
+ }
+
+ return parseResult, nil
+}