Skip to content

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

feat(parser): replace Cassandra ANTLR parser with omni parser (#20651)

rebelicea9a10ecde8ba
diff --git a/backend/plugin/parser/cassandra/cassandra.go b/backend/plugin/parser/cassandra/cassandra.go
index ba41c26571..044cbf2616 100644
--- a/backend/plugin/parser/cassandra/cassandra.go
+++ b/backend/plugin/parser/cassandra/cassandra.go
@@ -1,115 +1,67 @@
package cassandra
import (
- "strings"
+ "errors"
+ "fmt"
- "github.com/antlr4-go/antlr/v4"
- "github.com/bytebase/parser/cql"
+ omniparser "github.com/bytebase/omni/cassandra/parser"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/utils"
)
func init() {
base.RegisterParseStatementsFunc(storepb.Engine_CASSANDRA, parseCassandraStatements)
}
-// parseCassandraStatements is the ParseStatementsFunc for Cassandra.
-// Returns []ParsedStatement with both text and AST populated.
func parseCassandraStatements(statement string) ([]base.ParsedStatement, error) {
- // First split to get Statement with text and positions
stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
- // Then parse to get ASTs
- parseResults, err := ParseCassandraSQL(statement)
- if err != nil {
- return nil, err
- }
-
- // Combine: Statement provides text/positions, ParseResult provides AST
var result []base.ParsedStatement
- astIndex := 0
- for _, stmt := range stmts {
- ps := base.ParsedStatement{
- Statement: stmt,
- }
- if !stmt.Empty && astIndex < len(parseResults) {
- ps.AST = parseResults[astIndex]
- astIndex++
- }
- result = append(result, ps)
- }
-
- return result, nil
-}
-
-// ParseCassandraSQL parses the given CQL statement by using antlr4. Returns a list of AST and token stream if no error.
-func ParseCassandraSQL(statement string) ([]*base.ANTLRAST, error) {
- stmts, err := SplitSQL(statement)
- if err != nil {
- return nil, err
- }
-
- var result []*base.ANTLRAST
for _, stmt := range stmts {
if stmt.Empty {
continue
}
- parseResult, err := parseSingleCassandraSQL(stmt.Text, stmt.BaseLine())
- if err != nil {
- return nil, err
+ omniStmts, omniErr := ParseCQL(stmt.Text)
+ if omniErr != nil {
+ return nil, convertOmniError(omniErr, stmt)
}
- result = append(result, parseResult)
- }
+ for _, os := range omniStmts {
+ result = append(result, base.ParsedStatement{
+ Statement: stmt,
+ AST: &OmniAST{
+ Node: os.AST,
+ Text: stmt.Text,
+ StartPosition: stmt.Start,
+ },
+ })
+ }
+ }
return result, nil
}
-func parseSingleCassandraSQL(statement string, baseLine int) (*base.ANTLRAST, error) {
- statement = strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon) + "\n;"
- inputStream := antlr.NewInputStream(statement)
- lexer := cql.NewCqlLexer(inputStream)
- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
- p := cql.NewCqlParser(stream)
-
- // Remove default error listener and add our own error listener.
- startPosition := &storepb.Position{Line: int32(baseLine) + 1}
- lexer.RemoveErrorListeners()
- lexerErrorListener := &base.ParseErrorListener{
- Statement: statement,
- StartPosition: startPosition,
- }
- lexer.AddErrorListener(lexerErrorListener)
-
- p.RemoveErrorListeners()
- parserErrorListener := &base.ParseErrorListener{
- Statement: statement,
- StartPosition: startPosition,
+func convertOmniError(err error, stmt base.Statement) error {
+ var parseErr *omniparser.ParseError
+ if !errors.As(err, &parseErr) {
+ return err
}
- p.AddErrorListener(parserErrorListener)
- p.BuildParseTrees = true
-
- tree := p.Root()
-
- if lexerErrorListener.Err != nil {
- return nil, lexerErrorListener.Err
- }
-
- if parserErrorListener.Err != nil {
- return nil, parserErrorListener.Err
+ pos := byteOffsetToPosition(stmt.Text, parseErr.Loc.Start)
+ if stmt.Start != nil {
+ if pos.Line == 1 {
+ pos.Column += stmt.Start.Column - 1
+ }
+ pos.Line += stmt.Start.Line - 1
}
- result := &base.ANTLRAST{
- StartPosition: &storepb.Position{Line: int32(baseLine) + 1},
- Tree: tree,
- Tokens: stream,
+ return &base.SyntaxError{
+ Position: pos,
+ Message: fmt.Sprintf("Syntax error at line %d: %s", pos.Line, parseErr.Message),
+ RawMessage: parseErr.Message,
}
-
- return result, nil
}
diff --git a/backend/plugin/parser/cassandra/cassandra_test.go b/backend/plugin/parser/cassandra/cassandra_test.go
index 443c13d3ed..99bd9d7def 100644
--- a/backend/plugin/parser/cassandra/cassandra_test.go
+++ b/backend/plugin/parser/cassandra/cassandra_test.go
@@ -1,6 +1,7 @@
package cassandra
import (
+ "errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -9,7 +10,7 @@ import (
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
-func TestParseCassandraSQL(t *testing.T) {
+func TestParseCassandraStatements(t *testing.T) {
tests := []struct {
name string
statement string
@@ -46,21 +47,15 @@ func TestParseCassandraSQL(t *testing.T) {
wantStatCount: 0,
wantErr: false,
},
- {
- name: "Only semicolon",
- statement: ";",
- wantStatCount: 1, // Semicolon creates one statement (not filtered by ParseCassandraSQL)
- wantErr: false,
- },
{
name: "CREATE TABLE statement",
- statement: "CREATE TABLE users (id UUID PRIMARY KEY, name TEXT);",
+ statement: "CREATE TABLE users (id int PRIMARY KEY, name text);",
wantStatCount: 1,
wantErr: false,
},
{
name: "Multiple DDL statements",
- statement: "CREATE KEYSPACE test WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}; CREATE TABLE test.users (id UUID PRIMARY KEY);",
+ statement: "CREATE KEYSPACE test WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': '1'}; CREATE TABLE test.users (id int PRIMARY KEY);",
wantStatCount: 2,
wantErr: false,
},
@@ -68,7 +63,7 @@ func TestParseCassandraSQL(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- results, err := ParseCassandraSQL(tt.statement)
+ results, err := parseCassandraStatements(tt.statement)
if tt.wantErr {
require.Error(t, err)
return
@@ -76,34 +71,26 @@ func TestParseCassandraSQL(t *testing.T) {
require.NoError(t, err)
assert.Equal(t, tt.wantStatCount, len(results))
- // Verify each result has the required fields
for i, result := range results {
- assert.NotNil(t, result.Tree, "Result %d should have a Tree", i)
- assert.NotNil(t, result.Tokens, "Result %d should have Tokens", i)
+ assert.NotNil(t, result.AST, "Result %d should have an AST", i)
+ assert.NotEmpty(t, result.Text, "Result %d should have Text", i)
}
})
}
}
-func TestParseCassandraSQLBaseLine(t *testing.T) {
- statement := `SELECT * FROM users;
- SELECT * FROM orders;
- SELECT * FROM products;`
- results, err := ParseCassandraSQL(statement)
+func TestParseCassandraStatementsPositions(t *testing.T) {
+ statement := "SELECT * FROM users;\nSELECT * FROM orders;\nSELECT * FROM products;"
+ results, err := parseCassandraStatements(statement)
require.NoError(t, err)
require.Equal(t, 3, len(results))
- // BaseLine follows the pattern from SplitSQL based on token positions
- // First statement: line 0
- assert.Equal(t, 0, base.GetLineOffset(results[0].StartPosition))
- // Second statement: includes newline+tab prefix, but first token is on line 2 (BaseLine = line - 1 = 1-1 = 0)
- // Actually the newline is part of the previous statement's text, so first real token is on line 2
- assert.Equal(t, 0, base.GetLineOffset(results[1].StartPosition)) // First token after semicolon is still on line 1 (0-indexed)
- // Third statement
- assert.Equal(t, 1, base.GetLineOffset(results[2].StartPosition))
+ assert.Equal(t, int32(1), results[0].Start.Line)
+ assert.Equal(t, int32(2), results[1].Start.Line)
+ assert.Equal(t, int32(3), results[2].Start.Line)
}
-func TestParseCassandraSQLErrors(t *testing.T) {
+func TestParseCassandraStatementsErrors(t *testing.T) {
tests := []struct {
name string
statement string
@@ -112,16 +99,80 @@ func TestParseCassandraSQLErrors(t *testing.T) {
name: "Invalid CQL syntax",
statement: "SELCT * FORM users;",
},
- {
- name: "Unclosed string",
- statement: "SELECT * FROM users WHERE name = 'test;",
- },
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- _, err := ParseCassandraSQL(tt.statement)
+ _, err := parseCassandraStatements(tt.statement)
require.Error(t, err, "Expected error for invalid CQL")
})
}
}
+
+func TestSyntaxErrorIsSyntaxError(t *testing.T) {
+ _, err := parseCassandraStatements("SELCT * FORM users")
+ require.Error(t, err)
+ var syntaxErr *base.SyntaxError
+ require.True(t, errors.As(err, &syntaxErr), "parse error should be *base.SyntaxError, got %T", err)
+ require.NotNil(t, syntaxErr.Position)
+}
+
+func TestSyntaxErrorColumnOffset(t *testing.T) {
+ input := "SELECT * FROM t;\n SELCT * FROM users"
+ _, err := parseCassandraStatements(input)
+ require.Error(t, err)
+ var syntaxErr *base.SyntaxError
+ require.True(t, errors.As(err, &syntaxErr))
+
+ // The splitter trims "SELCT * FROM users" starting at line 2, col 3.
+ // The parse error on "SELCT" is at byte 0 of the trimmed text → local (line=1, col=1).
+ // After adjustment: line = 1 + 2 - 1 = 2, col = 1 + 3 - 1 = 3.
+ require.Equal(t, int32(2), syntaxErr.Position.Line)
+ require.Equal(t, int32(3), syntaxErr.Position.Column)
+}
+
+func TestParseCassandraOmniAST(t *testing.T) {
+ results, err := parseCassandraStatements("SELECT id, name FROM users")
+ require.NoError(t, err)
+ require.Len(t, results, 1)
+
+ node, ok := GetOmniNode(results[0].AST)
+ require.True(t, ok, "AST should be an OmniAST")
+ require.NotNil(t, node)
+}
+
+func TestParseCassandraComprehensiveDDL(t *testing.T) {
+ ddlStatements := []string{
+ "CREATE KEYSPACE ks WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}",
+ "ALTER KEYSPACE ks WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3}",
+ "DROP KEYSPACE IF EXISTS ks",
+ "CREATE TABLE ks.t (id int PRIMARY KEY, name text, data blob)",
+ "ALTER TABLE ks.t ADD email text",
+ "DROP TABLE IF EXISTS ks.t",
+ "CREATE INDEX idx ON ks.t (name)",
+ "DROP INDEX IF EXISTS ks.idx",
+ "CREATE TYPE ks.addr (street text, city text)",
+ "ALTER TYPE ks.addr ADD zip text",
+ "DROP TYPE IF EXISTS ks.addr",
+ "CREATE MATERIALIZED VIEW ks.mv AS SELECT id, name FROM ks.t WHERE id IS NOT NULL AND name IS NOT NULL PRIMARY KEY (name, id)",
+ "ALTER MATERIALIZED VIEW ks.mv WITH compression = {'sstable_compression': 'LZ4Compressor'}",
+ "DROP MATERIALIZED VIEW IF EXISTS ks.mv",
+ "CREATE FUNCTION ks.double(val int) RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE java AS 'return val * 2;'",
+ "DROP FUNCTION IF EXISTS ks.double",
+ "CREATE TRIGGER tr ON ks.t USING 'org.example.Trigger'",
+ "DROP TRIGGER IF EXISTS tr ON ks.t",
+ "TRUNCATE ks.t",
+ }
+ for _, stmt := range ddlStatements {
+ name := stmt
+ if len(name) > 40 {
+ name = name[:40]
+ }
+ t.Run(name, func(t *testing.T) {
+ results, err := parseCassandraStatements(stmt)
+ require.NoError(t, err)
+ require.Len(t, results, 1)
+ require.NotNil(t, results[0].AST)
+ })
+ }
+}
diff --git a/backend/plugin/parser/cassandra/omni.go b/backend/plugin/parser/cassandra/omni.go
new file mode 100644
index 0000000000..8c2d9bcba8
--- /dev/null
+++ b/backend/plugin/parser/cassandra/omni.go
@@ -0,0 +1,41 @@
+package cassandra
+
+import (
+ omnicassandra "github.com/bytebase/omni/cassandra"
+ "github.com/bytebase/omni/cassandra/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+// OmniAST wraps an omni AST node and implements the base.AST interface.
+type OmniAST struct {
+ Node ast.Node
+ Text string
+ StartPosition *storepb.Position
+}
+
+func (a *OmniAST) ASTStartPosition() *storepb.Position {
+ return a.StartPosition
+}
+
+// GetOmniNode extracts the omni AST node from a base.AST interface.
+func GetOmniNode(a base.AST) (ast.Node, bool) {
+ if a == nil {
+ return nil, false
+ }
+ omniAST, ok := a.(*OmniAST)
+ if !ok {
+ return nil, false
+ }
+ return omniAST.Node, true
+}
+
+// ParseCQL parses CQL using omni's parser and returns omni Statement objects.
+func ParseCQL(sql string) ([]omnicassandra.Statement, error) {
+ return omnicassandra.Parse(sql)
+}
+
+func byteOffsetToPosition(sql string, byteOffset int) *storepb.Position {
+ return base.NewByteOffsetPositionMapper(sql).Position(byteOffset)
+}
diff --git a/backend/plugin/parser/cassandra/query_span.go b/backend/plugin/parser/cassandra/query_span.go
index bb604d05bb..f2c96b8087 100644
--- a/backend/plugin/parser/cassandra/query_span.go
+++ b/backend/plugin/parser/cassandra/query_span.go
@@ -3,7 +3,6 @@ package cassandra
import (
"context"
- "github.com/antlr4-go/antlr/v4"
"github.com/pkg/errors"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -14,31 +13,21 @@ func init() {
base.RegisterGetQuerySpan(storepb.Engine_CASSANDRA, GetQuerySpan)
}
-// GetQuerySpan extracts the query span from a CQL statement.
func GetQuerySpan(ctx context.Context, gCtx base.GetQuerySpanContext, stmt base.Statement, database, _ string, _ bool) (*base.QuerySpan, error) {
- parseResults, err := ParseCassandraSQL(stmt.Text)
+ stmts, err := ParseCQL(stmt.Text)
if err != nil {
- return nil, err
+ return nil, convertOmniError(err, base.Statement{Text: stmt.Text})
}
- if len(parseResults) == 0 {
+ if len(stmts) == 0 {
return &base.QuerySpan{
SourceColumns: base.SourceColumnSet{},
Results: []base.QuerySpanResult{},
}, nil
}
- if len(parseResults) != 1 {
- return nil, errors.Errorf("expecting only one statement to get query span, but got %d", len(parseResults))
+ if len(stmts) != 1 {
+ return nil, errors.Errorf("expecting only one statement to get query span, but got %d", len(stmts))
}
- tree := parseResults[0].Tree
-
- // Create extractor and walk the tree
extractor := newQuerySpanExtractor(ctx, database, gCtx)
- antlr.ParseTreeWalkerDefault.Walk(extractor, tree)
-
- if extractor.err != nil {
- return nil, extractor.err
- }
-
- return extractor.querySpan, nil
+ return extractor.extract(stmts[0].AST), nil
}
diff --git a/backend/plugin/parser/cassandra/query_span_extractor.go b/backend/plugin/parser/cassandra/query_span_extractor.go
index 859c190851..baf57178e1 100644
--- a/backend/plugin/parser/cassandra/query_span_extractor.go
+++ b/backend/plugin/parser/cassandra/query_span_extractor.go
@@ -2,44 +2,24 @@ package cassandra
import (
"context"
- "strings"
- "github.com/antlr4-go/antlr/v4"
- "github.com/bytebase/parser/cql"
+ "github.com/bytebase/omni/cassandra/ast"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
-// querySpanExtractor walks the CQL parse tree to extract query span information
type querySpanExtractor struct {
- *cql.BaseCqlParserListener
-
- // Context
ctx context.Context
defaultKeyspace string
gCtx base.GetQuerySpanContext
-
- // Results we're building
- querySpan *base.QuerySpan
-
- // Error handling
- err error
-}
-
-// unquoteIdentifier removes double quotes from Cassandra identifiers if present.
-func unquoteIdentifier(identifier string) string {
- if len(identifier) >= 2 && identifier[0] == '"' && identifier[len(identifier)-1] == '"' {
- return identifier[1 : len(identifier)-1]
- }
- return identifier
+ querySpan *base.QuerySpan
}
func newQuerySpanExtractor(ctx context.Context, defaultKeyspace string, gCtx base.GetQuerySpanContext) *querySpanExtractor {
return &querySpanExtractor{
- BaseCqlParserListener: &cql.BaseCqlParserListener{},
- ctx: ctx,
- defaultKeyspace: defaultKeyspace,
- gCtx: gCtx,
+ ctx: ctx,
+ defaultKeyspace: defaultKeyspace,
+ gCtx: gCtx,
querySpan: &base.QuerySpan{
Type: base.QueryTypeUnknown,
Results: []base.QuerySpanResult{},
@@ -49,134 +29,159 @@ func newQuerySpanExtractor(ctx context.Context, defaultKeyspace string, gCtx bas
}
}
-// EnterSelect_ is called when we enter a SELECT statement
-func (e *querySpanExtractor) EnterSelect_(ctx *cql.Select_Context) {
- if e.err != nil {
- return
- }
+func (e *querySpanExtractor) extract(node ast.Node) *base.QuerySpan {
+ switch stmt := node.(type) {
+ case *ast.SelectStmt:
+ e.extractSelect(stmt)
+ case *ast.InsertStmt:
+ e.extractInsert(stmt)
+ case *ast.UpdateStmt:
+ e.extractUpdate(stmt)
+ case *ast.DeleteStmt:
+ e.extractDelete(stmt)
+ case *ast.BatchStmt:
+ e.querySpan.Type = base.DML
+ for _, child := range stmt.Statements {
+ e.extract(child)
+ }
+ case *ast.TruncateStmt:
+ e.querySpan.Type = base.DML
+ case *ast.CreateTableStmt, *ast.AlterTableStmt, *ast.DropTableStmt,
+ *ast.CreateKeyspaceStmt, *ast.AlterKeyspaceStmt, *ast.DropKeyspaceStmt,
+ *ast.CreateIndexStmt, *ast.DropIndexStmt,
+ *ast.CreateMVStmt, *ast.AlterMVStmt, *ast.DropMVStmt,
+ *ast.CreateTypeStmt, *ast.AlterTypeStmt, *ast.DropTypeStmt,
+ *ast.CreateFunctionStmt, *ast.DropFunctionStmt,
+ *ast.CreateAggregateStmt, *ast.DropAggregateStmt,
+ *ast.CreateTriggerStmt, *ast.DropTriggerStmt:
+ e.querySpan.Type = base.DDL
+ default:
+ }
+ return e.querySpan
+}
- // Set query type to SELECT
+func (e *querySpanExtractor) extractSelect(stmt *ast.SelectStmt) {
e.querySpan.Type = base.Select
- keyspace, table := e.extractTableFromFromSpec(ctx.FromSpec())
- if keyspace == "" {
- keyspace = e.defaultKeyspace
- }
+ keyspace, table := e.qualifiedNameParts(stmt.From)
- // Add accessed table to SourceColumns (table-level resource)
if table != "" {
e.querySpan.SourceColumns[base.ColumnResource{
Database: keyspace,
Table: table,
- Column: "", // Empty column means table-level access
}] = true
}
- results := e.extractSelectElements(ctx.SelectElements(), keyspace, table)
- e.querySpan.Results = results
+ e.querySpan.Results = e.selectElements(stmt.Elements, keyspace, table)
+
+ e.extractWhereColumns(stmt.Where, keyspace, table)
+}
- if whereSpec := ctx.WhereSpec(); whereSpec != nil {
- e.extractWhereColumns(whereSpec, keyspace, table)
+func (e *querySpanExtractor) extractInsert(stmt *ast.InsertStmt) {
+ e.querySpan.Type = base.DML
+ keyspace, table := e.qualifiedNameParts(stmt.Table)
+ if table != "" {
+ e.querySpan.SourceColumns[base.ColumnResource{
+ Database: keyspace,
+ Table: table,
+ }] = true
}
}
-// extractTableFromFromSpec extracts keyspace and table name from FROM clause
-func (*querySpanExtractor) extractTableFromFromSpec(fromSpec cql.IFromSpecContext) (keyspace, table string) {
- if fromSpec == nil {
- return "", ""
+func (e *querySpanExtractor) extractUpdate(stmt *ast.UpdateStmt) {
+ e.querySpan.Type = base.DML
+ keyspace, table := e.qualifiedNameParts(stmt.Table)
+ if table != "" {
+ e.querySpan.SourceColumns[base.ColumnResource{
+ Database: keyspace,
+ Table: table,
+ }] = true
}
+ e.extractWhereColumns(stmt.Where, keyspace, table)
+}
- if fromElem := fromSpec.FromSpecElement(); fromElem != nil {
- text := fromElem.GetText()
- // CQL supports keyspace.table in FROM clause
- if idx := strings.LastIndex(text, "."); idx > 0 {
- keyspacePart := text[:idx]
- tablePart := text[idx+1:]
- return unquoteIdentifier(keyspacePart), unquoteIdentifier(tablePart)
- }
- return "", unquoteIdentifier(text)
+func (e *querySpanExtractor) extractDelete(stmt *ast.DeleteStmt) {
+ e.querySpan.Type = base.DML
+ keyspace, table := e.qualifiedNameParts(stmt.From)
+ if table != "" {
+ e.querySpan.SourceColumns[base.ColumnResource{
+ Database: keyspace,
+ Table: table,
+ }] = true
}
- return "", ""
+ e.extractWhereColumns(stmt.Where, keyspace, table)
}
-// extractSelectElements extracts column information from SELECT clause
-func (e *querySpanExtractor) extractSelectElements(selectElements cql.ISelectElementsContext, keyspace, table string) []base.QuerySpanResult {
- if selectElements == nil {
- return nil
+func (e *querySpanExtractor) qualifiedNameParts(qn *ast.QualifiedName) (keyspace, table string) {
+ if qn == nil {
+ return e.defaultKeyspace, ""
}
+ switch len(qn.Parts) {
+ case 2:
+ return qn.Parts[0].Name, qn.Parts[1].Name
+ case 1:
+ return e.defaultKeyspace, qn.Parts[0].Name
+ default:
+ return e.defaultKeyspace, ""
+ }
+}
- if selectElements.GetStar() != nil {
- return e.expandSelectAsterisk(keyspace, table)
+func (e *querySpanExtractor) selectElements(elems []*ast.SelectElement, keyspace, table string) []base.QuerySpanResult {
+ if len(elems) == 0 {
+ return nil
}
var results []base.QuerySpanResult
- for _, elem := range selectElements.AllSelectElement() {
- aliasName, sourceName := e.extractColumnNameAndAlias(elem)
- if aliasName != "" || sourceName != "" {
- resultName := aliasName
- if resultName == "" {
- resultName = sourceName
- }
-
- sourceColumn := base.SourceColumnSet{}
- sourceColumn[base.ColumnResource{
- Database: keyspace,
- Table: table,
- Column: sourceName,
- }] = true
+ for _, elem := range elems {
+ if _, isStar := elem.Expr.(*ast.StarExpr); isStar {
+ return e.expandSelectAsterisk(keyspace, table)
+ }
+ sourceName := exprColumnName(elem.Expr)
+ resultName := sourceName
+ if elem.Alias != nil {
+ resultName = elem.Alias.Name
+ }
+ if resultName == "" && sourceName == "" {
results = append(results, base.QuerySpanResult{
- Name: resultName,
- SourceColumns: sourceColumn,
- IsPlainField: true,
+ Name: "",
+ SourceColumns: base.SourceColumnSet{},
})
+ continue
}
- }
- return results
-}
-// extractColumnNameAndAlias extracts both the alias (if present) and the source column name
-func (*querySpanExtractor) extractColumnNameAndAlias(elem cql.ISelectElementContext) (alias string, sourceColumn string) {
- if elem == nil {
- return "", ""
- }
+ sc := base.SourceColumnSet{}
+ sc[base.ColumnResource{
+ Database: keyspace,
+ Table: table,
+ Column: sourceName,
+ }] = true
- // Extract the source column name from the first child
- if elem.GetChildCount() > 0 {
- columnRef := elem.GetChild(0).(antlr.ParseTree).GetText()
- sourceColumn = unquoteIdentifier(columnRef)
+ results = append(results, base.QuerySpanResult{
+ Name: resultName,
+ SourceColumns: sc,
+ IsPlainField: true,
+ })
}
+ return results
+}
- // Check for AS alias
- for i := 0; i < elem.GetChildCount(); i++ {
- if child := elem.GetChild(i); child != nil {
- childText := child.(antlr.ParseTree).GetText()
- if strings.ToUpper(childText) == "AS" && i+1 < elem.GetChildCount() {
- aliasText := elem.GetChild(i + 1).(antlr.ParseTree).GetText()
- alias = unquoteIdentifier(aliasText)
- break
- }
+func exprColumnName(expr ast.ExprNode) string {
+ switch e := expr.(type) {
+ case *ast.Identifier:
+ return e.Name
+ case *ast.DotAccess:
+ if e.Field != nil {
+ return e.Field.Name
}
+ default:
}
-
- return alias, sourceColumn
+ return ""
}
-// expandSelectAsterisk expands SELECT * into individual column results
func (e *querySpanExtractor) expandSelectAsterisk(keyspace, table string) []base.QuerySpanResult {
- if e.gCtx.GetDatabaseMetadataFunc == nil {
- // Test environment - fallback to SelectAsterisk flag
- return []base.QuerySpanResult{{
- Name: "",
- SourceColumns: base.SourceColumnSet{},
- SelectAsterisk: true,
- }}
- }
-
- if table == "" {
- // Cannot expand SELECT * without a table name
+ if e.gCtx.GetDatabaseMetadataFunc == nil || table == "" {
return []base.QuerySpanResult{{
- Name: "",
SourceColumns: base.SourceColumnSet{},
SelectAsterisk: true,
}}
@@ -184,330 +189,98 @@ func (e *querySpanExtractor) expandSelectAsterisk(keyspace, table string) []base
_, metadata, err := e.gCtx.GetDatabaseMetadataFunc(e.ctx, e.gCtx.InstanceID, keyspace)
if err != nil || metadata == nil {
- // If we can't get metadata, fall back to SelectAsterisk flag
- // This matches behavior of other engines like TSQL
return []base.QuerySpanResult{{
- Name: "",
SourceColumns: base.SourceColumnSet{},
SelectAsterisk: true,
}}
}
- // Find table and expand columns
var results []base.QuerySpanResult
- schemaNames := metadata.ListSchemaNames()
- for _, schemaName := range schemaNames {
+ for _, schemaName := range metadata.ListSchemaNames() {
schema := metadata.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
-
tbl := schema.GetTable(table)
- if tbl != nil {
- for _, col := range tbl.GetProto().GetColumns() {
- sourceColumn := base.SourceColumnSet{}
- sourceColumn[base.ColumnResource{
- Database: keyspace,
- Table: table,
- Column: col.GetName(),
- }] = true
-
- results = append(results, base.QuerySpanResult{
- Name: col.GetName(),
- SourceColumns: sourceColumn,
- IsPlainField: true,
- })
- }
- return results
+ if tbl == nil {
+ continue
+ }
+ for _, col := range tbl.GetProto().GetColumns() {
+ sc := base.SourceColumnSet{}
+ sc[base.ColumnResource{
+ Database: keyspace,
+ Table: table,
+ Column: col.GetName(),
+ }] = true
+ results = append(results, base.QuerySpanResult{
+ Name: col.GetName(),
+ SourceColumns: sc,
+ IsPlainField: true,
+ })
}
+ return results
}
- // Table not found - fall back to SelectAsterisk flag
return []base.QuerySpanResult{{
- Name: "",
SourceColumns: base.SourceColumnSet{},
SelectAsterisk: true,
}}
}
-// extractWhereColumns extracts column references from WHERE clause
-func (e *querySpanExtractor) extractWhereColumns(whereSpec cql.IWhereSpecContext, keyspace, table string) {
- if whereSpec == nil {
- return
- }
-
- // Extract relation elements from WHERE clause
- if relationElements := whereSpec.RelationElements(); relationElements != nil {
- // Process all relation elements (conditions connected by AND)
- for _, relationElement := range relationElements.AllRelationElement() {
- e.extractColumnsFromRelation(relationElement, keyspace, table)
- }
+func (e *querySpanExtractor) extractWhereColumns(where []ast.ExprNode, keyspace, table string) {
+ for _, expr := range where {
+ e.extractColumnRefsFromExpr(expr, keyspace, table)
}
}
-// extractColumnsFromRelation extracts column references from a single relation element
-func (e *querySpanExtractor) extractColumnsFromRelation(relation cql.IRelationElementContext, keyspace, table string) {
- if relation == nil {
- return
- }
-
- // Extract column names from OBJECT_NAME tokens
- // In CQL, columns are referenced as OBJECT_NAME in WHERE conditions
- for _, objName := range relation.AllOBJECT_NAME() {
- columnName := unquoteIdentifier(objName.GetText())
-
- colResource := base.ColumnResource{
- Database: keyspace,
- Table: table,
- Column: columnName,
+func (e *querySpanExtractor) extractColumnRefsFromExpr(expr ast.ExprNode, keyspace, table string) {
+ switch ex := expr.(type) {
+ case *ast.BinaryExpr:
+ e.addPredicateColumnsFromExpr(ex.Left, keyspace, table)
+ case *ast.InExpr:
+ e.addPredicateColumnsFromExpr(ex.Column, keyspace, table)
+ case *ast.ContainsExpr:
+ e.addPredicateColumnsFromExpr(ex.Column, keyspace, table)
+ case *ast.TupleInExpr:
+ for _, col := range ex.Columns {
+ e.addPredicateColumnsFromExpr(col, keyspace, table)
}
-
- // Add to PredicateColumns only (SourceColumns tracks tables, not columns)
- e.querySpan.PredicateColumns[colResource] = true
- }
-
- // TODO: Handle more complex cases:
- // - Functions containing columns (e.g., token(column))
- // - Collection operations (e.g., collection CONTAINS value)
- // - Nested expressions
-}
-
-// EnterInsert is called when we enter an INSERT statement
-func (e *querySpanExtractor) EnterInsert(ctx *cql.InsertContext) {
- if e.err != nil {
- return
- }
- // Set query type to DML for INSERT
- e.querySpan.Type = base.DML
-
- // Extract table from INSERT INTO clause
- keyspace := e.defaultKeyspace
- table := ""
-
- if ctx.Keyspace() != nil {
- keyspace = unquoteIdentifier(ctx.Keyspace().GetText())
- }
- if ctx.Table() != nil {
- table = unquoteIdentifier(ctx.Table().GetText())
- }
-
- if table != "" {
- e.querySpan.SourceColumns[base.ColumnResource{
- Database: keyspace,
- Table: table,
- Column: "",
- }] = true
+ case *ast.TupleCompareExpr:
+ for _, col := range ex.Columns {
+ e.addPredicateColumnsFromExpr(col, keyspace, table)
+ }
+ default:
}
}
-// EnterUpdate is called when we enter an UPDATE statement
-func (e *querySpanExtractor) EnterUpdate(ctx *cql.UpdateContext) {
- if e.err != nil {
- return
- }
- // Set query type to DML for UPDATE
- e.querySpan.Type = base.DML
-
- // Extract table from UPDATE clause
- keyspace := e.defaultKeyspace
- table := ""
-
- if ctx.Keyspace() != nil {
- keyspace = unquoteIdentifier(ctx.Keyspace().GetText())
- }
- if ctx.Table() != nil {
- table = unquoteIdentifier(ctx.Table().GetText())
- }
-
- if table != "" {
- e.querySpan.SourceColumns[base.ColumnResource{
+func (e *querySpanExtractor) addPredicateColumnsFromExpr(expr ast.ExprNode, keyspace, table string) {
+ for _, name := range collectColumnNames(expr) {
+ e.querySpan.PredicateColumns[base.ColumnResource{
Database: keyspace,
Table: table,
- Column: "",
+ Column: name,
}] = true
}
-
- // Extract WHERE clause columns for UPDATE
- if ctx.WhereSpec() != nil {
- e.extractWhereColumns(ctx.WhereSpec(), keyspace, table)
- }
}
-// EnterDelete_ is called when we enter a DELETE statement
-func (e *querySpanExtractor) EnterDelete_(ctx *cql.Delete_Context) {
- if e.err != nil {
- return
- }
- // Set query type to DML for DELETE
- e.querySpan.Type = base.DML
-
- // Extract table from DELETE FROM clause
- keyspace := e.defaultKeyspace
- table := ""
- if ctx.FromSpec() != nil {
- ks, t := e.extractTableFromFromSpec(ctx.FromSpec())
- if ks != "" {
- keyspace = ks
+func collectColumnNames(expr ast.ExprNode) []string {
+ switch e := expr.(type) {
+ case *ast.Identifier:
+ return []string{e.Name}
+ case *ast.DotAccess:
+ var names []string
+ names = append(names, collectColumnNames(e.Object)...)
+ if e.Field != nil {
+ names = append(names, e.Field.Name)
}
- table = t
- }
-
- if table != "" {
- e.querySpan.SourceColumns[base.ColumnResource{
- Database: keyspace,
- Table: table,
- Column: "",
- }] = true
- }
-
- // Extract WHERE clause columns for DELETE
- if ctx.WhereSpec() != nil {
- e.extractWhereColumns(ctx.WhereSpec(), keyspace, table)
- }
-}
-
-// DDL Statement Handlers
-
-// EnterCreateTable is called when we enter a CREATE TABLE statement
-func (e *querySpanExtractor) EnterCreateTable(_ *cql.CreateTableContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterAlterTable is called when we enter an ALTER TABLE statement
-func (e *querySpanExtractor) EnterAlterTable(_ *cql.AlterTableContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterDropTable is called when we enter a DROP TABLE statement
-func (e *querySpanExtractor) EnterDropTable(_ *cql.DropTableContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterCreateKeyspace is called when we enter a CREATE KEYSPACE statement
-func (e *querySpanExtractor) EnterCreateKeyspace(_ *cql.CreateKeyspaceContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterAlterKeyspace is called when we enter an ALTER KEYSPACE statement
-func (e *querySpanExtractor) EnterAlterKeyspace(_ *cql.AlterKeyspaceContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterDropKeyspace is called when we enter a DROP KEYSPACE statement
-func (e *querySpanExtractor) EnterDropKeyspace(_ *cql.DropKeyspaceContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterCreateIndex is called when we enter a CREATE INDEX statement
-func (e *querySpanExtractor) EnterCreateIndex(_ *cql.CreateIndexContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterDropIndex is called when we enter a DROP INDEX statement
-func (e *querySpanExtractor) EnterDropIndex(_ *cql.DropIndexContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterCreateMaterializedView is called when we enter a CREATE MATERIALIZED VIEW statement
-func (e *querySpanExtractor) EnterCreateMaterializedView(_ *cql.CreateMaterializedViewContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterAlterMaterializedView is called when we enter an ALTER MATERIALIZED VIEW statement
-func (e *querySpanExtractor) EnterAlterMaterializedView(_ *cql.AlterMaterializedViewContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterDropMaterializedView is called when we enter a DROP MATERIALIZED VIEW statement
-func (e *querySpanExtractor) EnterDropMaterializedView(_ *cql.DropMaterializedViewContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterCreateType is called when we enter a CREATE TYPE statement
-func (e *querySpanExtractor) EnterCreateType(_ *cql.CreateTypeContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterAlterType is called when we enter an ALTER TYPE statement
-func (e *querySpanExtractor) EnterAlterType(_ *cql.AlterTypeContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterDropType is called when we enter a DROP TYPE statement
-func (e *querySpanExtractor) EnterDropType(_ *cql.DropTypeContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterCreateFunction is called when we enter a CREATE FUNCTION statement
-func (e *querySpanExtractor) EnterCreateFunction(_ *cql.CreateFunctionContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterDropFunction is called when we enter a DROP FUNCTION statement
-func (e *querySpanExtractor) EnterDropFunction(_ *cql.DropFunctionContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterCreateTrigger is called when we enter a CREATE TRIGGER statement
-func (e *querySpanExtractor) EnterCreateTrigger(_ *cql.CreateTriggerContext) {
- if e.err != nil {
- return
- }
- e.querySpan.Type = base.DDL
-}
-
-// EnterDropTrigger is called when we enter a DROP TRIGGER statement
-func (e *querySpanExtractor) EnterDropTrigger(_ *cql.DropTriggerContext) {
- if e.err != nil {
- return
+ return names
+ case *ast.FunctionCall:
+ var names []string
+ for _, arg := range e.Args {
+ names = append(names, collectColumnNames(arg)...)
+ }
+ return names
+ default:
+ return nil
}
- e.querySpan.Type = base.DDL
}
diff --git a/backend/plugin/parser/cassandra/query_span_test.go b/backend/plugin/parser/cassandra/query_span_test.go
index 96746e7c0b..989117d7cf 100644
--- a/backend/plugin/parser/cassandra/query_span_test.go
+++ b/backend/plugin/parser/cassandra/query_span_test.go
@@ -235,7 +235,6 @@ func TestGetQuerySpan(t *testing.T) {
require.NoError(t, err)
require.NotNil(t, got)
- // Check Type field
require.Equal(t, tt.want.Type, got.Type, "Query type mismatch")
// Check Results length
@@ -391,6 +390,24 @@ func TestWhereColumnExtraction(t *testing.T) {
},
expectedTable: "products",
},
+ {
+ name: "WHERE with tuple IN expression",
+ statement: "SELECT * FROM users WHERE (id, name) IN ((1, 'a'), (2, 'b'))",
+ expectedPredicateColumns: []base.ColumnResource{
+ {Database: "test_keyspace", Table: "users", Column: "id"},
+ {Database: "test_keyspace", Table: "users", Column: "name"},
+ },
+ expectedTable: "users",
+ },
+ {
+ name: "WHERE with dot access (UDT field)",
+ statement: "SELECT * FROM users WHERE addr.city = 'x'",
+ expectedPredicateColumns: []base.ColumnResource{
+ {Database: "test_keyspace", Table: "users", Column: "addr"},
+ {Database: "test_keyspace", Table: "users", Column: "city"},
+ },
+ expectedTable: "users",
+ },
}
for _, tt := range tests {
@@ -612,7 +629,7 @@ func TestQueryTypeDetection(t *testing.T) {
// DDL - Trigger operations
{
name: "CREATE TRIGGER statement",
- statement: "CREATE TRIGGER mytrigger USING 'org.apache.cassandra.triggers.AuditTrigger'",
+ statement: "CREATE TRIGGER mytrigger ON users USING 'org.apache.cassandra.triggers.AuditTrigger'",
expectedType: base.DDL,
},
{
@@ -635,6 +652,27 @@ func TestQueryTypeDetection(t *testing.T) {
}
}
+func TestSelectUnaliasedExprPreservesResultSlots(t *testing.T) {
+ ctx := context.Background()
+ gCtx := base.GetQuerySpanContext{}
+
+ got, err := GetQuerySpan(ctx, gCtx, base.Statement{Text: "SELECT WRITETIME(name), secret FROM users"}, "test_keyspace", "", false)
+ require.NoError(t, err)
+ require.NotNil(t, got)
+ require.Equal(t, base.Select, got.Type)
+ require.Len(t, got.Results, 2, "result list must have one slot per select element")
+
+ require.Equal(t, "", got.Results[0].Name)
+ require.Empty(t, got.Results[0].SourceColumns)
+
+ require.Equal(t, "secret", got.Results[1].Name)
+ require.Contains(t, got.Results[1].SourceColumns, base.ColumnResource{
+ Database: "test_keyspace",
+ Table: "users",
+ Column: "secret",
+ })
+}
+
func TestSelectAsteriskWithMetadata(t *testing.T) {
tests := []struct {
name string
diff --git a/backend/plugin/parser/cassandra/split.go b/backend/plugin/parser/cassandra/split.go
index 411cbc257c..a0eb72917a 100644
--- a/backend/plugin/parser/cassandra/split.go
+++ b/backend/plugin/parser/cassandra/split.go
@@ -1,8 +1,9 @@
package cassandra
import (
- "github.com/antlr4-go/antlr/v4"
- "github.com/bytebase/parser/cql"
+ "strings"
+
+ omnicassandra "github.com/bytebase/omni/cassandra"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
@@ -12,11 +13,47 @@ func init() {
base.RegisterSplitterFunc(storepb.Engine_CASSANDRA, SplitSQL)
}
-// SplitSQL splits the input into multiple CQL statements using semicolon as delimiter.
func SplitSQL(statement string) ([]base.Statement, error) {
- lexer := cql.NewCqlLexer(antlr.NewInputStream(statement))
- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
- stream.Fill()
+ segments := omnicassandra.Split(statement)
+
+ positionMapper := base.NewByteOffsetPositionMapper(statement)
+ result := make([]base.Statement, 0, len(segments))
+ for _, seg := range segments {
+ empty := seg.Empty || isCommentOnly(seg.Text)
+ result = append(result, base.Statement{
+ Text: seg.Text,
+ Empty: empty,
+ Start: positionMapper.Position(seg.ByteStart),
+ End: positionMapper.Position(seg.ByteEnd),
+ Range: &storepb.Range{
+ Start: int32(seg.ByteStart),
+ End: int32(seg.ByteEnd),
+ },
+ })
+ }
+ return result, nil
+}
- return base.SplitSQLByLexer(stream, cql.CqlLexerSEMI)
+func isCommentOnly(text string) bool {
+ s := text
+ for len(s) > 0 {
+ if s[0] == ' ' || s[0] == '\t' || s[0] == '\n' || s[0] == '\r' {
+ s = s[1:]
+ } else if strings.HasPrefix(s, "--") {
+ if idx := strings.IndexByte(s, '\n'); idx >= 0 {
+ s = s[idx+1:]
+ } else {
+ return true
+ }
+ } else if strings.HasPrefix(s, "/*") {
+ if idx := strings.Index(s, "*/"); idx >= 0 {
+ s = s[idx+2:]
+ } else {
+ return true
+ }
+ } else {
+ return false
+ }
+ }
+ return true
}
diff --git a/backend/plugin/parser/cassandra/test-data/test_split.yaml b/backend/plugin/parser/cassandra/test-data/test_split.yaml
index 60ded7187e..71795b58ae 100644
--- a/backend/plugin/parser/cassandra/test-data/test_split.yaml
+++ b/backend/plugin/parser/cassandra/test-data/test_split.yaml
@@ -1,111 +1,111 @@
- description: multiple statements on multiple lines
input: "SELECT * FROM users;\n\tSELECT * FROM orders;\n\tSELECT * FROM products;"
result:
- - text: SELECT * FROM users;
+ - text: SELECT * FROM users
baseline: 0
start:
line: 1
column: 1
end:
line: 1
- column: 21
+ column: 20
range:
start: 0
- end: 20
+ end: 19
empty: false
- - text: "\n\tSELECT * FROM orders;"
- baseline: 0
+ - text: SELECT * FROM orders
+ baseline: 1
start:
- line: 1
- column: 21
+ line: 2
+ column: 2
end:
line: 2
- column: 23
+ column: 22
range:
- start: 20
- end: 43
+ start: 22
+ end: 42
empty: false
- - text: "\n\tSELECT * FROM products;"
- baseline: 1
+ - text: SELECT * FROM products
+ baseline: 2
start:
- line: 2
- column: 23
+ line: 3
+ column: 2
end:
line: 3
- column: 25
+ column: 24
range:
- start: 43
- end: 68
+ start: 45
+ end: 67
empty: false
- description: single statement
input: SELECT * FROM users;
result:
- - text: SELECT * FROM users;
+ - text: SELECT * FROM users
baseline: 0
start:
line: 1
column: 1
end:
line: 1
- column: 21
+ column: 20
range:
start: 0
- end: 20
+ end: 19
empty: false
- description: 'position semantic: leading newlines'
input: "\n\nSELECT 1;"
result:
- - text: "\n\nSELECT 1;"
- baseline: 0
+ - text: SELECT 1
+ baseline: 2
start:
- line: 1
+ line: 3
column: 1
end:
line: 3
- column: 10
+ column: 9
range:
- start: 0
- end: 11
+ start: 2
+ end: 10
empty: false
- description: 'position semantic: leading spaces and newlines'
input: "\n \n SELECT 1;"
result:
- - text: "\n \n SELECT 1;"
- baseline: 0
+ - text: SELECT 1
+ baseline: 2
start:
- line: 1
- column: 1
+ line: 3
+ column: 3
end:
line: 3
- column: 12
+ column: 11
range:
- start: 0
- end: 15
+ start: 6
+ end: 14
empty: false
- description: 'position semantic: multi-statement with leading whitespace'
input: "SELECT 1;\n\n SELECT 2;"
result:
- - text: SELECT 1;
+ - text: SELECT 1
baseline: 0
start:
line: 1
column: 1
end:
line: 1
- column: 10
+ column: 9
range:
start: 0
- end: 9
+ end: 8
empty: false
- - text: "\n\n SELECT 2;"
- baseline: 0
+ - text: SELECT 2
+ baseline: 2
start:
- line: 1
- column: 10
+ line: 3
+ column: 3
end:
line: 3
- column: 12
+ column: 11
range:
- start: 9
- end: 22
+ start: 13
+ end: 21
empty: false
diff --git a/go.mod b/go.mod
index d174183a8d..bd0886964b 100644
--- a/go.mod
+++ b/go.mod
@@ -34,7 +34,7 @@ require (
github.com/bmatcuk/doublestar/v4 v4.10.0
github.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0
- github.com/bytebase/omni v0.0.0-20260618070256-8f57f04f5aa2
+ github.com/bytebase/omni v0.0.0-20260623064756-28c5d24052f2
github.com/caarlos0/env/v11 v11.4.1
github.com/cenkalti/backoff/v5 v5.0.3
github.com/cockroachdb/cockroachdb-parser v0.25.2
diff --git a/go.sum b/go.sum
index 497ce50b5d..e7648bf2c3 100644
--- a/go.sum
+++ b/go.sum
@@ -250,8 +250,8 @@ github.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352 h1:3sC5pdvJ7bNAhR
github.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352/go.mod h1:eyWrxE51HCbjGIChvty/mYaNcAroXshnIiR6SIqlxfY=
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-20260618070256-8f57f04f5aa2 h1:DHoqAOglW5+OyeKujkZamgwKidFMSiQANICOofJ0bWA=
-github.com/bytebase/omni v0.0.0-20260618070256-8f57f04f5aa2/go.mod h1:Gp5RN3FM07f9/FFOTZCeu8duTAIMeuinkjjBCrs2Dw4=
+github.com/bytebase/omni v0.0.0-20260623064756-28c5d24052f2 h1:ePr1uVqQrIJRFkKTWNdz3noiHD15sxrf8R/qLr1K1sg=
+github.com/bytebase/omni v0.0.0-20260623064756-28c5d24052f2/go.mod h1:Gp5RN3FM07f9/FFOTZCeu8duTAIMeuinkjjBCrs2Dw4=
github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640 h1:g4Jed1/Jv/DHBiQmEgN5ILOQDDBjFlG4N4Lp+3B4aYE=
github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640/go.mod h1:jeak/EfutSOAuWKvrFIT2IZunhWprM7oTFBRgZ9RCxo=
github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=