Skip to content

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

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.go
index 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 check
return 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 []writeTargetResource
databasesWithTableTarget := 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 real
diff --git a/backend/api/v1/sql_service_schema_resolution_test.go b/backend/api/v1/sql_service_schema_resolution_test.go
index 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.go
index 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.go
index 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 adv
if 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 {
continue
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index 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.go
index 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_test
import (
"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.go
index 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.go
index 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 positions
stmts, 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.go
index 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.go
index 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 int
var 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.go
index 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.go
index 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.go
index 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.go
index 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, limi
return 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.go
index 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 string
diff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.go
index 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.go
index 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 string
diff --git a/backend/plugin/schema/mysql/walk_through.go b/backend/plugin/schema/mysql/walk_through.go
index 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.WalkThroughContext
if 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.go
index 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 WalkThroughWithContext
diff --git a/backend/runner/plancheck/statement_report_executor.go b/backend/runner/plancheck/statement_report_executor.go
index 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, sheetManager
if 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 the
diff --git a/backend/runner/plancheck/statement_report_executor_test.go b/backend/runner/plancheck/statement_report_executor_test.go
index 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.mod
index 6a89bdbab9..f5eca782da 100644
--- a/go.mod
+++ b/go.mod
@@ -36,7 +36,7 @@ require (
github.com/bmatcuk/doublestar/v4 v4.10.0
github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735
github.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-8031142a6c5e
github.com/caarlos0/env/v11 v11.4.1
github.com/cenkalti/backoff/v7 v7.0.0
github.com/cockroachdb/cockroach-go/v2 v2.4.3
diff --git a/go.sum b/go.sum
index a9d72f8a69..9158695c9f 100644
--- a/go.sum
+++ b/go.sum
@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735 h1:v8y6mXeHmYVsdM
github.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=