Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
chore: migrate mssql prior backup DML grouping to omni (#20228)
rebelicedd13db647c1a
diff --git a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.goindex 98219c21f6..4a63ec949d 100644--- a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go@@ -3,11 +3,8 @@ package mssqlimport ("context""fmt"- "log/slog"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/mssql/ast"- parser "github.com/bytebase/parser/tsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -171,191 +168,118 @@ type TableReference struct {}type statementInfo struct {- offset int- statement string- tree antlr.ParserRuleContext- table *TableReference+ table *TableReference}func prepareTransformation(databaseName string, parsedStatements []base.ParsedStatement) []statementInfo {- extractor := &dmlExtractor{- databaseName: databaseName,- }-+ var dmls []statementInfofor _, stmt := range parsedStatements {if stmt.AST == nil {continue}- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {+ node, ok := tsqlparser.GetOmniNode(stmt.AST)+ if !ok || node == nil {continue}- antlr.ParseTreeWalkerDefault.Walk(extractor, antlrAST.Tree)- }-- return extractor.dmls-}--type dmlExtractor struct {- *parser.BaseTSqlParserListener-- databaseName string- dmls []statementInfo- offset int-}--func IsTopLevel(ctx antlr.Tree) bool {- if ctx == nil {- return true- }- switch ctx := ctx.(type) {- case *parser.Dml_clauseContext,- *parser.Sql_clausesContext,- *parser.Batch_without_goContext:- return IsTopLevel(ctx.GetParent())- case *parser.Tsql_fileContext:- return true- default:- return false- }-}--func (e *dmlExtractor) ExitBatch(ctx *parser.Batch_without_goContext) {- if len(ctx.AllSql_clauses()) == 0 {- e.offset++- }-}--func (e *dmlExtractor) ExitSql_clauses(ctx *parser.Sql_clausesContext) {- if IsTopLevel(ctx.GetParent()) {- e.offset++- }-}-func (e *dmlExtractor) EnterUpdate_statement(ctx *parser.Update_statementContext) {- if IsTopLevel(ctx.GetParent()) && ctx.Ddl_object() != nil {- extractor := &tableExtractor{- databaseName: e.databaseName,+ var (+ table *TableReference+ statementType StatementType+ )+ switch n := node.(type) {+ case *ast.UpdateStmt:+ table = resolveDMLTargetTable(n.Relation, n.FromClause, databaseName)+ statementType = StatementTypeUpdate+ case *ast.DeleteStmt:+ table = resolveDMLTargetTable(n.Relation, n.FromClause, databaseName)+ statementType = StatementTypeDelete+ default:+ continue}- antlr.ParseTreeWalkerDefault.Walk(extractor, ctx.Ddl_object())-- table := extractor.table- if extractor.table != nil && ctx.Table_sources() != nil && table.Database == e.databaseName && table.Schema == defaultSchema {- table = extractPhysicalTable(ctx.Table_sources(), extractor.table)+ if table == nil || table.Table == "" {+ continue}- table.StatementType = StatementTypeUpdate- e.dmls = append(e.dmls, statementInfo{- offset: e.offset,- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),- tree: ctx,- table: table,+ table.StatementType = statementType+ dmls = append(dmls, statementInfo{+ table: table,})}-}-func (e *dmlExtractor) EnterDelete_statement(ctx *parser.Delete_statementContext) {- if IsTopLevel(ctx.GetParent()) {- extractor := &tableExtractor{- databaseName: e.databaseName,- }- antlr.ParseTreeWalkerDefault.Walk(extractor, ctx.Delete_statement_from())-- table := extractor.table- if extractor.table != nil && ctx.From_table_sources() != nil && table.Database == e.databaseName && table.Schema == defaultSchema {- table = extractPhysicalTable(ctx.From_table_sources().Table_sources(), extractor.table)- }- table.StatementType = StatementTypeDelete- e.dmls = append(e.dmls, statementInfo{- offset: e.offset,- statement: ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx),- tree: ctx,- table: table,- })- }+ return dmls}-func extractPhysicalTable(ctx antlr.Tree, table *TableReference) *TableReference {- if ctx == nil || table == nil {+func resolveDMLTargetTable(relation ast.TableExpr, fromClause *ast.List, databaseName string) *TableReference {+ table := tableReferenceFromTableExpr(relation, databaseName, defaultSchema)+ if table == nil {return table}-- extractor := &physicalTableExtractor{- table: table,- }- antlr.ParseTreeWalkerDefault.Walk(extractor, ctx)- if extractor.result != nil {- return extractor.result- }- return table-}--type physicalTableExtractor struct {- *parser.BaseTSqlParserListener-- table *TableReference- result *TableReference-}--func (e *physicalTableExtractor) EnterTable_source_item(ctx *parser.Table_source_itemContext) {- if ctx.As_table_alias() != nil && ctx.Full_table_name() != nil {- alias := unquote(ctx.As_table_alias().Table_alias().GetText())- if alias == e.table.Table {- databaseName, schemaName, tableName := extractFullTableName(ctx.Full_table_name(), e.table.Database, e.table.Schema)- e.result = &TableReference{- Database: databaseName,- Schema: schemaName,- Table: tableName,- Alias: alias,- StatementType: e.table.StatementType,- }+ if fromClause != nil && table.Database == databaseName && table.Schema == defaultSchema {+ if physical := findPhysicalTableForAlias(fromClause, table); physical != nil {+ return physical}}+ return table}-func unquote(name string) string {- if len(name) < 2 {- return name+func tableReferenceFromTableExpr(expr ast.TableExpr, defaultDatabase, defaultSchema string) *TableReference {+ ref, ok := expr.(*ast.TableRef)+ if !ok {+ return nil}- if name[0] == '[' && name[len(name)-1] == ']' {- return name[1 : len(name)-1]+ schemaName := defaultSchema+ if ref.Schema != "" {+ schemaName = ref.Schema}-- if len(name) > 3 && name[0] == 'N' && name[1] == '\'' && name[len(name)-1] == '\'' {- return name[2 : len(name)-1]+ databaseName := defaultDatabase+ if ref.Database != "" {+ databaseName = ref.Database}- return name-}--type tableExtractor struct {- *parser.BaseTSqlParserListener-- databaseName string- table *TableReference-}--func (e *tableExtractor) EnterFull_table_name(ctx *parser.Full_table_nameContext) {- databaseName, schemaName, tableName := extractFullTableName(ctx, e.databaseName, defaultSchema)- table := TableReference{+ return &TableReference{Database: databaseName,Schema: schemaName,- Table: tableName,+ Table: ref.Object,+ Alias: ref.Alias,}- e.table = &table}-func extractFullTableName(ctx parser.IFull_table_nameContext, defaultDatabase string, defaultSchema string) (string, string, string) {- name, err := tsqlparser.NormalizeFullTableName(ctx)- if err != nil {- slog.Debug("Failed to normalize full table name", "error", err)- return defaultDatabase, defaultSchema, ""+func findPhysicalTableForAlias(list *ast.List, table *TableReference) *TableReference {+ if list == nil || table == nil {+ return nil}- schemaName := defaultSchema- if name.Schema != "" {- schemaName = name.Schema+ for _, item := range list.Items {+ if result := findPhysicalTableForAliasInNode(item, table); result != nil {+ return result+ }}- databaseName := defaultDatabase- if name.Database != "" {- databaseName = name.Database+ return nil+}++func findPhysicalTableForAliasInNode(node ast.Node, table *TableReference) *TableReference {+ switch n := node.(type) {+ case *ast.TableRef:+ if n.Alias != "" && n.Alias == table.Table {+ ref := tableReferenceFromTableExpr(n, table.Database, table.Schema)+ if ref == nil {+ return nil+ }+ ref.Alias = n.Alias+ return ref+ }+ case *ast.AliasedTableRef:+ if ref, ok := n.Table.(*ast.TableRef); ok && n.Alias == table.Table {+ result := tableReferenceFromTableExpr(ref, table.Database, table.Schema)+ if result == nil {+ return nil+ }+ result.Alias = n.Alias+ return result+ }+ case *ast.JoinClause:+ if result := findPhysicalTableForAliasInNode(n.Left, table); result != nil {+ return result+ }+ return findPhysicalTableForAliasInNode(n.Right, table)+ default:}- return databaseName, schemaName, name.Table+ return nil}diff --git a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check_test.go b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check_test.gonew file mode 100644index 0000000000..0ebf15bcbe--- /dev/null+++ b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check_test.go@@ -0,0 +1,47 @@+package mssql++import (+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+ tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql"+)++func TestPrepareTransformationUsesOmniAST(t *testing.T) {+ sql := `UPDATE p SET c1 = 1 FROM dbo.pokes AS p WHERE p.c1 = 1;+DELETE p FROM dbo.pokes AS p WHERE p.c1 = 1;`+ omniStmts, err := tsqlparser.ParseTSQLOmni(sql)+ require.NoError(t, err)++ var parsedStatements []base.ParsedStatement+ for _, stmt := range omniStmts {+ start := &storepb.Position{+ Line: int32(stmt.Start.Line),+ Column: int32(stmt.Start.Column),+ }+ parsedStatements = append(parsedStatements, base.ParsedStatement{+ Statement: base.Statement{+ Text: stmt.Text,+ Start: start,+ },+ AST: &tsqlparser.OmniAST{+ Node: stmt.AST,+ StartPosition: start,+ },+ })+ }++ statementInfoList := prepareTransformation("master", parsedStatements)+ require.Len(t, statementInfoList, 2)+ require.Equal(t, StatementTypeUpdate, statementInfoList[0].table.StatementType)+ require.Equal(t, StatementTypeDelete, statementInfoList[1].table.StatementType)+ for _, info := range statementInfoList {+ require.Equal(t, "master", info.table.Database)+ require.Equal(t, "dbo", info.table.Schema)+ require.Equal(t, "pokes", info.table.Table)+ require.Equal(t, "p", info.table.Alias)+ }+}