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: bump omni to 8031142a and adapt to its changes (#21625)
rebelice6f636ca6060d
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex a0bcc99855..5acbcf4179 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -1946,7 +1946,7 @@ type writeTargetResource struct {// resolveWriteTargets returns the tables a DML/DDL statement writes/changes, using// the same extractor plan-check trusts. Returns (nil, nil) when the engine has no-// extractor, the statement can't be parsed, or no targets are found — callers must+// extractor, a statement can't be parsed or read, or no targets are found — callers must// then fall back to the database-level check (never fail open). See SUP-222.//// Some engines' extractors report auxiliary tables referenced by the change (e.g.@@ -1995,10 +1995,19 @@ func (s *SQLService) resolveWriteTargets(changeSummary, err := parserbase.ExtractChangedResources(engine, database.DatabaseName, targetSchema, dbMeta, asts, statement,)- if err != nil || changeSummary == nil || changeSummary.ChangedResources == nil {- //nolint:nilerr // unsupported engine / no result → fall back to database-level check+ if err != nil {+ //nolint:nilerr // unsupported engine → fall back to database-level checkreturn nil, nil}+ return writeTargetsFromChangeSummary(changeSummary), nil+}++// writeTargetsFromChangeSummary returns the write targets changeSummary records. It returns+// nil when there are none, or when the extractor skipped a statement, which may write any table.+func writeTargetsFromChangeSummary(changeSummary *parserbase.ChangeSummary) []writeTargetResource {+ if changeSummary == nil || changeSummary.ChangedResources == nil || changeSummary.SkippedStatements > 0 {+ return nil+ }var targets []writeTargetResourcedatabasesWithTableTarget := map[string]bool{}@@ -2033,7 +2042,7 @@ func (s *SQLService) resolveWriteTargets(}targets = append(targets, writeTargetResource{database: db})}- return targets, nil+ return targets}// unresolvedSchemaSentinel is an impossible schema name (it contains NUL, which no realdiff --git a/backend/api/v1/sql_service_schema_resolution_test.go b/backend/api/v1/sql_service_schema_resolution_test.goindex 767204529c..6dc0e877d7 100644--- a/backend/api/v1/sql_service_schema_resolution_test.go+++ b/backend/api/v1/sql_service_schema_resolution_test.go@@ -7,6 +7,7 @@ import ("github.com/stretchr/testify/require"storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/store/model")@@ -76,3 +77,20 @@ func TestUnresolvedSchemaSentinelIsImpossible(t *testing.T) {t.Parallel()require.Contains(t, unresolvedSchemaSentinel, "\x00")}++func TestWriteTargetsFromChangeSummaryRefusesSkippedStatements(t *testing.T) {+ t.Parallel()+ extract := func(statement string) *parserbase.ChangeSummary {+ stmts, err := parserbase.ParseStatements(storepb.Engine_MARIADB, statement)+ require.NoError(t, err)+ changeSummary, err := parserbase.ExtractChangedResources(storepb.Engine_MARIADB, "db", "", nil /* dbMetadata */, parserbase.ExtractASTs(stmts), statement)+ require.NoError(t, err)+ return changeSummary+ }++ require.Equal(t,+ []writeTargetResource{{database: "db", table: "t"}},+ writeTargetsFromChangeSummary(extract("CREATE TABLE t (a INT);")),+ )+ require.Nil(t, writeTargetsFromChangeSummary(extract("CREATE OR REPLACE TABLE other_db.t (a INT);")))+}diff --git a/backend/plugin/advisor/mysql/mysql_rules_test.go b/backend/plugin/advisor/mysql/mysql_rules_test.goindex a7428fd6b3..f557c5aca4 100644--- a/backend/plugin/advisor/mysql/mysql_rules_test.go+++ b/backend/plugin/advisor/mysql/mysql_rules_test.go@@ -450,6 +450,44 @@ func TestMariaDBPriorBackupCheckAdvisor(t *testing.T) {require.Contains(t, adviceList[0].Content, "mixed DDL and DML")}+func TestMariaDBPriorBackupCheckAdvisorFlagsMariaDBOnlyStatements(t *testing.T) {+ sm := sheet.NewManager()++ adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, "UPDATE test SET c1 = 1 WHERE b1 = 1;\nDELETE FROM test WHERE b1 = 2 RETURNING b1;", nil, advisor.Context{+ DBType: storepb.Engine_MARIADB,+ DBSchema: advisor.MockMySQLDatabase,+ EnablePriorBackup: true,+ InstanceID: "instance",+ ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {+ return []string{"bbdataarchive"}, nil+ },+ })++ require.NoError(t, err)+ require.Len(t, adviceList, 1)+ require.Equal(t, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK.String(), adviceList[0].Title)+ require.Equal(t, "Prior backup cannot handle MariaDB-specific syntax", adviceList[0].Content)+}++func TestMariaDBSQLReviewReviewsAroundMariaDBOnlyStatements(t *testing.T) {+ sm := sheet.NewManager()+ finalMetadata := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MARIADB, true)+ statement := "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);\nALTER TABLE u DROP COLUMN IF EXISTS b;"++ adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, statement, []*storepb.SQLReviewRule{+ {Type: storepb.SQLReviewRule_TABLE_REQUIRE_PK, Level: storepb.SQLReviewRule_ERROR, Engine: storepb.Engine_MARIADB},+ }, advisor.Context{+ DBType: storepb.Engine_MARIADB,+ DBSchema: advisor.MockMySQLDatabase,+ FinalMetadata: finalMetadata,+ })++ require.NoError(t, err)+ require.Len(t, adviceList, 1)+ require.Equal(t, code.TableNoPK.Int32(), adviceList[0].Code)+ require.Contains(t, adviceList[0].Content, "`t`")+}+func TestMySQLBuiltinWalkThroughCheckTableExists(t *testing.T) {sm := sheet.NewManager()finalMetadata := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{diff --git a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.goindex 5ebe8dc306..531d06a76f 100644--- a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -53,6 +54,17 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advif stmt.AST == nil {continue}+ // The backup transform parses every statement with omni's MySQL parser, which rejects this one.+ if _, ok := stmt.AST.(*mariadb.OmniAST); ok {+ adviceList = append(adviceList, &storepb.Advice{+ Status: level,+ Title: title,+ Content: "Prior backup cannot handle MariaDB-specific syntax",+ Code: code.BuiltinPriorBackupCheck.Int32(),+ StartPosition: base.ConvertANTLRLineToPosition(stmt.BaseLine()),+ })+ continue+ }node, ok := mysqlparser.GetOmniNode(stmt.AST)if !ok {continuediff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.goindex 9e7a35a029..41c06e574d 100644--- a/backend/plugin/parser/base/interface.go+++ b/backend/plugin/parser/base/interface.go@@ -401,6 +401,9 @@ type ChangeSummary struct {DMLCount int// InsertCount counts the rows of INSERT ... VALUES statements.InsertCount int+ // SkippedStatements counts the statements the extractor could not read, whose+ // changes ChangedResources misses.+ SkippedStatements int}// searchPathPrefix starts the statement WithSearchPath puts before a DML statement.diff --git a/backend/plugin/parser/mariadb/diagnose_e2e_test.go b/backend/plugin/parser/mariadb/diagnose_e2e_test.goindex b65acf4894..fb2692cf58 100644--- a/backend/plugin/parser/mariadb/diagnose_e2e_test.go+++ b/backend/plugin/parser/mariadb/diagnose_e2e_test.go@@ -1,4 +1,4 @@-package mariadb+package mariadb_testimport ("context"@@ -6,7 +6,9 @@ import ("github.com/stretchr/testify/require"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/parser/mariadb""github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -28,6 +30,10 @@ var mariaDBOnlySQL = []string{// application-time periods (omni #324-#328)"CREATE TABLE t (s DATE, e DATE, PERIOD FOR app_time(s, e))","UPDATE t FOR PORTION OF app_time FROM '2020-01-01' TO '2021-01-01' SET id = 1",+ // omni/mysql takes only the engine's own OR REPLACE and DROP forms (omni #487, #488)+ "CREATE OR REPLACE TABLE t (id INT)",+ "CREATE OR REPLACE PROCEDURE p() BEGIN SELECT 1; END",+ "ALTER TABLE t DROP COLUMN IF EXISTS id",}// TestMariaDBDiagnoseKeystone is the carve-out keystone. Before the re-point,@@ -44,9 +50,13 @@ func TestMariaDBDiagnoseKeystone(t *testing.T) {require.NotEmpty(t, mysqlDiags, "omni/mysql should still (wrongly) flag %q — the false error being fixed", stmt)// GREEN: the omni/mariadb backend accepts it (no diagnostics).- mariadbDiags, err := Diagnose(ctx, base.DiagnoseContext{}, stmt)+ mariadbDiags, err := mariadb.Diagnose(ctx, base.DiagnoseContext{}, stmt)require.NoError(t, err)require.Empty(t, mariadbDiags, "omni/mariadb should accept %q with no diagnostic", stmt)++ // Checks parse it too, through the MariaDB fallback of ParseStatements.+ _, err = base.ParseStatements(storepb.Engine_MARIADB, stmt)+ require.NoError(t, err, stmt)}// Inverse fidelity case: FOR UPDATE ... OF is valid MySQL but MariaDB removed@@ -56,13 +66,13 @@ func TestMariaDBDiagnoseKeystone(t *testing.T) {mysqlFU, err := mysql.Diagnose(ctx, base.DiagnoseContext{}, forUpdateOf)require.NoError(t, err)require.Empty(t, mysqlFU, "omni/mysql accepts FOR UPDATE OF (valid MySQL)")- mariadbFU, err := Diagnose(ctx, base.DiagnoseContext{}, forUpdateOf)+ mariadbFU, err := mariadb.Diagnose(ctx, base.DiagnoseContext{}, forUpdateOf)require.NoError(t, err)require.NotEmpty(t, mariadbFU, "omni/mariadb must flag FOR UPDATE OF (removed in MariaDB 11.4)")// Diagnose must still report a genuine syntax error — proving it actually// validates, not just "returns empty".- badDiags, err := Diagnose(ctx, base.DiagnoseContext{}, "SELECT FROM WHERE )(")+ badDiags, err := mariadb.Diagnose(ctx, base.DiagnoseContext{}, "SELECT FROM WHERE )(")require.NoError(t, err)require.NotEmpty(t, badDiags, "a real syntax error must still be reported")}diff --git a/backend/plugin/parser/mariadb/omni.go b/backend/plugin/parser/mariadb/omni.goindex d076a3d567..9f04ea86b4 100644--- a/backend/plugin/parser/mariadb/omni.go+++ b/backend/plugin/parser/mariadb/omni.go@@ -9,6 +9,20 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store")+// OmniAST wraps an omni MariaDB AST node and implements the base.AST interface.+type OmniAST struct {+ Node ast.Node+ // Text is the original SQL text of this statement.+ Text string+ // StartPosition is the 1-based position where this statement starts.+ StartPosition *storepb.Position+}++// ASTStartPosition implements base.AST.+func (a *OmniAST) ASTStartPosition() *storepb.Position {+ return a.StartPosition+}+// ParseMariaDB parses SQL using omni's MariaDB parser and returns an ast.List.func ParseMariaDB(sql string) (*ast.List, error) {return mariadbparser.Parse(sql)diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.goindex e6f261b100..da81d0feb2 100644--- a/backend/plugin/parser/mysql/mysql.go+++ b/backend/plugin/parser/mysql/mysql.go@@ -4,24 +4,38 @@ import ("errors""fmt"+ mariadbomniparser "github.com/bytebase/omni/mariadb/parser"mysqlomniparser "github.com/bytebase/omni/mysql/parser"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/parser/mariadb")func init() {base.RegisterParseStatementsFunc(storepb.Engine_MYSQL, parseMySQLStatements)- base.RegisterParseStatementsFunc(storepb.Engine_MARIADB, parseMySQLStatements)+ base.RegisterParseStatementsFunc(storepb.Engine_MARIADB, parseMariaDBStatements)base.RegisterParseStatementsFunc(storepb.Engine_OCEANBASE, parseMySQLStatements)base.RegisterGetStatementTypes(storepb.Engine_MYSQL, GetStatementTypes)base.RegisterGetStatementTypes(storepb.Engine_MARIADB, GetStatementTypes)base.RegisterGetStatementTypes(storepb.Engine_OCEANBASE, GetStatementTypes)}-// parseMySQLStatements is the ParseStatementsFunc for MySQL, MariaDB, and OceanBase.+// parseMySQLStatements is the ParseStatementsFunc for MySQL and OceanBase.// Returns []ParsedStatement with both text and AST populated.func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {+ return parseStatements(statement, false /* mariaDBFallback */)+}++// parseMariaDBStatements is the ParseStatementsFunc for MariaDB. The MySQL code+// paths read omni's MySQL AST, so each statement goes to omni's MySQL parser+// first. A statement only omni's MariaDB parser accepts, such as CREATE OR+// REPLACE TABLE, gets a *mariadb.OmniAST instead, which those paths do not read.+func parseMariaDBStatements(statement string) ([]base.ParsedStatement, error) {+ return parseStatements(statement, true /* mariaDBFallback */)+}++func parseStatements(statement string, mariaDBFallback bool) ([]base.ParsedStatement, error) {// Split once to get Statement with text and positionsstmts, err := SplitSQL(statement)if err != nil {@@ -36,7 +50,27 @@ func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {list, omniErr := ParseMySQL(stmt.Text)if omniErr != nil {- return nil, convertOmniError(omniErr, stmt)+ if !mariaDBFallback {+ return nil, convertOmniError(omniErr, stmt)+ }+ mariaDBList, mariaDBErr := mariadb.ParseMariaDB(stmt.Text)+ if mariaDBErr != nil {+ return nil, convertOmniError(mariaDBErr, stmt)+ }+ if mariaDBList == nil {+ continue+ }+ for _, node := range mariaDBList.Items {+ result = append(result, base.ParsedStatement{+ Statement: stmt,+ AST: &mariadb.OmniAST{+ Node: node,+ Text: stmt.Text,+ StartPosition: stmt.Start,+ },+ })+ }+ continue}if list == nil || len(list.Items) == 0 {@@ -58,28 +92,39 @@ func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {return result, nil}-// convertOmniError converts an omni parser error to a base.SyntaxError with proper line:column position.+// convertOmniError converts an omni MySQL or MariaDB parser error to a base.SyntaxError with proper line:column position.func convertOmniError(err error, stmt base.Statement) error {- var parseErr *mysqlomniparser.ParseError- if !errors.As(err, &parseErr) {+ var message, relatedText string+ var position int+ var mysqlErr *mysqlomniparser.ParseError+ var mariaDBErr *mariadbomniparser.ParseError+ switch {+ case errors.As(err, &mysqlErr):+ message, position, relatedText = mysqlErr.Message, mysqlErr.Position, mysqlErr.RelatedText+ case errors.As(err, &mariaDBErr):+ message, position, relatedText = mariaDBErr.Message, mariaDBErr.Position, mariaDBErr.RelatedText+ default:return err}- pos := ByteOffsetToRunePosition(stmt.Text, parseErr.Position)+ pos := ByteOffsetToRunePosition(stmt.Text, position)- // Adjust line by the statement's base line (stmt.Start.Line is 1-based).+ // Offset by the statement's 1-based start; its column applies only to the statement's first line.if stmt.Start != nil {+ if pos.Line == 1 {+ pos.Column += stmt.Start.Column - 1+ }pos.Line += stmt.Start.Line - 1}- msg := fmt.Sprintf("Syntax error at line %d:%d: %s", pos.Line, pos.Column, parseErr.Message)- if parseErr.RelatedText != "" {- msg += "\nrelated text: " + parseErr.RelatedText+ msg := fmt.Sprintf("Syntax error at line %d:%d: %s", pos.Line, pos.Column, message)+ if relatedText != "" {+ msg += "\nrelated text: " + relatedText}return &base.SyntaxError{Position: pos,Message: msg,- RawMessage: parseErr.Message,+ RawMessage: message,}}diff --git a/backend/plugin/parser/mysql/mysql_test.go b/backend/plugin/parser/mysql/mysql_test.goindex 94a8522d11..334bcf779a 100644--- a/backend/plugin/parser/mysql/mysql_test.go+++ b/backend/plugin/parser/mysql/mysql_test.go@@ -7,6 +7,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/parser/mariadb")func TestParseMySQLStatements(t *testing.T) {@@ -28,3 +29,57 @@ func TestParseMySQLStatements(t *testing.T) {require.False(t, statements[1].Empty)require.NotNil(t, statements[1].AST)}++func TestParseMariaDBStatementsFallsBackToMariaDBParser(t *testing.T) {+ statement := "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);\nALTER TABLE t DROP COLUMN IF EXISTS b;"++ statements, err := base.ParseStatements(storepb.Engine_MARIADB, statement)+ require.NoError(t, err)++ require.Len(t, statements, 3)+ require.IsType(t, &OmniAST{}, statements[0].AST)+ for _, stmt := range statements[1:] {+ mariaDBAST, ok := stmt.AST.(*mariadb.OmniAST)+ require.True(t, ok, stmt.Text)+ require.NotNil(t, mariaDBAST.Node)+ require.Equal(t, stmt.Text, mariaDBAST.Text)+ require.Equal(t, stmt.Start, mariaDBAST.StartPosition)+ }+}++func TestParseMariaDBStatementsReportsMariaDBSyntaxError(t *testing.T) {+ // omni's MySQL parser would stop at TABLE, column 19.+ _, err := base.ParseStatements(storepb.Engine_MARIADB, "SELECT 1;\nCREATE OR REPLACE TABLE t (a INT DEFAULT);")++ var syntaxErr *base.SyntaxError+ require.ErrorAs(t, err, &syntaxErr)+ require.Equal(t, &storepb.Position{Line: 2, Column: 41}, syntaxErr.Position)+}++func TestParseStatementsSyntaxErrorColumnOnSharedLine(t *testing.T) {+ for _, tc := range []struct {+ engine storepb.Engine+ statement string+ want *storepb.Position+ }{+ // The error is at the ')' after DEFAULT, column 51 of the line.+ {storepb.Engine_MARIADB, "SELECT 1; CREATE OR REPLACE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 1, Column: 51}},+ {storepb.Engine_MYSQL, "SELECT 1; CREATE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 1, Column: 40}},+ {storepb.Engine_MYSQL, "SELECT 1;\nSELECT 2; CREATE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 2, Column: 40}},+ } {+ _, err := base.ParseStatements(tc.engine, tc.statement)++ var syntaxErr *base.SyntaxError+ require.ErrorAs(t, err, &syntaxErr, tc.statement)+ require.Equal(t, tc.want, syntaxErr.Position, tc.statement)+ }+}++func TestParseMySQLStatementsRejectsMariaDBSyntax(t *testing.T) {+ for _, engine := range []storepb.Engine{storepb.Engine_MYSQL, storepb.Engine_OCEANBASE} {+ _, err := base.ParseStatements(engine, "CREATE OR REPLACE TABLE t (a INT);")++ var syntaxErr *base.SyntaxError+ require.ErrorAs(t, err, &syntaxErr, engine.String())+ }+}diff --git a/backend/plugin/parser/mysql/resource_change.go b/backend/plugin/parser/mysql/resource_change.goindex 9c1ae0df7b..f2c1fe782d 100644--- a/backend/plugin/parser/mysql/resource_change.go+++ b/backend/plugin/parser/mysql/resource_change.go@@ -8,6 +8,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/parser/mariadb""github.com/bytebase/bytebase/backend/store/model")@@ -22,7 +23,7 @@ func init() {func extractChangedResources(currentDatabase string, _ string, dbMetadata *model.DatabaseMetadata, asts []base.AST, _ string) (*base.ChangeSummary, error) {changedResources := model.NewChangedResources(dbMetadata)- var dmlCount, insertCount int+ var dmlCount, insertCount, skippedStatements intvar dmlStatements []string// addObjectDatabase records a database-only write target for a non-table object DDL@@ -36,6 +37,10 @@ func extractChangedResources(currentDatabase string, _ string, dbMetadata *model}for _, unifiedAST := range asts {+ if _, ok := unifiedAST.(*mariadb.OmniAST); ok {+ skippedStatements+++ continue+ }omniAST, ok := unifiedAST.(*OmniAST)if !ok {return nil, errors.New("expected OmniAST for MySQL")@@ -158,10 +163,11 @@ func extractChangedResources(currentDatabase string, _ string, dbMetadata *model}return &base.ChangeSummary{- ChangedResources: changedResources,- DMLStatements: dmlStatements,- DMLCount: dmlCount,- InsertCount: insertCount,+ ChangedResources: changedResources,+ DMLStatements: dmlStatements,+ DMLCount: dmlCount,+ InsertCount: insertCount,+ SkippedStatements: skippedStatements,}, nil}diff --git a/backend/plugin/parser/mysql/resource_change_test.go b/backend/plugin/parser/mysql/resource_change_test.goindex a083913bb2..46efb6f8bc 100644--- a/backend/plugin/parser/mysql/resource_change_test.go+++ b/backend/plugin/parser/mysql/resource_change_test.go@@ -105,3 +105,18 @@ func TestExtractChangedResourcesObjectDDLDatabaseOnly(t *testing.T) {require.NoError(t, err)require.Empty(t, got.ChangedResources.GetDatabaseOnlyTargets())}++func TestExtractChangedResourcesCountsMariaDBOnlyStatements(t *testing.T) {+ const statement = "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE other_db.u (a INT);"++ want := model.NewChangedResources(nil /* dbMetadata */)+ want.AddTable("db", "", &storepb.ChangedResourceTable{Name: "t"}, false)++ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, statement)+ require.NoError(t, err)+ asts := base.ExtractASTs(stmts)+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)+ require.NoError(t, err)+ require.Equal(t, want, got.ChangedResources)+ require.Equal(t, 1, got.SkippedStatements)+}diff --git a/backend/plugin/parser/mysql/statement_type.go b/backend/plugin/parser/mysql/statement_type.goindex 40fd8ebb3d..c925af5c4e 100644--- a/backend/plugin/parser/mysql/statement_type.go+++ b/backend/plugin/parser/mysql/statement_type.go@@ -8,11 +8,16 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/parser/mariadb")func GetStatementTypes(asts []base.AST) ([]storepb.StatementType, error) {sqlTypeSet := make(map[storepb.StatementType]bool)for _, a := range asts {+ if _, ok := a.(*mariadb.OmniAST); ok {+ sqlTypeSet[storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED] = true+ continue+ }node, ok := GetOmniNode(a)if !ok {return nil, errors.New("expected OmniAST for MySQL")diff --git a/backend/plugin/parser/mysql/statement_type_test.go b/backend/plugin/parser/mysql/statement_type_test.goindex 094221fe89..07fd1419b3 100644--- a/backend/plugin/parser/mysql/statement_type_test.go+++ b/backend/plugin/parser/mysql/statement_type_test.go@@ -77,3 +77,12 @@ func TestGetStatementType(t *testing.T) {yamltest.Record(t, filepath, tests)}}++func TestGetStatementTypesLeavesMariaDBOnlyStatementsUnspecified(t *testing.T) {+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);")+ require.NoError(t, err)++ got, err := base.GetStatementTypes(storepb.Engine_MARIADB, base.ExtractASTs(stmts))+ require.NoError(t, err)+ require.ElementsMatch(t, []storepb.StatementType{storepb.StatementType_CREATE_TABLE, storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}, got)+}diff --git a/backend/plugin/parser/plsql/limit.go b/backend/plugin/parser/plsql/limit.goindex 01061ec6c0..e67cc3429a 100644--- a/backend/plugin/parser/plsql/limit.go+++ b/backend/plugin/parser/plsql/limit.go@@ -72,10 +72,11 @@ func addLimitFor11g(statement string, limitCount int) string {return fmt.Sprintf("SELECT * FROM (%s) WHERE ROWNUM <= %d", base.TrimStatement(statement), limitCount)}-// isSelectOrWithStatement checks if the statement is a SELECT or WITH statement+// isSelectOrWithStatement checks if the statement is a query: SELECT, WITH, or+// a parenthesized query.func isSelectOrWithStatement(statement string) bool {trimmedStatement := strings.ToLower(strings.TrimLeftFunc(statement, unicode.IsSpace))- return strings.HasPrefix(trimmedStatement, "select") || strings.HasPrefix(trimmedStatement, "with")+ return strings.HasPrefix(trimmedStatement, "select") || strings.HasPrefix(trimmedStatement, "with") || strings.HasPrefix(trimmedStatement, "(")}// addLimitFor12cAndLater adds a FETCH NEXT clause for Oracle 12c and later versions.@@ -127,12 +128,14 @@ func addFetchNextClause(statement string, limitCount int) (string, error) {}func rewriteOracleSelectFetch(sql string, selectStmt *oracleast.SelectStmt, limitCount int) (string, error) {- target := rightmostOracleSetSelect(selectStmt)- if target.FetchFirst != nil {- return rewriteOracleFetchClause(sql, target.FetchFirst, limitCount)- }- if target.ForUpdate != nil && target.ForUpdate.Loc.Start > 0 && target.ForUpdate.Loc.Start <= len(sql) {- return sql[:target.ForUpdate.Loc.Start] + fmt.Sprintf("FETCH NEXT %d ROWS ONLY ", limitCount) + sql[target.ForUpdate.Loc.Start:], nil+ target, parenthesized := rightmostOracleSetSelect(sql, selectStmt)+ if !parenthesized {+ if target.FetchFirst != nil {+ return rewriteOracleFetchClause(sql, target.FetchFirst, limitCount)+ }+ if target.ForUpdate != nil && target.ForUpdate.Loc.Start > 0 && target.ForUpdate.Loc.Start <= len(sql) {+ return sql[:target.ForUpdate.Loc.Start] + fmt.Sprintf("FETCH NEXT %d ROWS ONLY ", limitCount) + sql[target.ForUpdate.Loc.Start:], nil+ }}loc := oracleast.NodeLoc(target)@@ -142,11 +145,45 @@ func rewriteOracleSelectFetch(sql string, selectStmt *oracleast.SelectStmt, limireturn sql[:loc.End] + fmt.Sprintf(" FETCH NEXT %d ROWS ONLY", limitCount) + sql[loc.End:], nil}-func rightmostOracleSetSelect(selectStmt *oracleast.SelectStmt) *oracleast.SelectStmt {- if selectStmt.Op != oracleast.SETOP_NONE && selectStmt.Rarg != nil {- return rightmostOracleSetSelect(selectStmt.Rarg)+// rightmostOracleSetSelect returns the operand that omni attaches the ORDER+// BY, row limit, and FOR UPDATE ending a set operation to: its last operand.+// omni chains operands through Rarg, and only the text tells a parenthesized+// operand from the rest of the chain. The walk stops at a parenthesized one+// and reports it, as the clauses inside it limit that operand alone.+func rightmostOracleSetSelect(sql string, selectStmt *oracleast.SelectStmt) (*oracleast.SelectStmt, bool) {+ for selectStmt.Op != oracleast.SETOP_NONE && selectStmt.Rarg != nil {+ selectStmt = selectStmt.Rarg+ if isParenthesizedOracleQuery(sql, oracleast.NodeLoc(selectStmt)) {+ return selectStmt, true+ }+ }+ return selectStmt, false+}++// isParenthesizedOracleQuery reports whether one pair of parentheses encloses+// all of sql[loc.Start:loc.End].+func isParenthesizedOracleQuery(sql string, loc oracleast.Loc) bool {+ if loc.Start < 0 || loc.End > len(sql) || loc.Start >= loc.End || sql[loc.Start] != '(' {+ return false+ }+ lexer := oracleparser.NewLexerRange(sql, loc.Start, loc.End)+ depth := 0+ for {+ tok := lexer.NextToken()+ if tok.End <= tok.Loc {+ return false+ }+ switch tok.Type {+ case '(':+ depth+++ case ')':+ depth--+ if depth == 0 {+ return tok.End == loc.End+ }+ default:+ }}- return selectStmt}func rewriteOracleFetchClause(sql string, fetch *oracleast.FetchFirstClause, limitCount int) (string, error) {diff --git a/backend/plugin/parser/plsql/limit_test.go b/backend/plugin/parser/plsql/limit_test.goindex 7d327dec36..5688485ca0 100644--- a/backend/plugin/parser/plsql/limit_test.go+++ b/backend/plugin/parser/plsql/limit_test.go@@ -163,6 +163,86 @@ func TestAddLimitFor12cAndLaterRegressionClauseOrder(t *testing.T) {}}+func TestAddLimitFor12cAndLaterParenthesizedQueries(t *testing.T) {+ tests := []struct {+ name string+ statement string+ want string+ }{+ {+ name: "parenthesized query",+ statement: "(SELECT a FROM t)",+ want: "(SELECT a FROM t) FETCH NEXT 10 ROWS ONLY",+ },+ {+ name: "parenthesized query with order by",+ statement: "(SELECT a FROM t) ORDER BY a",+ want: "(SELECT a FROM t) ORDER BY a FETCH NEXT 10 ROWS ONLY",+ },+ {+ name: "parenthesized query lowers its row limit",+ statement: "(SELECT a FROM t) FETCH FIRST 100 ROWS ONLY",+ want: "(SELECT a FROM t) FETCH FIRST 10 ROWS ONLY",+ },+ {+ name: "row limit of a parenthesized last operand limits that operand only",+ statement: "SELECT a FROM t UNION ALL (SELECT b FROM t FETCH FIRST 3 ROWS ONLY)",+ want: "SELECT a FROM t UNION ALL (SELECT b FROM t FETCH FIRST 3 ROWS ONLY) FETCH NEXT 10 ROWS ONLY",+ },+ {+ name: "row limit inside a parenthesized set operation limits that operation only",+ statement: "SELECT a FROM t UNION (SELECT b FROM t UNION SELECT a FROM t FETCH FIRST 3 ROWS ONLY)",+ want: "SELECT a FROM t UNION (SELECT b FROM t UNION SELECT a FROM t FETCH FIRST 3 ROWS ONLY) FETCH NEXT 10 ROWS ONLY",+ },+ {+ name: "row limit after a parenthesized last operand limits the query",+ statement: "SELECT a FROM t UNION (SELECT b FROM t UNION SELECT a FROM t) FETCH FIRST 30 ROWS ONLY",+ want: "SELECT a FROM t UNION (SELECT b FROM t UNION SELECT a FROM t) FETCH FIRST 10 ROWS ONLY",+ },+ {+ name: "row limit after a parenthesized middle operand limits the query",+ statement: "SELECT a FROM t UNION (SELECT b FROM t) UNION SELECT a FROM t FETCH FIRST 30 ROWS ONLY",+ want: "SELECT a FROM t UNION (SELECT b FROM t) UNION SELECT a FROM t FETCH FIRST 10 ROWS ONLY",+ },+ {+ name: "parenthesized operands with order by",+ statement: "(SELECT a FROM t) UNION (SELECT b FROM t) ORDER BY 1",+ want: "(SELECT a FROM t) UNION (SELECT b FROM t) ORDER BY 1 FETCH NEXT 10 ROWS ONLY",+ },+ {+ name: "parenthesized set operation",+ statement: "(SELECT a FROM t UNION SELECT b FROM t)",+ want: "(SELECT a FROM t UNION SELECT b FROM t FETCH NEXT 10 ROWS ONLY)",+ },+ {+ name: "parenthesis in a string literal of the last operand",+ statement: "SELECT a FROM t UNION (SELECT ')' FROM t)",+ want: "SELECT a FROM t UNION (SELECT ')' FROM t) FETCH NEXT 10 ROWS ONLY",+ },+ {+ name: "except",+ statement: "SELECT a FROM t EXCEPT SELECT b FROM t",+ want: "SELECT a FROM t EXCEPT SELECT b FROM t FETCH NEXT 10 ROWS ONLY",+ },+ }++ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ got := addLimitFor12cAndLater(tc.statement, 10)++ require.Equal(t, tc.want, got)+ _, err := ParsePLSQL(got)+ require.NoError(t, err, "rewritten SQL should remain parseable: %s", got)+ })+ }+}++func TestAddLimitFor11gWrapsParenthesizedQuery(t *testing.T) {+ got := addLimitFor11g("(SELECT a FROM t) ORDER BY a", 10)++ require.Equal(t, "SELECT * FROM ((SELECT a FROM t) ORDER BY a) WHERE ROWNUM <= 10", got)+}+func TestAddFetchNextClauseRegressionExistingFetch(t *testing.T) {tests := []struct {name stringdiff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.goindex 8eb6a56b74..682d063ecb 100644--- a/backend/plugin/parser/plsql/query_span_extractor.go+++ b/backend/plugin/parser/plsql/query_span_extractor.go@@ -633,6 +633,11 @@ func (q *omniQuerySpanExtractor) extractOmniSelect(stmt *oracleast.SelectStmt) (if stmt.Op != 0 {return q.extractOmniSetSelect(stmt)}+ // omni wraps a parenthesized query that ORDER BY or a row limit follows,+ // or a WITH clause precedes; the wrapper has no select list of its own.+ if stmt.Larg != nil {+ return q.extractOmniSelect(stmt.Larg)+ }if stmt.ModelClause != nil {source, err := q.extractOmniModelSelect(stmt)if err != nil {diff --git a/backend/plugin/parser/plsql/query_span_test.go b/backend/plugin/parser/plsql/query_span_test.goindex db0cdbf331..ab4c4777b4 100644--- a/backend/plugin/parser/plsql/query_span_test.go+++ b/backend/plugin/parser/plsql/query_span_test.go@@ -219,6 +219,43 @@ func TestGetQuerySpanRefusesSystemTableWithLink(t *testing.T) {require.Equal(t, base.Select, span.Type)}+func TestGetQuerySpanParenthesizedQuery(t *testing.T) {+ metadata := &metadatapb.DatabaseSchemaMetadata{+ Name: "PUBLIC",+ Schemas: []*metadatapb.SchemaMetadata{{Name: "", Tables: []*metadatapb.TableMetadata{{Name: "T", Columns: []*metadatapb.ColumnMetadata{{Name: "A"}, {Name: "B"}}}}}},+ }+ databaseMetadataGetter, databaseNamesLister, linkedDatabaseMetadataGetter := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})+ gCtx := base.GetQuerySpanContext{+ InstanceID: instanceIDA,+ GetDatabaseMetadataFunc: databaseMetadataGetter,+ ListDatabaseNamesFunc: databaseNamesLister,+ GetLinkedDatabaseMetadataFunc: linkedDatabaseMetadataGetter,+ }+ columnA := base.ColumnResource{Database: "PUBLIC", Table: "T", Column: "A"}+ columnB := base.ColumnResource{Database: "PUBLIC", Table: "T", Column: "B"}+ tests := []struct {+ statement string+ want base.SourceColumnSet+ }{+ {statement: "(SELECT a FROM t)", want: base.SourceColumnSet{columnA: true}},+ {statement: "(SELECT a FROM t) ORDER BY a", want: base.SourceColumnSet{columnA: true}},+ {statement: "((SELECT a FROM t)) ORDER BY 1", want: base.SourceColumnSet{columnA: true}},+ {statement: "(SELECT a FROM t) FETCH FIRST 5 ROWS ONLY", want: base.SourceColumnSet{columnA: true}},+ {statement: "WITH w AS (SELECT a FROM t) (SELECT a FROM w)", want: base.SourceColumnSet{columnA: true}},+ {statement: "(SELECT a FROM t) UNION (SELECT b FROM t) ORDER BY 1", want: base.SourceColumnSet{columnA: true, columnB: true}},+ {statement: "SELECT a FROM t EXCEPT SELECT b FROM t", want: base.SourceColumnSet{columnA: true, columnB: true}},+ }+ for _, tc := range tests {+ t.Run(tc.statement, func(t *testing.T) {+ span, err := GetQuerySpan(context.TODO(), gCtx, base.Statement{Text: tc.statement}, "PUBLIC", "", false)+ require.NoError(t, err)+ require.Len(t, span.Results, 1)+ require.Equal(t, "A", span.Results[0].Name)+ require.Equal(t, tc.want, span.Results[0].SourceColumns)+ })+ }+}+func TestGetAccessTables(t *testing.T) {tests := []struct {statement stringdiff --git a/backend/plugin/schema/mysql/walk_through.go b/backend/plugin/schema/mysql/walk_through.goindex fabde580fe..20a2ba7586 100644--- a/backend/plugin/schema/mysql/walk_through.go+++ b/backend/plugin/schema/mysql/walk_through.go@@ -14,6 +14,7 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/store/model"@@ -36,6 +37,13 @@ func WalkThroughWithContext(ctx context.Context, wtCtx schema.WalkThroughContextif wtCtx.RawSQL == "" {return nil}+ // omni's MySQL catalog rejects a statement only MariaDB accepts, and+ // simulating the others without it would check them against the wrong schema.+ for _, a := range asts {+ if _, ok := a.(*mariadb.OmniAST); ok {+ return nil+ }+ }dbName := d.GetProto().GetName()precheck := firstMySQLWalkThroughAdvice(diff --git a/backend/plugin/schema/mysql/walk_through_test.go b/backend/plugin/schema/mysql/walk_through_test.goindex 30aeb95f9c..3ea733e8fe 100644--- a/backend/plugin/schema/mysql/walk_through_test.go+++ b/backend/plugin/schema/mysql/walk_through_test.go@@ -125,6 +125,18 @@ func TestWalkThroughCreateTableIfNotExistsCTASExistingTable(t *testing.T) {require.NotNil(t, state.GetSchemaMetadata("").GetTable("t1"))}+func TestWalkThroughSkipsMariaDBOnlyStatements(t *testing.T) {+ state := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MARIADB, true)+ statement := "CREATE OR REPLACE TABLE t (a INT);\nALTER TABLE t ADD COLUMN b INT;"+ sm := sheet.NewManager()+ stmts, advices := sm.GetStatementsForChecks(storepb.Engine_MARIADB, statement)+ require.Empty(t, advices)++ advice := WalkThroughWithContext(context.Background(), schema.WalkThroughContext{RawSQL: statement}, state, base.ExtractASTs(stmts))+ require.Nil(t, advice)+ require.Empty(t, state.GetProto().GetSchemas())+}+// TestWalkThroughSRIDInvisible verifies the omni catalog -> metadatapb.ColumnMetadata// conversion (tableToProto) carries the spatial SRID (presence + value, including the// valid explicit SRID 0) and the INVISIBLE flag. Without this the WalkThroughWithContextdiff --git a/backend/runner/plancheck/statement_report_executor.go b/backend/runner/plancheck/statement_report_executor.goindex ddf07d6823..06c11721ac 100644--- a/backend/runner/plancheck/statement_report_executor.go+++ b/backend/runner/plancheck/statement_report_executor.go@@ -241,13 +241,23 @@ func GetSQLSummaryReport(ctx context.Context, stores *store.Store, sheetManagerif err != nil {return nil, "", errors.Wrapf(err, "failed to extract changed resources")}- totalAffectedRows, estimateWarning := calculateAffectedRows(ctx, instance.Metadata.GetEngine(), changeSummary, explainCalculator)+ report, warning := buildSQLSummaryReport(ctx, instance.Metadata.GetEngine(), sqlTypes, changeSummary, explainCalculator)+ return report, warning, nil+}+// buildSQLSummaryReport returns the report of changeSummary and a warning about what it could not+// estimate. It returns no report when the extractor skipped a statement: that statement's rows and+// resources are unknown, and approval rules would read the undercount as statement.affected_rows.+func buildSQLSummaryReport(ctx context.Context, engine storepb.Engine, sqlTypes []storepb.StatementType, changeSummary *parserbase.ChangeSummary, explainCalculator getAffectedRowsFromExplain) (*storepb.PlanCheckRunResult_Result_SqlSummaryReport, string) {+ if changeSummary.SkippedStatements > 0 {+ return nil, fmt.Sprintf("Affected rows and changed resources are not reported because %d of the statements could not be read.", changeSummary.SkippedStatements)+ }+ totalAffectedRows, estimateWarning := calculateAffectedRows(ctx, engine, changeSummary, explainCalculator)return &storepb.PlanCheckRunResult_Result_SqlSummaryReport{StatementTypes: sqlTypes,AffectedRows: totalAffectedRows,ChangedResources: changeSummary.ChangedResources.Build(),- }, estimateWarning, nil+ }, estimateWarning}// SummaryStatementTypes classifies a summary report's statements through thediff --git a/backend/runner/plancheck/statement_report_executor_test.go b/backend/runner/plancheck/statement_report_executor_test.goindex c80ee2e877..99857952bf 100644--- a/backend/runner/plancheck/statement_report_executor_test.go+++ b/backend/runner/plancheck/statement_report_executor_test.go@@ -419,3 +419,38 @@ func TestSummaryStatementTypesRejectsEngineWithoutClassifier(t *testing.T) {_, err := SummaryStatementTypes(storepb.Engine_SNOWFLAKE, nil)require.Error(t, err)}++func TestBuildSQLSummaryReportOmitsReportWithSkippedStatements(t *testing.T) {+ for _, tc := range []struct {+ name string+ statement string+ wantReport bool+ }{+ {name: "mysql_parsable_sheet", statement: "UPDATE t SET a = 1 WHERE id = 1;", wantReport: true},+ {name: "mariadb_only_dml", statement: "UPDATE t SET a = 1 WHERE id = 1;\nDELETE FROM t WHERE id = 2 RETURNING id;"},+ } {+ t.Run(tc.name, func(t *testing.T) {+ stmts, err := parserbase.ParseStatements(storepb.Engine_MARIADB, tc.statement)+ require.NoError(t, err)+ changeSummary, err := parserbase.ExtractChangedResources(storepb.Engine_MARIADB, "db", "", nil /* dbMetadata */, parserbase.ExtractASTs(stmts), tc.statement)+ require.NoError(t, err)+ explains := 0+ explain := func(context.Context, string) (int64, error) {+ explains+++ return 7, nil+ }++ report, warning := buildSQLSummaryReport(context.Background(), storepb.Engine_MARIADB, nil /* sqlTypes */, changeSummary, explain)++ if tc.wantReport {+ require.NotNil(t, report)+ require.Equal(t, int64(7), report.AffectedRows)+ require.Empty(t, warning)+ return+ }+ require.Nil(t, report)+ require.Equal(t, "Affected rows and changed resources are not reported because 1 of the statements could not be read.", warning)+ require.Zero(t, explains)+ })+ }+}diff --git a/go.mod b/go.modindex 6a89bdbab9..f5eca782da 100644--- a/go.mod+++ b/go.mod@@ -36,7 +36,7 @@ require (github.com/bmatcuk/doublestar/v4 v4.10.0github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0- github.com/bytebase/omni v0.0.0-20261016090414-431fd0dff942+ github.com/bytebase/omni v0.0.0-20261020074414-8031142a6c5egithub.com/caarlos0/env/v11 v11.4.1github.com/cenkalti/backoff/v7 v7.0.0github.com/cockroachdb/cockroach-go/v2 v2.4.3diff --git a/go.sum b/go.sumindex a9d72f8a69..9158695c9f 100644--- a/go.sum+++ b/go.sum@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735 h1:v8y6mXeHmYVsdMgithub.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735/go.mod h1:vTHjcvfn8Pmf65WjnV1ytTCYyC7xNhFjrniv4YWvtA8=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0 h1:bJ8NSf2K+pccl5m/wuu97fiYjDwpJH6IzURAq/3XA2U=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0/go.mod h1:BEWMfiZtqshdmulKJcIsWb45MUaEvDO4CROcgi8dfFg=-github.com/bytebase/omni v0.0.0-20261016090414-431fd0dff942 h1:9AYkMDev4UcDaYyrJk2cqymYxJYrQLEyHXX85I2XRMc=-github.com/bytebase/omni v0.0.0-20261016090414-431fd0dff942/go.mod h1:9XZE1hqtvr09Oc+DdLu1/yCb8MDcoy/EPdA4AONDHlE=+github.com/bytebase/omni v0.0.0-20261020074414-8031142a6c5e h1:HliM6J1o0GjVkQ7j6MarLVhqy0ezGqVrZohVelbxDHU=+github.com/bytebase/omni v0.0.0-20261020074414-8031142a6c5e/go.mod h1:9XZE1hqtvr09Oc+DdLu1/yCb8MDcoy/EPdA4AONDHlE=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=github.com/bytebase/pkcs8 v0.0.0-20240612095628-fcd0a7484c94 h1:6PNsuNmSqCuR8Z616uQLzDIvujWCFsKzeVc3ECmVubk=