Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.goindex ba41c26571..044cbf2616 100644--- a/backend/plugin/parser/cassandra/cassandra.go+++ b/backend/plugin/parser/cassandra/cassandra.go@@ -1,115 +1,67 @@package cassandraimport (- "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 positionsstmts, 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 ASTvar 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.ANTLRASTfor _, 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.goindex 443c13d3ed..99bd9d7def 100644--- a/backend/plugin/parser/cassandra/cassandra_test.go+++ b/backend/plugin/parser/cassandra/cassandra_test.go@@ -1,6 +1,7 @@package cassandraimport (+ "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 stringstatement 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 fieldsfor 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 stringstatement 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.gonew file mode 100644index 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.goindex bb604d05bb..f2c96b8087 100644--- a/backend/plugin/parser/cassandra/query_span.go+++ b/backend/plugin/parser/cassandra/query_span.go@@ -3,7 +3,6 @@ package cassandraimport ("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 treeextractor := 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.goindex 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 cassandraimport ("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 informationtype querySpanExtractor struct {- *cql.BaseCqlParserListener-- // Contextctx context.ContextdefaultKeyspace stringgCtx 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 resultsfunc (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 TSQLreturn []base.QuerySpanResult{{- Name: "",SourceColumns: base.SourceColumnSet{},SelectAsterisk: true,}}}- // Find table and expand columnsvar 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 flagreturn []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.goindex 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 fieldrequire.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 stringdiff --git a/backend/plugin/parser/cassandra/split.go b/backend/plugin/parser/cassandra/split.goindex 411cbc257c..a0eb72917a 100644--- a/backend/plugin/parser/cassandra/split.go+++ b/backend/plugin/parser/cassandra/split.go@@ -1,8 +1,9 @@package cassandraimport (- "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.yamlindex 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 linesinput: "SELECT * FROM users;\n\tSELECT * FROM orders;\n\tSELECT * FROM products;"result:- - text: SELECT * FROM users;+ - text: SELECT * FROM usersbaseline: 0start:line: 1column: 1end:line: 1- column: 21+ column: 20range:start: 0- end: 20+ end: 19empty: false- - text: "\n\tSELECT * FROM orders;"- baseline: 0+ - text: SELECT * FROM orders+ baseline: 1start:- line: 1- column: 21+ line: 2+ column: 2end:line: 2- column: 23+ column: 22range:- start: 20- end: 43+ start: 22+ end: 42empty: false- - text: "\n\tSELECT * FROM products;"- baseline: 1+ - text: SELECT * FROM products+ baseline: 2start:- line: 2- column: 23+ line: 3+ column: 2end:line: 3- column: 25+ column: 24range:- start: 43- end: 68+ start: 45+ end: 67empty: false- description: single statementinput: SELECT * FROM users;result:- - text: SELECT * FROM users;+ - text: SELECT * FROM usersbaseline: 0start:line: 1column: 1end:line: 1- column: 21+ column: 20range:start: 0- end: 20+ end: 19empty: false- description: 'position semantic: leading newlines'input: "\n\nSELECT 1;"result:- - text: "\n\nSELECT 1;"- baseline: 0+ - text: SELECT 1+ baseline: 2start:- line: 1+ line: 3column: 1end:line: 3- column: 10+ column: 9range:- start: 0- end: 11+ start: 2+ end: 10empty: 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: 2start:- line: 1- column: 1+ line: 3+ column: 3end:line: 3- column: 12+ column: 11range:- start: 0- end: 15+ start: 6+ end: 14empty: false- description: 'position semantic: multi-statement with leading whitespace'input: "SELECT 1;\n\n SELECT 2;"result:- - text: SELECT 1;+ - text: SELECT 1baseline: 0start:line: 1column: 1end:line: 1- column: 10+ column: 9range:start: 0- end: 9+ end: 8empty: false- - text: "\n\n SELECT 2;"- baseline: 0+ - text: SELECT 2+ baseline: 2start:- line: 1- column: 10+ line: 3+ column: 3end:line: 3- column: 12+ column: 11range:- start: 9- end: 22+ start: 13+ end: 21empty: falsediff --git a/go.mod b/go.modindex d174183a8d..bd0886964b 100644--- a/go.mod+++ b/go.mod@@ -34,7 +34,7 @@ require (github.com/bmatcuk/doublestar/v4 v4.10.0github.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352github.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-28c5d24052f2github.com/caarlos0/env/v11 v11.4.1github.com/cenkalti/backoff/v5 v5.0.3github.com/cockroachdb/cockroachdb-parser v0.25.2diff --git a/go.sum b/go.sumindex 497ce50b5d..e7648bf2c3 100644--- a/go.sum+++ b/go.sum@@ -250,8 +250,8 @@ github.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352 h1:3sC5pdvJ7bNAhRgithub.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=