Skip to content

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

feat: migrate 10 more PostgreSQL advisors to ANTLR parser (#17859)

h3n4l71098bfb14c5
diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_foreign_key_convention.go
new file mode 100644
index 0000000000..6e047a2b67
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_naming_foreign_key_convention.go
@@ -0,0 +1,330 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+ "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"
+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+)
+
+var (
+ _ advisor.Advisor = (*NamingFKConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleFKNaming, &NamingFKConventionAdvisor{})
+}
+
+// NamingFKConventionAdvisor is the advisor checking for foreign key naming convention.
+type NamingFKConventionAdvisor struct {
+}
+
+// Check checks for foreign key naming convention.
+func (*NamingFKConventionAdvisor) 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, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &namingFKConventionChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type namingFKConventionChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ format string
+ maxLength int
+ templateList []string
+}
+
+type fkMetaData struct {
+ indexName string
+ tableName string
+ line int
+ metaData map[string]string
+}
+
+// EnterCreatestmt handles CREATE TABLE with FOREIGN KEY constraints
+func (c *namingFKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Opttableelementlist() == nil {
+ return
+ }
+
+ allQualifiedNames := ctx.AllQualified_name()
+ if len(allQualifiedNames) == 0 {
+ return
+ }
+
+ tableName := extractTableName(allQualifiedNames[0])
+
+ // Check table-level and column-level constraints
+ if ctx.Opttableelementlist().Tableelementlist() != nil {
+ for _, element := range ctx.Opttableelementlist().Tableelementlist().AllTableelement() {
+ // Check table-level constraints
+ if element.Tableconstraint() != nil {
+ metadata := c.extractFKMetadata(element.Tableconstraint(), tableName, ctx.GetStart().GetLine())
+ if metadata != nil {
+ c.checkFKMetadata(metadata)
+ }
+ }
+
+ // Check column-level constraints
+ if element.ColumnDef() != nil {
+ columnDef := element.ColumnDef()
+ if columnDef.Colquallist() != nil {
+ allQuals := columnDef.Colquallist().AllColconstraint()
+ for _, qual := range allQuals {
+ metadata := c.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())
+ if metadata != nil {
+ c.checkFKMetadata(metadata)
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT FOREIGN KEY
+func (c *namingFKConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() == nil {
+ return
+ }
+
+ tableName := extractTableName(ctx.Relation_expr().Qualified_name())
+
+ if ctx.Alter_table_cmds() == nil {
+ return
+ }
+
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // Check for ADD + Tableconstraint
+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
+ metadata := c.extractFKMetadata(cmd.Tableconstraint(), tableName, cmd.GetStart().GetLine())
+ if metadata != nil {
+ c.checkFKMetadata(metadata)
+ }
+ }
+
+ // Check for ADD COLUMN with inline foreign key constraint
+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
+ columnDef := cmd.ColumnDef()
+ if columnDef.Colquallist() != nil {
+ allQuals := columnDef.Colquallist().AllColconstraint()
+ for _, qual := range allQuals {
+ metadata := c.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())
+ if metadata != nil {
+ c.checkFKMetadata(metadata)
+ }
+ }
+ }
+ }
+ }
+}
+
+func (*namingFKConventionChecker) extractFKMetadata(constraint parser.ITableconstraintContext, tableName string, line int) *fkMetaData {
+ if constraint.Constraintelem() == nil {
+ return nil
+ }
+
+ elem := constraint.Constraintelem()
+
+ // Check if this is a FOREIGN KEY constraint
+ if elem.FOREIGN() == nil || elem.KEY() == nil {
+ return nil
+ }
+
+ // Extract constraint name
+ constraintName := ""
+ if constraint.Name() != nil {
+ constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())
+ }
+
+ // Extract referencing columns
+ var referencingColumns []string
+ if elem.Columnlist() != nil {
+ for _, colElem := range elem.Columnlist().AllColumnElem() {
+ if colElem.Colid() != nil {
+ referencingColumns = append(referencingColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))
+ }
+ }
+ }
+
+ // Extract referenced table and columns
+ var referencedTable string
+ var referencedColumns []string
+ if elem.Qualified_name() != nil {
+ referencedTable = extractTableName(elem.Qualified_name())
+ }
+
+ if elem.Opt_column_list() != nil && elem.Opt_column_list().Columnlist() != nil {
+ for _, colElem := range elem.Opt_column_list().Columnlist().AllColumnElem() {
+ if colElem.Colid() != nil {
+ referencedColumns = append(referencedColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))
+ }
+ }
+ }
+
+ metaData := map[string]string{
+ advisor.ReferencingTableNameTemplateToken: tableName,
+ advisor.ReferencingColumnNameTemplateToken: strings.Join(referencingColumns, "_"),
+ advisor.ReferencedTableNameTemplateToken: referencedTable,
+ advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumns, "_"),
+ }
+
+ return &fkMetaData{
+ indexName: constraintName,
+ tableName: tableName,
+ line: line,
+ metaData: metaData,
+ }
+}
+
+func (*namingFKConventionChecker) extractColumnFKMetadata(qual parser.IColconstraintContext, tableName string, columnDef parser.IColumnDefContext, line int) *fkMetaData {
+ if qual.Colconstraintelem() == nil {
+ return nil
+ }
+
+ elem := qual.Colconstraintelem()
+
+ // Check if this is a REFERENCES constraint (inline foreign key)
+ if elem.REFERENCES() == nil {
+ return nil
+ }
+
+ // Extract constraint name
+ constraintName := ""
+ if qual.Name() != nil {
+ constraintName = pgparser.NormalizePostgreSQLName(qual.Name())
+ }
+
+ // Extract referencing column (the column being defined)
+ var referencingColumn string
+ if columnDef.Colid() != nil {
+ referencingColumn = pgparser.NormalizePostgreSQLColid(columnDef.Colid())
+ }
+
+ // Extract referenced table and columns
+ var referencedTable string
+ var referencedColumns []string
+ if elem.Qualified_name() != nil {
+ referencedTable = extractTableName(elem.Qualified_name())
+ }
+
+ if elem.Opt_column_list() != nil && elem.Opt_column_list().Columnlist() != nil {
+ for _, colElem := range elem.Opt_column_list().Columnlist().AllColumnElem() {
+ if colElem.Colid() != nil {
+ referencedColumns = append(referencedColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))
+ }
+ }
+ }
+
+ metaData := map[string]string{
+ advisor.ReferencingTableNameTemplateToken: tableName,
+ advisor.ReferencingColumnNameTemplateToken: referencingColumn,
+ advisor.ReferencedTableNameTemplateToken: referencedTable,
+ advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumns, "_"),
+ }
+
+ return &fkMetaData{
+ indexName: constraintName,
+ tableName: tableName,
+ line: line,
+ metaData: metaData,
+ }
+}
+
+func (c *namingFKConventionChecker) checkFKMetadata(fkData *fkMetaData) {
+ regex, err := c.getTemplateRegexp(fkData.metaData)
+ if err != nil {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.Internal.Int32(),
+ Title: "Internal error for foreign key naming convention rule",
+ Content: fmt.Sprintf("Failed to compile regex: %s", err.Error()),
+ StartPosition: &storepb.Position{
+ Line: int32(fkData.line),
+ Column: 0,
+ },
+ })
+ return
+ }
+
+ if !regex.MatchString(fkData.indexName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingFKConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf(`Foreign key in table "%s" mismatches the naming convention, expect %q but found "%s"`, fkData.tableName, regex, fkData.indexName),
+ StartPosition: &storepb.Position{
+ Line: int32(fkData.line),
+ Column: 0,
+ },
+ })
+ }
+
+ if c.maxLength > 0 && len(fkData.indexName) > c.maxLength {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingFKConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf(`Foreign key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, fkData.indexName, fkData.tableName, c.maxLength),
+ StartPosition: &storepb.Position{
+ Line: int32(fkData.line),
+ Column: 0,
+ },
+ })
+ }
+}
+
+func (c *namingFKConventionChecker) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {
+ template := c.format
+ for _, key := range c.templateList {
+ if token, ok := tokens[key]; ok {
+ template = strings.ReplaceAll(template, key, token)
+ }
+ }
+
+ return regexp.Compile(template)
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pgantlr/advisor_naming_fully_qualified.go
new file mode 100644
index 0000000000..c24de9bd1f
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_naming_fully_qualified.go
@@ -0,0 +1,345 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+ "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"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+)
+
+var (
+ _ advisor.Advisor = (*FullyQualifiedObjectNameAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleFullyQualifiedObjectName, &FullyQualifiedObjectNameAdvisor{})
+}
+
+// FullyQualifiedObjectNameAdvisor is the advisor checking for fully qualified object names.
+type FullyQualifiedObjectNameAdvisor struct {
+}
+
+// Check checks for fully qualified object names.
+func (*FullyQualifiedObjectNameAdvisor) 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 := &fullyQualifiedObjectNameChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ dbSchema: checkCtx.DBSchema,
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type fullyQualifiedObjectNameChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ dbSchema *storepb.DatabaseSchemaMetadata
+ statementsText string
+}
+
+// EnterCreatestmt handles CREATE TABLE
+func (c *fullyQualifiedObjectNameChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ allQualifiedNames := ctx.AllQualified_name()
+ if len(allQualifiedNames) > 0 {
+ c.checkQualifiedName(allQualifiedNames[0], ctx.GetStop().GetLine())
+ }
+}
+
+// EnterCreateseqstmt handles CREATE SEQUENCE
+func (c *fullyQualifiedObjectNameChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
+ }
+}
+
+// EnterCreatetrigstmt handles CREATE TRIGGER
+func (c *fullyQualifiedObjectNameChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check the table name in the ON clause
+ if ctx.Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
+ }
+}
+
+// EnterIndexstmt handles CREATE INDEX
+func (c *fullyQualifiedObjectNameChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check the table name in the ON clause
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ }
+}
+
+// EnterDropstmt handles DROP TABLE, DROP SEQUENCE, DROP INDEX
+func (c *fullyQualifiedObjectNameChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check all qualified names in the drop statement
+ if ctx.Any_name_list() != nil {
+ for _, anyName := range ctx.Any_name_list().AllAny_name() {
+ c.checkAnyName(anyName, ctx.GetStop().GetLine())
+ }
+ }
+}
+
+// EnterAltertablestmt handles ALTER TABLE
+func (c *fullyQualifiedObjectNameChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ }
+}
+
+// EnterAlterseqstmt handles ALTER SEQUENCE
+func (c *fullyQualifiedObjectNameChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())
+ }
+}
+
+// EnterRenamestmt handles ALTER TABLE RENAME
+func (c *fullyQualifiedObjectNameChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ }
+}
+
+// EnterInsertstmt handles INSERT
+func (c *fullyQualifiedObjectNameChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Insert_target() != nil && ctx.Insert_target().Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Insert_target().Qualified_name(), ctx.GetStop().GetLine())
+ }
+}
+
+// EnterUpdatestmt handles UPDATE
+func (c *fullyQualifiedObjectNameChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ if ctx.Relation_expr_opt_alias() != nil && ctx.Relation_expr_opt_alias().Relation_expr() != nil {
+ if ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name() != nil {
+ c.checkQualifiedName(ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name(), ctx.GetStop().GetLine())
+ }
+ }
+}
+
+// EnterSelectstmt handles SELECT
+func (c *fullyQualifiedObjectNameChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // For SELECT statements, we need to extract tables from the query
+ // and check them against the database schema
+ if c.dbSchema == nil {
+ return
+ }
+
+ // Extract the statement text for this SELECT
+ startLine := ctx.GetStop().GetLine()
+ endLine := ctx.GetStop().GetLine()
+ statementText := extractStatementText(c.statementsText, startLine, endLine)
+
+ if statementText == "" {
+ return
+ }
+
+ // Find all table references in the SELECT statement
+ for _, tableName := range c.findAllTablesInSelect(statementText) {
+ objName := tableName.String()
+ if !c.isFullyQualified(objName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: int32(advisor.NamingNotFullyQualifiedName),
+ Title: c.title,
+ Content: fmt.Sprintf("unqualified object name: '%s'", objName),
+ StartPosition: &storepb.Position{
+ Line: int32(startLine),
+ Column: 0,
+ },
+ })
+ }
+ }
+}
+
+// checkQualifiedName checks if a qualified name is fully qualified
+func (c *fullyQualifiedObjectNameChecker) checkQualifiedName(ctx parser.IQualified_nameContext, line int) {
+ if ctx == nil {
+ return
+ }
+
+ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx)
+ objName := strings.Join(parts, ".")
+
+ if !c.isFullyQualified(objName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: int32(advisor.NamingNotFullyQualifiedName),
+ Title: c.title,
+ Content: fmt.Sprintf("unqualified object name: '%s'", objName),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// checkAnyName checks if an any_name is fully qualified
+func (c *fullyQualifiedObjectNameChecker) checkAnyName(ctx parser.IAny_nameContext, line int) {
+ if ctx == nil {
+ return
+ }
+
+ // Extract parts from any_name (schema.object or object)
+ parts := pgparser.NormalizePostgreSQLAnyName(ctx)
+ objName := strings.Join(parts, ".")
+
+ if !c.isFullyQualified(objName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: int32(advisor.NamingNotFullyQualifiedName),
+ Title: c.title,
+ Content: fmt.Sprintf("unqualified object name: '%s'", objName),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// isFullyQualified checks if an object name is fully qualified (contains a dot)
+func (*fullyQualifiedObjectNameChecker) isFullyQualified(objName string) bool {
+ if objName == "" {
+ return true
+ }
+ re := regexp.MustCompile(`.+\..+`)
+ return re.MatchString(objName)
+}
+
+// findAllTablesInSelect finds all table references in a SELECT statement
+func (c *fullyQualifiedObjectNameChecker) findAllTablesInSelect(statement string) []base.ColumnResource {
+ // Parse the statement to extract table references
+ result, err := pgparser.ParsePostgreSQL(statement)
+ if err != nil {
+ return nil
+ }
+
+ // Use a visitor to find all table references
+ collector := &tableReferenceCollector{
+ schemaNameMap: c.getSchemaNameMapFromPublic(),
+ }
+
+ if result.Tree != nil {
+ antlr.ParseTreeWalkerDefault.Walk(collector, result.Tree)
+ }
+
+ return collector.tables
+}
+
+// getSchemaNameMapFromPublic creates a map of table names from the database schema
+func (c *fullyQualifiedObjectNameChecker) getSchemaNameMapFromPublic() map[string]bool {
+ if c.dbSchema == nil || c.dbSchema.Schemas == nil {
+ return nil
+ }
+
+ filterMap := map[string]bool{}
+ for _, schema := range c.dbSchema.Schemas {
+ // Tables
+ for _, tbl := range schema.Tables {
+ filterMap[tbl.Name] = true
+ }
+ // External Tables
+ for _, tbl := range schema.ExternalTables {
+ filterMap[tbl.Name] = true
+ }
+ }
+ return filterMap
+}
+
+// tableReferenceCollector collects table references from a SELECT statement
+type tableReferenceCollector struct {
+ *parser.BasePostgreSQLParserListener
+
+ tables []base.ColumnResource
+ schemaNameMap map[string]bool
+}
+
+// EnterTable_ref collects table references
+func (c *tableReferenceCollector) EnterTable_ref(ctx *parser.Table_refContext) {
+ // Look for relation_expr in the table_ref
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Relation_expr().Qualified_name())
+
+ resource := base.ColumnResource{}
+ if len(parts) == 2 {
+ resource.Schema = parts[0]
+ resource.Table = parts[1]
+ } else if len(parts) == 1 {
+ resource.Table = parts[0]
+ }
+
+ // Only add if the table exists in the schema
+ if c.schemaNameMap == nil || c.schemaNameMap[resource.Table] {
+ c.tables = append(c.tables, resource)
+ }
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_index_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_index_convention.go
new file mode 100644
index 0000000000..c150480bf5
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_naming_index_convention.go
@@ -0,0 +1,214 @@
+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"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"
+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+)
+
+var (
+ _ advisor.Advisor = (*NamingIndexConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleIDXNaming, &NamingIndexConventionAdvisor{})
+}
+
+// NamingIndexConventionAdvisor is the advisor checking for index naming convention.
+type NamingIndexConventionAdvisor struct {
+}
+
+// Check checks for index naming convention.
+func (*NamingIndexConventionAdvisor) 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, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &namingIndexConventionChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ catalog: checkCtx.Catalog,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type namingIndexConventionChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ format string
+ maxLength int
+ templateList []string
+ catalog *catalog.Finder
+}
+
+// EnterIndexstmt checks CREATE INDEX statements
+func (c *namingIndexConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is a UNIQUE index - if so, skip it
+ if ctx.Opt_unique() != nil && ctx.Opt_unique().UNIQUE() != nil {
+ return
+ }
+
+ // Get index name
+ indexName := ""
+ if ctx.Name() != nil {
+ indexName = pgparser.NormalizePostgreSQLName(ctx.Name())
+ }
+ if indexName == "" {
+ return
+ }
+
+ // Get table name
+ tableName := ""
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ }
+ if tableName == "" {
+ return
+ }
+
+ // Get column list
+ var columnList []string
+ if ctx.Index_params() != nil {
+ allParams := ctx.Index_params().AllIndex_elem()
+ for _, param := range allParams {
+ if param.Colid() != nil {
+ colName := pgparser.NormalizePostgreSQLColid(param.Colid())
+ columnList = append(columnList, colName)
+ }
+ }
+ }
+
+ c.checkIndexName(indexName, tableName, columnList, ctx.GetStart().GetLine())
+}
+
+// EnterRenamestmt checks ALTER INDEX ... RENAME TO statements
+func (c *namingIndexConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check for ALTER INDEX ... RENAME TO
+ if ctx.INDEX() != nil && ctx.TO() != nil {
+ allNames := ctx.AllName()
+ if len(allNames) < 1 {
+ return
+ }
+
+ // Get old index name from qualified_name
+ var oldIndexName string
+ if ctx.Qualified_name() != nil {
+ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Qualified_name())
+ if len(parts) > 0 {
+ oldIndexName = parts[len(parts)-1]
+ }
+ }
+
+ // Get new index name from the name after TO
+ newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])
+
+ // Look up the index in catalog to determine if it's a regular index (not unique, not PK)
+ if c.catalog != nil && oldIndexName != "" {
+ tableName, index := c.findIndex("", "", oldIndexName)
+ if index != nil {
+ // Only check if it's a regular index (not unique, not primary)
+ if !index.Unique() && !index.Primary() {
+ c.checkIndexName(newIndexName, tableName, index.ExpressionList(), ctx.GetStart().GetLine())
+ }
+ }
+ }
+ }
+}
+
+func (c *namingIndexConventionChecker) checkIndexName(indexName, tableName string, columnList []string, line int) {
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+
+ regex, err := getTemplateRegexp(c.format, c.templateList, metaData)
+ if err != nil {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.Internal.Int32(),
+ Title: "Internal error for index naming convention rule",
+ Content: fmt.Sprintf("Failed to compile regex: %v", err),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ return
+ }
+
+ if !regex.MatchString(indexName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingIndexConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("Index in table %q mismatches the naming convention, expect %q but found %q", tableName, regex, indexName),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+
+ if c.maxLength > 0 && len(indexName) > c.maxLength {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingIndexConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("Index %q in table %q mismatches the naming convention, its length should be within %d characters", indexName, tableName, c.maxLength),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+}
+
+// findIndex returns index found in catalogs, nil if not found.
+func (c *namingIndexConventionChecker) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {
+ if c.catalog == nil {
+ return "", nil
+ }
+ return c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ SchemaName: normalizeSchemaName(schemaName),
+ TableName: tableName,
+ IndexName: indexName,
+ })
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_primary_key_convention.go
new file mode 100644
index 0000000000..e6e7200ed1
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_naming_primary_key_convention.go
@@ -0,0 +1,369 @@
+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"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"
+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+)
+
+var (
+ _ advisor.Advisor = (*NamingPKConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRulePKNaming, &NamingPKConventionAdvisor{})
+}
+
+// NamingPKConventionAdvisor is the advisor checking for primary key naming convention.
+type NamingPKConventionAdvisor struct {
+}
+
+// Check checks for primary key naming convention.
+func (*NamingPKConventionAdvisor) 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, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &namingPKConventionChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ catalog: checkCtx.Catalog,
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type namingPKConventionChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ format string
+ maxLength int
+ templateList []string
+ catalog *catalog.Finder
+ statementsText string
+}
+
+type pkMetaData struct {
+ pkName string
+ tableName string
+ schemaName string
+ line int
+ metaData map[string]string
+}
+
+// EnterCreatestmt handles CREATE TABLE with PRIMARY KEY constraints
+func (c *namingPKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ var tableName, schemaName string
+ allQualifiedNames := ctx.AllQualified_name()
+ if len(allQualifiedNames) > 0 {
+ tableName = extractTableName(allQualifiedNames[0])
+ schemaName = extractSchemaName(allQualifiedNames[0])
+ if schemaName == "" {
+ schemaName = "public"
+ }
+ }
+
+ // Check table-level constraints
+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ for _, elem := range allElements {
+ // Check table-level PRIMARY KEY constraint
+ if elem.Tableconstraint() != nil {
+ constraint := elem.Tableconstraint()
+ if pkData := c.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {
+ c.checkPKName(pkData)
+ }
+ }
+
+ // Check column-level PRIMARY KEY constraint - commented out for now
+ // Column-level constraints typically don't have explicit names in the test cases
+ }
+ }
+}
+
+// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT PRIMARY KEY
+func (c *namingPKConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ var tableName, schemaName string
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())
+ if schemaName == "" {
+ schemaName = "public"
+ }
+ }
+
+ // Check all alter table commands
+ if ctx.Alter_table_cmds() != nil {
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // ADD CONSTRAINT
+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
+ constraint := cmd.Tableconstraint()
+ if pkData := c.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {
+ c.checkPKName(pkData)
+ }
+ }
+ }
+ }
+}
+
+// EnterRenamestmt handles ALTER TABLE RENAME CONSTRAINT and ALTER INDEX RENAME TO
+func (c *namingPKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ allNames := ctx.AllName()
+
+ // Check for ALTER TABLE ... RENAME CONSTRAINT old_name TO new_name
+ // Example: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO new_pk
+ if ctx.TABLE() != nil && ctx.CONSTRAINT() != nil && ctx.TO() != nil {
+ var tableName, schemaName string
+ // Get table name from Relation_expr()
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())
+ }
+
+ if len(allNames) >= 2 {
+ oldName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-2])
+ newName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])
+
+ // Check if old constraint is a primary key using catalog
+ if c.catalog != nil {
+ normalizedSchema := schemaName
+ if normalizedSchema == "" {
+ normalizedSchema = "public"
+ }
+ _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ SchemaName: normalizedSchema,
+ TableName: tableName,
+ IndexName: oldName,
+ })
+ if index != nil && index.Primary() {
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ pkData := &pkMetaData{
+ pkName: newName,
+ tableName: tableName,
+ schemaName: schemaName,
+ line: ctx.GetStart().GetLine(),
+ metaData: metaData,
+ }
+ c.checkPKName(pkData)
+ }
+ }
+ }
+ }
+
+ // Check for ALTER INDEX ... RENAME TO new_name
+ // Example: ALTER INDEX old_pk RENAME TO new_pk
+ if ctx.INDEX() != nil && ctx.TO() != nil {
+ var oldIndexName, schemaName string
+
+ // Try Qualified_name first (direct qualified name)
+ if ctx.Qualified_name() != nil {
+ oldIndexName = extractTableName(ctx.Qualified_name())
+ schemaName = extractSchemaName(ctx.Qualified_name())
+ } else if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ // Fall back to Relation_expr
+ oldIndexName = extractTableName(ctx.Relation_expr().Qualified_name())
+ schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())
+ }
+
+ if oldIndexName != "" && len(allNames) > 0 {
+ newIndexName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])
+
+ // Check if this index is a primary key using catalog
+ if c.catalog != nil {
+ normalizedSchema := schemaName
+ if normalizedSchema == "" {
+ normalizedSchema = "public"
+ }
+ // "ALTER INDEX name RENAME TO new_name" doesn't specify table name
+ tableName, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ SchemaName: normalizedSchema,
+ TableName: "", // Empty table name for ALTER INDEX
+ IndexName: oldIndexName,
+ })
+ if index != nil && index.Primary() {
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ pkData := &pkMetaData{
+ pkName: newIndexName,
+ tableName: tableName,
+ schemaName: normalizedSchema,
+ line: ctx.GetStart().GetLine(),
+ metaData: metaData,
+ }
+ c.checkPKName(pkData)
+ }
+ }
+ }
+ }
+}
+
+func (c *namingPKConventionChecker) getPKMetaDataFromTableConstraint(constraint parser.ITableconstraintContext, tableName, schemaName string, line int) *pkMetaData {
+ if constraint == nil || constraint.Constraintelem() == nil {
+ return nil
+ }
+
+ elem := constraint.Constraintelem()
+
+ // Check if this is a PRIMARY KEY constraint
+ if elem.PRIMARY() != nil && elem.KEY() != nil {
+ var pkName string
+ var columnList []string
+
+ // Try to get constraint name using GetText() on constraint itself and parsing it
+ // Format is usually: CONSTRAINT name PRIMARY KEY (columns) or just PRIMARY KEY (columns)
+ constraintText := constraint.GetText()
+ // Check if it starts with CONSTRAINT keyword
+ if strings.HasPrefix(strings.ToUpper(constraintText), "CONSTRAINT") {
+ // Extract the name between CONSTRAINT and PRIMARY
+ parts := strings.Split(constraintText, "PRIMARY")
+ if len(parts) > 0 {
+ // Remove "CONSTRAINT" prefix
+ namePart := strings.TrimPrefix(strings.ToUpper(parts[0]), "CONSTRAINT")
+ namePart = strings.TrimSpace(strings.ToLower(namePart))
+ // The name is before the keyword PRIMARY
+ // This is a simplified extraction
+ if namePart != "" && !strings.Contains(namePart, "(") {
+ pkName = namePart
+ }
+ }
+ }
+
+ // Get column list
+ if elem.Columnlist() != nil {
+ allColumns := elem.Columnlist().AllColumnElem()
+ for _, col := range allColumns {
+ if col.Colid() != nil {
+ columnList = append(columnList, pgparser.NormalizePostgreSQLColid(col.Colid()))
+ }
+ }
+ }
+
+ // PRIMARY KEY USING INDEX
+ if elem.Existingindex() != nil && elem.Existingindex().Name() != nil {
+ // Extract index name properly
+ indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())
+ // Find the index in catalog to get column list
+ if c.catalog != nil && indexName != "" {
+ normalizedSchema := schemaName
+ if normalizedSchema == "" {
+ normalizedSchema = "public"
+ }
+ _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ SchemaName: normalizedSchema,
+ TableName: tableName,
+ IndexName: indexName,
+ })
+ if index != nil {
+ columnList = index.ExpressionList()
+ }
+ }
+ }
+
+ if pkName != "" {
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ return &pkMetaData{
+ pkName: pkName,
+ tableName: tableName,
+ schemaName: schemaName,
+ line: line,
+ metaData: metaData,
+ }
+ }
+ }
+
+ return nil
+}
+
+func (c *namingPKConventionChecker) checkPKName(pkData *pkMetaData) {
+ regex, err := getTemplateRegexp(c.format, c.templateList, pkData.metaData)
+ if err != nil {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.Internal.Int32(),
+ Title: "Internal error for primary key naming convention rule",
+ Content: fmt.Sprintf("Failed to compile regex: %v", err),
+ StartPosition: &storepb.Position{
+ Line: int32(pkData.line),
+ Column: 0,
+ },
+ })
+ return
+ }
+
+ if !regex.MatchString(pkData.pkName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingPKConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf(`Primary key in table "%s" mismatches the naming convention, expect %q but found "%s"`, pkData.tableName, regex, pkData.pkName),
+ StartPosition: &storepb.Position{
+ Line: int32(pkData.line),
+ Column: 0,
+ },
+ })
+ }
+
+ if c.maxLength > 0 && len(pkData.pkName) > c.maxLength {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingPKConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf(`Primary key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, pkData.pkName, pkData.tableName, c.maxLength),
+ StartPosition: &storepb.Position{
+ Line: int32(pkData.line),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_unique_key_convention.go
new file mode 100644
index 0000000000..d60835f1f8
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_naming_unique_key_convention.go
@@ -0,0 +1,395 @@
+package pgantlr
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+ "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"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"
+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"
+)
+
+var (
+ _ advisor.Advisor = (*NamingUKConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleUKNaming, &NamingUKConventionAdvisor{})
+}
+
+// NamingUKConventionAdvisor is the advisor checking for unique key naming convention.
+type NamingUKConventionAdvisor struct {
+}
+
+// Check checks for unique key naming convention.
+func (*NamingUKConventionAdvisor) 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, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &namingUKConventionChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ catalog: checkCtx.Catalog,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type namingUKConventionChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ format string
+ maxLength int
+ templateList []string
+ catalog *catalog.Finder
+}
+
+//nolint:unused
+type indexMetaData struct {
+ indexName string
+ tableName string
+ line int
+ metaData map[string]string
+}
+
+// EnterIndexstmt handles CREATE UNIQUE INDEX statements
+func (c *namingUKConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Only check UNIQUE indexes
+ if ctx.Opt_unique() == nil || ctx.Opt_unique().UNIQUE() == nil {
+ return
+ }
+
+ indexName := ""
+ if ctx.Name() != nil {
+ indexName = pgparser.NormalizePostgreSQLName(ctx.Name())
+ }
+
+ tableName := ""
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ }
+
+ // Extract column list
+ var columnList []string
+ if ctx.Index_params() != nil {
+ allParams := ctx.Index_params().AllIndex_elem()
+ for _, param := range allParams {
+ if param.Colid() != nil {
+ colName := pgparser.NormalizePostgreSQLColid(param.Colid())
+ columnList = append(columnList, colName)
+ }
+ }
+ }
+
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+
+ c.checkUniqueKeyName(indexName, tableName, metaData, ctx.GetStart().GetLine())
+}
+
+// EnterCreatestmt handles CREATE TABLE with UNIQUE constraints
+func (c *namingUKConventionChecker) 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
+ }
+
+ // Check table-level constraints
+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {
+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()
+ for _, elem := range allElements {
+ if elem.Tableconstraint() != nil {
+ c.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())
+ }
+ // Check column-level constraints
+ if elem.ColumnDef() != nil {
+ c.checkColumnDef(elem.ColumnDef(), tableName)
+ }
+ }
+ }
+}
+
+// EnterAltertablestmt handles ALTER TABLE statements
+func (c *namingUKConventionChecker) 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
+ }
+
+ if ctx.Alter_table_cmds() != nil {
+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()
+ for _, cmd := range allCmds {
+ // ADD CONSTRAINT
+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
+ c.checkTableConstraint(cmd.Tableconstraint(), tableName, ctx.GetStart().GetLine())
+ }
+ // ADD COLUMN with constraints
+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {
+ c.checkColumnDef(cmd.ColumnDef(), tableName)
+ }
+ }
+ }
+
+ // Note: ALTER TABLE ... RENAME CONSTRAINT is handled in EnterRenamestmt
+ // because PostgreSQL parser treats "ALTER TABLE t RENAME CONSTRAINT old TO new"
+ // as a rename statement, not as an alter_table_cmd
+}
+
+// EnterRenamestmt handles ALTER INDEX ... RENAME TO and ALTER TABLE ... RENAME CONSTRAINT statements
+func (c *namingUKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check for ALTER INDEX ... RENAME TO
+ if ctx.INDEX() != nil && ctx.TO() != nil {
+ allNames := ctx.AllName()
+ if len(allNames) < 1 {
+ return
+ }
+
+ // Get old index name from qualified_name
+ var oldIndexName string
+ if ctx.Qualified_name() != nil {
+ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Qualified_name())
+ if len(parts) > 0 {
+ oldIndexName = parts[len(parts)-1]
+ }
+ }
+
+ // Get new index name from the name after TO
+ newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])
+
+ // Look up the index in catalog to determine if it's a unique key
+ if c.catalog != nil && oldIndexName != "" {
+ tableName, index := c.findIndex("", "", oldIndexName)
+ if index != nil && index.Unique() && !index.Primary() {
+ c.checkUniqueKeyName(newIndexName, tableName, map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }, ctx.GetStart().GetLine())
+ }
+ }
+ }
+
+ // Check for ALTER TABLE ... RENAME CONSTRAINT
+ if ctx.CONSTRAINT() != nil && ctx.TO() != nil && c.catalog != nil {
+ allNames := ctx.AllName()
+ if len(allNames) >= 2 {
+ oldConstraintName := pgparser.NormalizePostgreSQLName(allNames[0])
+ newConstraintName := pgparser.NormalizePostgreSQLName(allNames[1])
+
+ // Get table name from the statement
+ var tableName, schemaName string
+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {
+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())
+ schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())
+ }
+
+ // Check if this is a unique key constraint in catalog
+ foundTableName, index := c.findIndex(schemaName, tableName, oldConstraintName)
+ if index != nil && index.Unique() && !index.Primary() {
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),
+ advisor.TableNameTemplateToken: foundTableName,
+ }
+ c.checkUniqueKeyName(newConstraintName, foundTableName, metaData, ctx.GetStart().GetLine())
+ }
+ }
+ }
+}
+
+func (c *namingUKConventionChecker) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {
+ if constraint == nil {
+ return
+ }
+
+ constraintName := ""
+ if constraint.Name() != nil {
+ constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())
+ }
+
+ if constraint.Constraintelem() != nil {
+ elem := constraint.Constraintelem()
+
+ // UNIQUE constraint
+ if elem.UNIQUE() != nil {
+ var columnList []string
+ if elem.Columnlist() != nil {
+ allColumns := elem.Columnlist().AllColumnElem()
+ for _, col := range allColumns {
+ if col.Colid() != nil {
+ colName := pgparser.NormalizePostgreSQLColid(col.Colid())
+ columnList = append(columnList, colName)
+ }
+ }
+ } else if elem.Existingindex() != nil && elem.Existingindex().Name() != nil {
+ // Handle UNIQUE USING INDEX - the column list is in the existing index
+ indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())
+ foundTableName, index := c.findIndex("", tableName, indexName)
+ if index != nil {
+ columnList = index.ExpressionList()
+ tableName = foundTableName
+ }
+ }
+
+ // Only check if we have a constraint name (unnamed constraints are auto-generated)
+ if constraintName != "" {
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ c.checkUniqueKeyName(constraintName, tableName, metaData, line)
+ }
+ }
+ }
+}
+
+func (c *namingUKConventionChecker) checkColumnDef(columndef parser.IColumnDefContext, tableName string) {
+ if columndef == nil {
+ return
+ }
+
+ colName := ""
+ if columndef.Colid() != nil {
+ colName = pgparser.NormalizePostgreSQLColid(columndef.Colid())
+ }
+
+ // Check column-level constraints
+ if columndef.Colquallist() != nil {
+ allQuals := columndef.Colquallist().AllColconstraint()
+ for _, qual := range allQuals {
+ if qual.Colconstraintelem() != nil {
+ elem := qual.Colconstraintelem()
+ // Check for UNIQUE constraint
+ if elem.UNIQUE() != nil {
+ // Column-level unique constraints with names
+ constraintName := ""
+ if qual.Name() != nil {
+ constraintName = pgparser.NormalizePostgreSQLName(qual.Name())
+ }
+
+ // Only check if we have a constraint name
+ if constraintName != "" {
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: colName,
+ advisor.TableNameTemplateToken: tableName,
+ }
+ c.checkUniqueKeyName(constraintName, tableName, metaData, qual.GetStart().GetLine())
+ }
+ }
+ }
+ }
+ }
+}
+
+func (c *namingUKConventionChecker) checkUniqueKeyName(indexName, tableName string, metaData map[string]string, line int) {
+ regex, err := c.getTemplateRegexp(metaData)
+ if err != nil {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.Internal.Int32(),
+ Title: "Internal error for unique key naming convention rule",
+ Content: fmt.Sprintf("Failed to compile regex for unique key naming convention: %v", err),
+ })
+ return
+ }
+
+ if !regex.MatchString(indexName) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingUKConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf(`Unique key in table "%s" mismatches the naming convention, expect %q but found "%s"`, tableName, regex, indexName),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+
+ if c.maxLength > 0 && len(indexName) > c.maxLength {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.NamingUKConventionMismatch.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf(`Unique key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, indexName, tableName, c.maxLength),
+ StartPosition: &storepb.Position{
+ Line: int32(line),
+ Column: 0,
+ },
+ })
+ }
+}
+
+func (c *namingUKConventionChecker) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {
+ template := c.format
+ for _, key := range c.templateList {
+ if token, ok := tokens[key]; ok {
+ template = strings.ReplaceAll(template, key, token)
+ }
+ }
+ return regexp.Compile(template)
+}
+
+// findIndex returns index found in catalogs, nil if not found.
+func (c *namingUKConventionChecker) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {
+ if c.catalog == nil {
+ return "", nil
+ }
+ return c.catalog.Origin.FindIndex(&catalog.IndexFind{
+ SchemaName: normalizeSchemaName(schemaName),
+ TableName: tableName,
+ IndexName: indexName,
+ })
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_check_set_role_variable.go b/backend/plugin/advisor/pgantlr/advisor_statement_check_set_role_variable.go
new file mode 100644
index 0000000000..c4476371b2
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_check_set_role_variable.go
@@ -0,0 +1,111 @@
+package pgantlr
+
+import (
+ "context"
+
+ "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 = (*StatementCheckSetRoleVariable)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementCheckSetRoleVariable, &StatementCheckSetRoleVariable{})
+}
+
+type StatementCheckSetRoleVariable struct {
+}
+
+func (*StatementCheckSetRoleVariable) 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 := &statementCheckSetRoleVariableChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ if !checker.hasSetRole {
+ return []*storepb.Advice{{
+ Status: level,
+ Code: advisor.StatementCheckSetRoleVariable.Int32(),
+ Title: checker.title,
+ Content: "No SET ROLE statement found.",
+ StartPosition: nil,
+ }}, nil
+ }
+
+ return nil, nil
+}
+
+type statementCheckSetRoleVariableChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ level storepb.Advice_Status
+ title string
+ hasSetRole bool
+ foundNonSetStmt bool
+}
+
+// EnterVariablesetstmt handles SET statements
+func (c *statementCheckSetRoleVariableChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // If we already found a non-SET statement, skip this
+ if c.foundNonSetStmt {
+ return
+ }
+
+ // Check if this is a SET ROLE statement
+ setRest := ctx.Set_rest()
+ if setRest != nil {
+ setRestMore := setRest.Set_rest_more()
+ if setRestMore != nil && setRestMore.ROLE() != nil {
+ c.hasSetRole = true
+ }
+ }
+}
+
+// EnterEveryRule is called for every rule entry to detect non-SET statements
+func (c *statementCheckSetRoleVariableChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // If we already found a non-SET statement, no need to continue checking
+ if c.foundNonSetStmt {
+ return
+ }
+
+ // Check if this is a non-SET statement at the top level
+ // We only care about statements that are not VariablesetstmtContext
+ if _, isSetStmt := ctx.(*parser.VariablesetstmtContext); !isSetStmt {
+ // Check if this is a statement node (not structural nodes like Stmt, Root, etc.)
+ switch ctx.(type) {
+ case *parser.RootContext, *parser.StmtblockContext, *parser.StmtmultiContext, *parser.StmtContext:
+ // These are structural nodes, not actual statements
+ return
+ default:
+ // This is a non-SET statement
+ c.foundNonSetStmt = true
+ }
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_dml.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_dml.go
new file mode 100644
index 0000000000..7ed70acbf2
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_dml.go
@@ -0,0 +1,252 @@
+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 = (*StatementDisallowMixInDMLAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowMixInDML, &StatementDisallowMixInDMLAdvisor{})
+}
+
+// StatementDisallowMixInDMLAdvisor is the advisor checking for disallow mix DDL and DML.
+type StatementDisallowMixInDMLAdvisor struct {
+}
+
+// Check checks for disallow mix DDL and DML.
+func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ // Only check when change type is DML
+ switch checkCtx.ChangeType {
+ case storepb.PlanCheckRunConfig_DML:
+ default:
+ return nil, nil
+ }
+
+ tree, err := getANTLRTree(checkCtx)
+ if err != nil {
+ return nil, err
+ }
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ checker := &statementDisallowMixInDMLChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementDisallowMixInDMLChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ statementsText string
+}
+
+// EnterCreatestmt handles CREATE TABLE statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE TABLE")
+}
+
+// EnterIndexstmt handles CREATE INDEX statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE INDEX")
+}
+
+// EnterAltertablestmt handles ALTER TABLE statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "ALTER TABLE")
+}
+
+// EnterDropstmt handles DROP statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "DROP")
+}
+
+// EnterCreateschemastmt handles CREATE SCHEMA statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreateschemastmt(ctx *parser.CreateschemastmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE SCHEMA")
+}
+
+// EnterCreateseqstmt handles CREATE SEQUENCE statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE SEQUENCE")
+}
+
+// EnterAlterseqstmt handles ALTER SEQUENCE statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "ALTER SEQUENCE")
+}
+
+// EnterViewstmt handles CREATE VIEW statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterViewstmt(ctx *parser.ViewstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE VIEW")
+}
+
+// EnterCreatefunctionstmt handles CREATE FUNCTION statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE FUNCTION")
+}
+
+// EnterCreatetrigstmt handles CREATE TRIGGER statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE TRIGGER")
+}
+
+// EnterRenamestmt handles RENAME statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "RENAME")
+}
+
+// EnterAlterobjectschemastmt handles ALTER ... SET SCHEMA statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterAlterobjectschemastmt(ctx *parser.AlterobjectschemastmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "ALTER SET SCHEMA")
+}
+
+// EnterAlterenumstmt handles ALTER TYPE ... ADD VALUE statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterAlterenumstmt(ctx *parser.AlterenumstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "ALTER TYPE")
+}
+
+// EnterAltercompositetypestmt handles ALTER TYPE (composite) statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterAltercompositetypestmt(ctx *parser.AltercompositetypestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "ALTER TYPE")
+}
+
+// EnterCreateextensionstmt handles CREATE EXTENSION statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE EXTENSION")
+}
+
+// EnterCreatedbstmt handles CREATE DATABASE statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreatedbstmt(ctx *parser.CreatedbstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE DATABASE")
+}
+
+// EnterCreatematviewstmt handles CREATE MATERIALIZED VIEW statements (DDL)
+func (c *statementDisallowMixInDMLChecker) EnterCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.addDDLAdvice(ctx, "CREATE MATERIALIZED VIEW")
+}
+
+func (c *statementDisallowMixInDMLChecker) addDDLAdvice(ctx antlr.ParserRuleContext, _ string) {
+ // Extract the statement text including semicolon using character positions
+ startPos := ctx.GetStart().GetStart()
+ stopPos := ctx.GetStop().GetStop()
+
+ // Find the semicolon after this statement
+ stmtText := ""
+ if stopPos+1 < len(c.statementsText) {
+ // Look for semicolon
+ endPos := stopPos + 1
+ for endPos < len(c.statementsText) && c.statementsText[endPos] != ';' {
+ endPos++
+ }
+ if endPos < len(c.statementsText) {
+ stmtText = c.statementsText[startPos : endPos+1]
+ } else {
+ stmtText = c.statementsText[startPos:stopPos+1] + ";"
+ }
+ } else {
+ stmtText = c.statementsText[startPos:stopPos+1] + ";"
+ }
+
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.StatementDisallowMixDDLDML.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("Data change can only run DML, %q is not DML", stmtText),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_on_del_cascade.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_on_del_cascade.go
new file mode 100644
index 0000000000..9541eee1ac
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_on_del_cascade.go
@@ -0,0 +1,103 @@
+package pgantlr
+
+import (
+ "context"
+
+ "github.com/antlr4-go/antlr/v4"
+
+ 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 = (*StatementDisallowOnDelCascadeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowOnDelCascade, &StatementDisallowOnDelCascadeAdvisor{})
+}
+
+// StatementDisallowOnDelCascadeAdvisor is the advisor checking for ON DELETE CASCADE.
+type StatementDisallowOnDelCascadeAdvisor struct {
+}
+
+// Check checks for ON DELETE CASCADE.
+func (*StatementDisallowOnDelCascadeAdvisor) 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 := &statementDisallowOnDelCascadeChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ statementsText: checkCtx.Statements,
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementDisallowOnDelCascadeChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ statementsText string
+}
+
+// EnterKey_delete checks for ON DELETE CASCADE
+func (c *statementDisallowOnDelCascadeChecker) EnterKey_delete(ctx *parser.Key_deleteContext) {
+ // Check if this has CASCADE as the key_action
+ if ctx.Key_action() != nil {
+ keyAction := ctx.Key_action()
+ // Check if this is CASCADE
+ if keyAction.CASCADE() != nil {
+ // Find the top-level statement context
+ var stmtCtx antlr.ParserRuleContext
+ current := ctx.GetParent()
+ for current != nil {
+ if isTopLevel(current) {
+ if prc, ok := current.(antlr.ParserRuleContext); ok {
+ stmtCtx = prc
+ }
+ break
+ }
+ current = current.GetParent()
+ }
+
+ if stmtCtx != nil {
+ // Note: To match legacy pg-query behavior, we need to use GetLine() - 1
+ // The legacy advisor uses pg_query's stmt_location which points to the position
+ // right before the statement (often a newline), while ANTLR's GetLine() points
+ // to the actual line where the statement starts. This creates an off-by-one
+ // when there are statements before the CREATE TABLE.
+ line := stmtCtx.GetStart().GetLine() - 1
+ if line < 1 {
+ line = 1
+ }
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.StatementDisallowCascade.Int32(),
+ Title: c.title,
+ Content: "The CASCADE option is not permitted for ON DELETE clauses",
+ StartPosition: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
+ Line: int32(line),
+ Column: 0,
+ }, c.statementsText),
+ })
+ }
+ }
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_rm_tbl_cascade.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_rm_tbl_cascade.go
new file mode 100644
index 0000000000..0d856d8f79
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_rm_tbl_cascade.go
@@ -0,0 +1,110 @@
+package pgantlr
+
+import (
+ "context"
+
+ "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 = (*StatementDisallowRemoveTblCascadeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowRemoveTblCascade, &StatementDisallowRemoveTblCascadeAdvisor{})
+}
+
+// StatementDisallowRemoveTblCascadeAdvisor is the advisor checking for disallow CASCADE option when removing tables.
+type StatementDisallowRemoveTblCascadeAdvisor struct {
+}
+
+// Check checks for CASCADE option in DROP TABLE and TRUNCATE TABLE statements.
+func (*StatementDisallowRemoveTblCascadeAdvisor) 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 := &statementDisallowRemoveTblCascadeChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ }
+
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+
+ return checker.adviceList, nil
+}
+
+type statementDisallowRemoveTblCascadeChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+}
+
+// EnterDropstmt handles DROP TABLE statements with CASCADE
+func (c *statementDisallowRemoveTblCascadeChecker) EnterDropstmt(ctx *parser.DropstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is a DROP TABLE statement
+ if ctx.Object_type_any_name() == nil || ctx.Object_type_any_name().TABLE() == nil {
+ return
+ }
+
+ // Check for CASCADE option
+ if c.hasCascadeOption(ctx.Opt_drop_behavior()) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.StatementDisallowCascade.Int32(),
+ Title: c.title,
+ Content: "The use of CASCADE is not permitted when removing a table",
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: int32(ctx.GetStart().GetColumn()),
+ },
+ })
+ }
+}
+
+// EnterTruncatestmt handles TRUNCATE TABLE statements with CASCADE
+func (c *statementDisallowRemoveTblCascadeChecker) EnterTruncatestmt(ctx *parser.TruncatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check for CASCADE option
+ if c.hasCascadeOption(ctx.Opt_drop_behavior()) {
+ c.adviceList = append(c.adviceList, &storepb.Advice{
+ Status: c.level,
+ Code: advisor.StatementDisallowCascade.Int32(),
+ Title: c.title,
+ Content: "The use of CASCADE is not permitted when removing a table",
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: int32(ctx.GetStart().GetColumn()),
+ },
+ })
+ }
+}
+
+// hasCascadeOption checks if the drop behavior is CASCADE
+func (*statementDisallowRemoveTblCascadeChecker) hasCascadeOption(ctx parser.IOpt_drop_behaviorContext) bool {
+ if ctx == nil {
+ return false
+ }
+ return ctx.CASCADE() != nil
+}
diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pgantlr/advisor_statement_dml_dry_run.go
new file mode 100644
index 0000000000..9fd3a8ecc6
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/advisor_statement_dml_dry_run.go
@@ -0,0 +1,146 @@
+package pgantlr
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+
+ "github.com/antlr4-go/antlr/v4"
+ 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 = (*StatementDMLDryRunAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDMLDryRun, &StatementDMLDryRunAdvisor{})
+}
+
+// StatementDMLDryRunAdvisor is the advisor checking for DML dry run.
+type StatementDMLDryRunAdvisor struct {
+}
+
+// Check checks for DML dry run.
+func (*StatementDMLDryRunAdvisor) 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
+ }
+
+ checker := &statementDMLDryRunChecker{
+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
+ level: level,
+ title: string(checkCtx.Rule.Type),
+ ctx: ctx,
+ driver: checkCtx.Driver,
+ usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,
+ statementsText: checkCtx.Statements,
+ }
+
+ // Only run EXPLAIN queries if we have a database connection
+ if checker.driver != nil {
+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)
+ }
+
+ return checker.adviceList, nil
+}
+
+type statementDMLDryRunChecker struct {
+ *parser.BasePostgreSQLParserListener
+
+ adviceList []*storepb.Advice
+ level storepb.Advice_Status
+ title string
+ driver *sql.DB
+ ctx context.Context
+ explainCount int
+ setRoles []string
+ usePostgresDatabaseOwner bool
+ statementsText string
+}
+
+// EnterVariablesetstmt handles SET ROLE statements
+func (c *statementDMLDryRunChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ // Check if this is SET ROLE
+ if ctx.SET() != nil && ctx.Set_rest() != nil && ctx.Set_rest().Set_rest_more() != nil {
+ setRestMore := ctx.Set_rest().Set_rest_more()
+ if setRestMore.ROLE() != nil {
+ // Store the SET ROLE statement text
+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ c.setRoles = append(c.setRoles, stmtText)
+ }
+ }
+}
+
+// EnterInsertstmt handles INSERT statements
+func (c *statementDMLDryRunChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.checkDMLDryRun(ctx)
+}
+
+// EnterUpdatestmt handles UPDATE statements
+func (c *statementDMLDryRunChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.checkDMLDryRun(ctx)
+}
+
+// EnterDeletestmt handles DELETE statements
+func (c *statementDMLDryRunChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {
+ if !isTopLevel(ctx.GetParent()) {
+ return
+ }
+
+ c.checkDMLDryRun(ctx)
+}
+
+func (c *statementDMLDryRunChecker) checkDMLDryRun(ctx antlr.ParserRuleContext) {
+ // Check if we've hit the maximum number of EXPLAIN queries
+ if c.explainCount >= common.MaximumLintExplainSize {
+ return
+ }
+
+ c.explainCount++
+
+ // Get the statement text
+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())
+ normalizedStmt := advisor.NormalizeStatement(stmtText)
+
+ // Run EXPLAIN to perform dry run
+ _, 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.StatementDMLDryRunFailed.Int32(),
+ Title: c.title,
+ Content: fmt.Sprintf("\"%s\" dry runs failed: %s", normalizedStmt, err.Error()),
+ StartPosition: &storepb.Position{
+ Line: int32(ctx.GetStart().GetLine()),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/pgantlr/pgantlr_test.go b/backend/plugin/advisor/pgantlr/pgantlr_test.go
index 31bcc15c7c..e06ebb844a 100644
--- a/backend/plugin/advisor/pgantlr/pgantlr_test.go
+++ b/backend/plugin/advisor/pgantlr/pgantlr_test.go
@@ -22,37 +22,40 @@ func TestPostgreSQLANTLRRules(t *testing.T) {
advisor.SchemaRuleColumnTypeDisallowList, // Migrated from legacy
advisor.SchemaRuleCommentLength, // Migrated from legacy
advisor.SchemaRuleCreateIndexConcurrently, // Migrated from legacy
+ advisor.SchemaRuleFKNaming, // Migrated from legacy
+ advisor.SchemaRuleFullyQualifiedObjectName, // Migrated from legacy
+ advisor.SchemaRuleIDXNaming, // Migrated from legacy
advisor.SchemaRuleIndexKeyNumberLimit, // Migrated from legacy
advisor.SchemaRuleIndexNoDuplicateColumn, // Migrated from legacy
advisor.SchemaRuleIndexPrimaryKeyTypeAllowlist, // Migrated from legacy
advisor.SchemaRuleIndexTotalNumberLimit, // Migrated from legacy
+ advisor.SchemaRulePKNaming, // 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
advisor.SchemaRuleSchemaBackwardCompatibility, // Migrated from legacy
- advisor.SchemaRuleStatementAddFKNotValid, // Migrated from legacy
- advisor.SchemaRuleStatementDisallowCommit, // Migrated from legacy
- advisor.SchemaRuleStatementNonTransactional, // Migrated from legacy
- advisor.SchemaRuleTableDropNamingConvention, // Migrated from legacy
- advisor.SchemaRuleTableDisallowPartition, // Migrated from legacy
- advisor.SchemaRuleTableNoFK, // Migrated from legacy
- advisor.SchemaRuleTableNaming, // Migrated from legacy
- advisor.SchemaRuleTableCommentConvention, // Migrated from legacy
- advisor.SchemaRuleStatementCreateSpecifySchema, // Migrated from legacy
advisor.SchemaRuleStatementAddCheckNotValid, // Migrated from legacy
+ advisor.SchemaRuleStatementAddFKNotValid, // Migrated from legacy
advisor.SchemaRuleStatementAffectedRowLimit, // Migrated from legacy
+ advisor.SchemaRuleStatementCheckSetRoleVariable, // Migrated from legacy
+ advisor.SchemaRuleStatementCreateSpecifySchema, // Migrated from legacy
advisor.SchemaRuleStatementDisallowAddColumnWithDefault, // Migrated from legacy
advisor.SchemaRuleStatementDisallowAddNotNull, // Migrated from legacy
+ advisor.SchemaRuleStatementDisallowCommit, // Migrated from legacy
advisor.SchemaRuleStatementDisallowMixInDDL, // Migrated from legacy
- // advisor.SchemaRuleTableRequirePK, // WIP - needs debugging
- // Add real rules here as you migrate them from legacy pg/ folder
- // Example:
- // advisor.SchemaRuleStatementDisallowCommit,
- // advisor.SchemaRuleStatementInsertMustSpecifyColumn,
- // advisor.SchemaRuleTableNaming,
- // etc.
+ advisor.SchemaRuleStatementDisallowMixInDML, // Migrated from legacy
+ advisor.SchemaRuleStatementDisallowOnDelCascade, // Migrated from legacy
+ advisor.SchemaRuleStatementDisallowRemoveTblCascade, // Migrated from legacy
+ advisor.SchemaRuleStatementDMLDryRun, // Migrated from legacy
+ advisor.SchemaRuleStatementNonTransactional, // Migrated from legacy
+ advisor.SchemaRuleTableCommentConvention, // Migrated from legacy
+ advisor.SchemaRuleTableDisallowPartition, // Migrated from legacy
+ advisor.SchemaRuleTableDropNamingConvention, // Migrated from legacy
+ advisor.SchemaRuleTableNaming, // Migrated from legacy
+ advisor.SchemaRuleTableNoFK, // Migrated from legacy
+ advisor.SchemaRuleUKNaming, // Migrated from legacy
}
for _, rule := range antlrRules {
@@ -63,10 +66,12 @@ 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.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes
- advisor.SchemaRuleTableRequirePK: true, // Needs catalog for DROP CONSTRAINT/COLUMN checks
- // Other advisors don't need mock data
+ advisor.BuiltinRulePriorBackupCheck: true,
+ advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case
+ advisor.SchemaRuleFullyQualifiedObjectName: true, // Needs metadata for SELECT statement checks
+ advisor.SchemaRuleIDXNaming: true, // Needs catalog for ALTER INDEX RENAME
+ advisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes
+ advisor.SchemaRulePKNaming: true, // Needs catalog for PRIMARY KEY USING INDEX
+ advisor.SchemaRuleTableRequirePK: true, // Needs catalog for DROP CONSTRAINT/COLUMN checks
+ advisor.SchemaRuleUKNaming: true, // Needs catalog for UNIQUE USING INDEX
}
diff --git a/backend/plugin/advisor/pgantlr/test/naming_fully_qualified.yaml b/backend/plugin/advisor/pgantlr/test/naming_fully_qualified.yaml
new file mode 100644
index 0000000000..f09ac6c1b3
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/naming_fully_qualified.yaml
@@ -0,0 +1,103 @@
+- statement: |-
+ CREATE TABLE public.pokesv1 (foo int, bar varchar);
+ INSERT INTO public.pokesv1 VALUES (1, '1');
+ CREATE TABLE public.pokes (foo int);
+ CREATE TABLE pokesv2 (foo int, bar varchar);
+ changeType: 1
+ want:
+ - status: 2
+ code: 310
+ title: naming.fully-qualified
+ content: 'unqualified object name: ''pokesv2'''
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE SEQUENCE public.seq;
+ CREATE SEQUENCE seq;
+ DROP SEQUENCE public.seq
+ changeType: 1
+ want:
+ - status: 2
+ code: 310
+ title: naming.fully-qualified
+ content: 'unqualified object name: ''seq'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TRIGGER test_trigger
+ AFTER INSERT ON pokesv1
+ FOR EACH ROW
+ EXECUTE PROCEDURE trigger_function();
+ INSERT INTO bbdev.public.pokesv1 VALUES (1, '1');
+ changeType: 1
+ want:
+ - status: 2
+ code: 310
+ title: naming.fully-qualified
+ content: 'unqualified object name: ''pokesv1'''
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: DROP TRIGGER test_trigger ON public.pokes;
+ changeType: 1
+- statement: |-
+ CREATE TABLE public.pokesv1 (foo int, bar varchar);
+ ALTER TABLE pokesv1 RENAME TO pokesv2;
+ changeType: 1
+ want:
+ - status: 2
+ code: 310
+ title: naming.fully-qualified
+ content: 'unqualified object name: ''pokesv1'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE public.pokesv1 (foo int);
+ INSERT INTO pokesv1(foo) VALUES (1);
+ INSERT INTO public.pokesv1 VALUES (2);
+ changeType: 1
+ want:
+ - status: 2
+ code: 310
+ title: naming.fully-qualified
+ content: 'unqualified object name: ''pokesv1'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE public.pokesv1 (foo int);
+ UPDATE public.pokesv1 SET foo = 1 WHERE 1=1;
+ UPDATE public.pokesv1 SET foo = 2 WHERE foo=1;
+ UPDATE pokesv1 SET foo = 1 WHERE 1=1;
+ UPDATE public.pokesv1 SET foo = 1 WHERE 1 > 1;
+ changeType: 1
+ want:
+ - status: 2
+ code: 310
+ title: naming.fully-qualified
+ content: 'unqualified object name: ''pokesv1'''
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: "CREATE TABLE public.pokes (foo int); \nSELECT * FROM (SELECT (id) FROM tech_book) AS foo;"
+ changeType: 1
+ want:
+ - status: 2
+ code: 310
+ title: naming.fully-qualified
+ content: 'unqualified object name: ''tech_book'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: "CREATE TABLE public.pokes (foo int);\nWITH foo1 AS (SELECT * FROM public.tech_book) \nSELECT * FROM foo1;"
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/test/naming_index_fk.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_fk.yaml
new file mode 100644
index 0000000000..8ccacc5cb9
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/naming_index_fk.yaml
@@ -0,0 +1,68 @@
+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_tech_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id)
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_author_id FOREIGN KEY (author_id) REFERENCES author (id)
+ changeType: 1
+ want:
+ - status: 2
+ code: 305
+ title: naming.index.fk
+ content: Foreign key in table "tech_book" mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found "fk_author_id"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD CONSTRAINT wlwflloczhmazamdotbibvqrrzyhmvkslvyzpmlmxt FOREIGN KEY (author_id) REFERENCES author (id)
+ changeType: 1
+ want:
+ - status: 2
+ code: 305
+ title: naming.index.fk
+ content: Foreign key in table "tech_book" mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found "wlwflloczhmazamdotbibvqrrzyhmvkslvyzpmlmxt"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD COLUMN author_id INT CONSTRAINT fk_tech_book_author_id_author_id REFERENCES author (id)
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD COLUMN author_id INT CONSTRAINT fk_author_id REFERENCES author (id)
+ changeType: 1
+ want:
+ - status: 2
+ code: 305
+ title: naming.index.fk
+ content: Foreign key in table "tech_book" mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found "fk_author_id"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT, author_id INT, CONSTRAINT fk_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id))
+ changeType: 1
+- statement: CREATE TABLE book(id INT, author_id INT, CONSTRAINT fk_book_author_id FOREIGN KEY (author_id) REFERENCES author (id))
+ changeType: 1
+ want:
+ - status: 2
+ code: 305
+ title: naming.index.fk
+ content: Foreign key in table "book" mismatches the naming convention, expect "^$|^fk_book_author_id_author_id$" but found "fk_book_author_id"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT, author_id INT CONSTRAINT fk_book_author_id_author_id REFERENCES author (id))
+ changeType: 1
+- statement: |-
+ -- this is the first line.
+ CREATE TABLE book(
+ id INT,
+ author_id INT CONSTRAINT fk_book_author_id REFERENCES author (id)
+ )
+ changeType: 1
+ want:
+ - status: 2
+ code: 305
+ title: naming.index.fk
+ content: Foreign key in table "book" mismatches the naming convention, expect "^$|^fk_book_author_id_author_id$" but found "fk_book_author_id"
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/naming_index_idx.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_idx.yaml
new file mode 100644
index 0000000000..55040616e3
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/naming_index_idx.yaml
@@ -0,0 +1,37 @@
+- statement: CREATE INDEX idx_tech_book_id_name ON tech_book(id, name)
+ changeType: 1
+- statement: CREATE INDEX tech_book_id_name ON tech_book(id, name)
+ changeType: 1
+ want:
+ - status: 2
+ code: 303
+ title: naming.index.idx
+ content: Index in table "tech_book" mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found "tech_book_id_name"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE INDEX wfdtqyetsyoovcvikjlyfukxyjxxxhifl ON tech_book(id, name)
+ changeType: 1
+ want:
+ - status: 2
+ code: 303
+ title: naming.index.idx
+ content: Index in table "tech_book" mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found "wfdtqyetsyoovcvikjlyfukxyjxxxhifl"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER INDEX old_index RENAME TO idx_tech_book_id_name
+ changeType: 1
+- statement: ALTER INDEX old_index RENAME TO idx_tech_book
+ changeType: 1
+ want:
+ - status: 2
+ code: 303
+ title: naming.index.idx
+ content: Index in table "tech_book" mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found "idx_tech_book"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/naming_index_pk.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_pk.yaml
new file mode 100644
index 0000000000..6e9faff391
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/naming_index_pk.yaml
@@ -0,0 +1,86 @@
+- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY (id, name)
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD CONSTRAINT tech_book_id_name PRIMARY KEY (id, name)
+ changeType: 1
+ want:
+ - status: 2
+ code: 306
+ title: naming.index.pk
+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "tech_book_id_name"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD CONSTRAINT udmhjtnsaablcmjhqcznfiwtnevcehcvw PRIMARY KEY (id, name)
+ changeType: 1
+ want:
+ - status: 2
+ code: 306
+ title: naming.index.pk
+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "udmhjtnsaablcmjhqcznfiwtnevcehcvw"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT, name VARCHAR(20), CONSTRAINT pk_book_name PRIMARY KEY (name))
+ changeType: 1
+- statement: |-
+ -- this is the first line.
+ CREATE TABLE book(
+ id INT,
+ name VARCHAR(20),
+ CONSTRAINT tech_book_name PRIMARY KEY (name)
+ )
+ changeType: 1
+ want:
+ - status: 2
+ code: 306
+ title: naming.index.pk
+ content: Primary key in table "book" mismatches the naming convention, expect "^$|^pk_book_name$" but found "tech_book_name"
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT, name VARCHAR(20), PRIMARY KEY (name))
+ changeType: 1
+- statement: CREATE TABLE book(id INT, name VARCHAR(20) PRIMARY KEY)
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY USING INDEX old_index
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book PRIMARY KEY USING INDEX old_index
+ changeType: 1
+ want:
+ - status: 2
+ code: 306
+ title: naming.index.pk
+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "pk_tech_book"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO pk_tech_book_id_name
+ changeType: 1
+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO pk_tech_book
+ changeType: 1
+ want:
+ - status: 2
+ code: 306
+ title: naming.index.pk
+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "pk_tech_book"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER INDEX old_pk RENAME TO pk_tech_book_id_name
+ changeType: 1
+- statement: ALTER INDEX old_pk RENAME TO pk_tech_book
+ changeType: 1
+ want:
+ - status: 2
+ code: 306
+ title: naming.index.pk
+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "pk_tech_book"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/naming_index_uk.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_uk.yaml
new file mode 100644
index 0000000000..247f5c6ac6
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/naming_index_uk.yaml
@@ -0,0 +1,99 @@
+- statement: CREATE UNIQUE INDEX uk_tech_book_id_name ON tech_book(id, name)
+ changeType: 1
+- statement: CREATE UNIQUE INDEX tech_book_id_name ON tech_book(id, name)
+ changeType: 1
+ want:
+ - status: 2
+ code: 304
+ title: naming.index.uk
+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "tech_book_id_name"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE UNIQUE INDEX dzfzqbhnkiiegdhvqjeqoevesfuwcmokrehxlapoqj ON tech_book(id, name)
+ changeType: 1
+ want:
+ - status: 2
+ code: 304
+ title: naming.index.uk
+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "dzfzqbhnkiiegdhvqjeqoevesfuwcmokrehxlapoqj"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD CONSTRAINT uk_tech_book_id_name UNIQUE (id, name)
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD CONSTRAINT tech_book_id_name UNIQUE (id, name)
+ changeType: 1
+ want:
+ - status: 2
+ code: 304
+ title: naming.index.uk
+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "tech_book_id_name"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20), CONSTRAINT uk_book_name UNIQUE (name))
+ changeType: 1
+- statement: |-
+ -- this is the first line.
+ CREATE TABLE book(
+ id INT PRIMARY KEY,
+ name VARCHAR(20),
+ CONSTRAINT book_name UNIQUE (name)
+ )
+ changeType: 1
+ want:
+ - status: 2
+ code: 304
+ title: naming.index.uk
+ content: Unique key in table "book" mismatches the naming convention, expect "^$|^uk_book_name$" but found "book_name"
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20), UNIQUE (name))
+ changeType: 1
+- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20) UNIQUE)
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD CONSTRAINT uk_tech_book_id_name UNIQUE USING INDEX old_index
+ changeType: 1
+- statement: ALTER TABLE tech_book ADD CONSTRAINT uk_tech_book UNIQUE USING INDEX old_index
+ changeType: 1
+ want:
+ - status: 2
+ code: 304
+ title: naming.index.uk
+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "uk_tech_book"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_uk TO uk_tech_book_id_name
+ changeType: 1
+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_uk TO uk_tech_book
+ changeType: 1
+ want:
+ - status: 2
+ code: 304
+ title: naming.index.uk
+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "uk_tech_book"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER INDEX old_uk RENAME TO uk_tech_book_id_name
+ changeType: 1
+- statement: ALTER INDEX old_uk RENAME TO uk_tech_book
+ changeType: 1
+ want:
+ - status: 2
+ code: 304
+ title: naming.index.uk
+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "uk_tech_book"
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_check_set_role_variable.yaml b/backend/plugin/advisor/pgantlr/test/statement_check_set_role_variable.yaml
new file mode 100644
index 0000000000..0e76beb7a9
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_check_set_role_variable.yaml
@@ -0,0 +1,11 @@
+- statement: SET SESSION ROLE joe; SELECT * FROM t
+ changeType: 1
+- statement: INSERT INTO t (id) VALUES (1);
+ changeType: 2
+ want:
+ - status: 2
+ code: 217
+ title: statement.check-set-role-variable
+ content: No SET ROLE statement found.
+ startposition: null
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_dml.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_dml.yaml
new file mode 100644
index 0000000000..3c10935ca0
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_dml.yaml
@@ -0,0 +1,15 @@
+- statement: DELETE FROM tech_book WHERE a > 1;
+ changeType: 2
+- statement: UPDATE tech_book SET id = 1;
+ changeType: 2
+- statement: ALTER TABLE tech_book ADD COLUMN author TEXT; UPDATE tech_book SET id = 1;DELETE FROM tech_book WHERE a > 1;
+ changeType: 2
+ want:
+ - status: 2
+ code: 227
+ title: statement.disallow-mix-in-dml
+ content: Data change can only run DML, "ALTER TABLE tech_book ADD COLUMN author TEXT;" is not DML
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_on_del_cascade.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_on_del_cascade.yaml
new file mode 100644
index 0000000000..c857849dd3
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_on_del_cascade.yaml
@@ -0,0 +1,44 @@
+- statement: TRUNCATE TABLE issues CASCADE;
+ changeType: 1
+- statement: |-
+ CREATE TABLE users (
+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,
+ user_id integer NOT NULL,
+ PRIMARY KEY (tenant_id, user_id)
+ );
+ changeType: 1
+ want:
+ - status: 2
+ code: 213
+ title: statement.disallow-on-del-cascade
+ content: The CASCADE option is not permitted for ON DELETE clauses
+ startposition:
+ line: 1
+ column: 1
+ endposition: null
+- statement: |-
+ CREATE TABLE users (
+ tenant_id integer,
+ user_id integer NOT NULL,
+ PRIMARY KEY (tenant_id, user_id)
+ );
+ COMMENT ON TABLE users IS 'CASCADE COMMENT';
+ changeType: 1
+- statement: |-
+ TRUNCATE TABLE tech_book CASCADE;
+ DROP TABLE tech_book CASCADE;
+ CREATE TABLE users (
+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,
+ user_id integer NOT NULL,
+ PRIMARY KEY (tenant_id, user_id)
+ );
+ changeType: 1
+ want:
+ - status: 2
+ code: 213
+ title: statement.disallow-on-del-cascade
+ content: The CASCADE option is not permitted for ON DELETE clauses
+ startposition:
+ line: 2
+ column: 1
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_rm_tbl_cascade.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_rm_tbl_cascade.yaml
new file mode 100644
index 0000000000..7c4bd65518
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_rm_tbl_cascade.yaml
@@ -0,0 +1,52 @@
+- statement: TRUNCATE TABLE issues CASCADE;
+ changeType: 1
+ want:
+ - status: 2
+ code: 213
+ title: statement.disallow-rm-tbl-cascade
+ content: The use of CASCADE is not permitted when removing a table
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE users (
+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,
+ user_id integer NOT NULL,
+ PRIMARY KEY (tenant_id, user_id)
+ );
+ changeType: 1
+- statement: |-
+ CREATE TABLE users (
+ tenant_id integer,
+ user_id integer NOT NULL,
+ PRIMARY KEY (tenant_id, user_id)
+ );
+ COMMENT ON TABLE users IS 'CASCADE COMMENT';
+ changeType: 1
+- statement: |-
+ TRUNCATE TABLE tech_book CASCADE;
+ DROP TABLE tech_book CASCADE;
+ CREATE TABLE users (
+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,
+ user_id integer NOT NULL,
+ PRIMARY KEY (tenant_id, user_id)
+ );
+ changeType: 1
+ want:
+ - status: 2
+ code: 213
+ title: statement.disallow-rm-tbl-cascade
+ content: The use of CASCADE is not permitted when removing a table
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 213
+ title: statement.disallow-rm-tbl-cascade
+ content: The use of CASCADE is not permitted when removing a table
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_dml_dry_run.yaml b/backend/plugin/advisor/pgantlr/test/statement_dml_dry_run.yaml
new file mode 100644
index 0000000000..291d9d0089
--- /dev/null
+++ b/backend/plugin/advisor/pgantlr/test/statement_dml_dry_run.yaml
@@ -0,0 +1,4 @@
+- statement: INSERT INTO tech_book values(1, 'a')
+ changeType: 1
+- statement: DELETE FROM tech_book
+ changeType: 1
diff --git a/backend/plugin/advisor/pgantlr/utils.go b/backend/plugin/advisor/pgantlr/utils.go
index 1ad3db8da3..1bc5365a49 100644
--- a/backend/plugin/advisor/pgantlr/utils.go
+++ b/backend/plugin/advisor/pgantlr/utils.go
@@ -1,6 +1,7 @@
package pgantlr
import (
+ "regexp"
"strconv"
"strings"
@@ -118,3 +119,23 @@ func extractStatementText(statementsText string, startLine, endLine int) string
return strings.TrimSpace(strings.Join(stmtLines, " "))
}
+
+// getTemplateRegexp generates a regex pattern by replacing tokens in the template with actual values.
+// Used by naming convention advisors to dynamically build patterns based on metadata.
+func getTemplateRegexp(template string, templateList []string, tokens map[string]string) (*regexp.Regexp, error) {
+ for _, key := range templateList {
+ if token, ok := tokens[key]; ok {
+ template = strings.ReplaceAll(template, key, token)
+ }
+ }
+
+ return regexp.Compile(template)
+}
+
+// normalizeSchemaName normalizes empty schema names to "public" (PostgreSQL default schema).
+func normalizeSchemaName(schemaName string) string {
+ if schemaName == "" {
+ return "public"
+ }
+ return schemaName
+}