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 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.goindex 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 advisorvar 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.goindex 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 parserfunc (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.goindex 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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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 legacyadvisor.SchemaRuleColumnCommentConvention, // Migrated from legacyadvisor.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.yamlindex 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: 2code: 2001title: 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 DMLstartposition:line: 1column: 0diff --git a/backend/plugin/advisor/pgantlr/test/column_disallow_change_type.yaml b/backend/plugin/advisor/pgantlr/test/column_disallow_change_type.yamlnew file mode 100644index 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: 1diff --git a/backend/plugin/advisor/pgantlr/test/column_maximum_character_length.yaml b/backend/plugin/advisor/pgantlr/test/column_maximum_character_length.yamlnew file mode 100644index 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: nulldiff --git a/backend/plugin/advisor/pgantlr/test/column_no_null.yaml b/backend/plugin/advisor/pgantlr/test/column_no_null.yamlnew file mode 100644index 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: 1diff --git a/backend/plugin/advisor/pgantlr/test_helper.go b/backend/plugin/advisor/pgantlr/test_helper.goindex 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, dbTyperr = 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, dbTyppayload = ""}+ // 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 comparisonslices.SortFunc(adviceList, func(x, y *storepb.Advice) int {@@ -136,11 +142,3 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyprequire.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.gonew file mode 100644index 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+}