Skip to content

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

refactor(parser/cassandra): change ParseCassandraSQL to return list of AST nodes (#18112)

h3n4lbe962e3725aa
diff --git a/backend/plugin/parser/cassandra/cassandra.go b/backend/plugin/parser/cassandra/cassandra.go
new file mode 100644
index 0000000000..81897dc168
--- /dev/null
+++ b/backend/plugin/parser/cassandra/cassandra.go
@@ -0,0 +1,98 @@
+package cassandra
+
+import (
+ "strings"
+
+ "github.com/antlr4-go/antlr/v4"
+ "github.com/bytebase/parser/cql"
+
+ 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.RegisterParseFunc(storepb.Engine_CASSANDRA, parseCassandraForRegistry)
+}
+
+// parseCassandraForRegistry is the ParseFunc for Cassandra.
+// Returns []*ParseResult on success.
+func parseCassandraForRegistry(statement string) (any, error) {
+ result, err := ParseCassandraSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+ return result, nil
+}
+
+type ParseResult struct {
+ Tree antlr.Tree
+ Tokens *antlr.CommonTokenStream
+ BaseLine int
+}
+
+// ParseCassandraSQL parses the given CQL statement by using antlr4. Returns a list of AST and token stream if no error.
+func ParseCassandraSQL(statement string) ([]*ParseResult, error) {
+ stmts, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ var result []*ParseResult
+ for _, stmt := range stmts {
+ if stmt.Empty {
+ continue
+ }
+
+ parseResult, err := parseSingleCassandraSQL(stmt.Text, stmt.BaseLine)
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, parseResult)
+ }
+
+ return result, nil
+}
+
+func parseSingleCassandraSQL(statement string, baseLine int) (*ParseResult, 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.
+ lexer.RemoveErrorListeners()
+ lexerErrorListener := &base.ParseErrorListener{
+ Statement: statement,
+ BaseLine: baseLine,
+ }
+ lexer.AddErrorListener(lexerErrorListener)
+
+ p.RemoveErrorListeners()
+ parserErrorListener := &base.ParseErrorListener{
+ Statement: statement,
+ BaseLine: baseLine,
+ }
+ 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
+ }
+
+ result := &ParseResult{
+ Tree: tree,
+ Tokens: stream,
+ BaseLine: baseLine,
+ }
+
+ return result, nil
+}
diff --git a/backend/plugin/parser/cassandra/cassandra_test.go b/backend/plugin/parser/cassandra/cassandra_test.go
new file mode 100644
index 0000000000..e6ae1787f2
--- /dev/null
+++ b/backend/plugin/parser/cassandra/cassandra_test.go
@@ -0,0 +1,125 @@
+package cassandra
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestParseCassandraSQL(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ wantStatCount int
+ wantErr bool
+ }{
+ {
+ name: "Single SELECT statement",
+ statement: "SELECT * FROM users;",
+ wantStatCount: 1,
+ wantErr: false,
+ },
+ {
+ name: "Multiple statements",
+ statement: "SELECT * FROM users; SELECT * FROM orders;",
+ wantStatCount: 2,
+ wantErr: false,
+ },
+ {
+ name: "Statement without semicolon",
+ statement: "SELECT * FROM users",
+ wantStatCount: 1,
+ wantErr: false,
+ },
+ {
+ name: "Multiple statements with comments",
+ statement: "-- First query\nSELECT * FROM users;\n-- Second query\nSELECT * FROM orders;",
+ wantStatCount: 2,
+ wantErr: false,
+ },
+ {
+ name: "Empty statement",
+ statement: "",
+ 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);",
+ 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);",
+ wantStatCount: 2,
+ wantErr: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ results, err := ParseCassandraSQL(tt.statement)
+ if tt.wantErr {
+ require.Error(t, err)
+ return
+ }
+ 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)
+ }
+ })
+ }
+}
+
+func TestParseCassandraSQLBaseLine(t *testing.T) {
+ statement := `SELECT * FROM users;
+ SELECT * FROM orders;
+ SELECT * FROM products;`
+ results, err := ParseCassandraSQL(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, results[0].BaseLine)
+ // 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, results[1].BaseLine) // First token after semicolon is still on line 1 (0-indexed)
+ // Third statement
+ assert.Equal(t, 1, results[2].BaseLine)
+}
+
+func TestParseCassandraSQLErrors(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ }{
+ {
+ 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)
+ require.Error(t, err, "Expected error for invalid CQL")
+ })
+ }
+}
diff --git a/backend/plugin/parser/cassandra/query_span.go b/backend/plugin/parser/cassandra/query_span.go
index 224a5cbca3..b4a46b3660 100644
--- a/backend/plugin/parser/cassandra/query_span.go
+++ b/backend/plugin/parser/cassandra/query_span.go
@@ -4,7 +4,7 @@ import (
"context"
"github.com/antlr4-go/antlr/v4"
- "github.com/bytebase/parser/cql"
+ "github.com/pkg/errors"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
@@ -16,32 +16,22 @@ func init() {
// GetQuerySpan extracts the query span from a CQL statement.
func GetQuerySpan(_ context.Context, gCtx base.GetQuerySpanContext, statement, database, _ string, _ bool) (*base.QuerySpan, error) {
- lexer := cql.NewCqlLexer(antlr.NewInputStream(statement))
- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
- p := cql.NewCqlParser(stream)
-
- lexerErrorListener := &base.ParseErrorListener{
- Statement: statement,
- }
- lexer.RemoveErrorListeners()
- lexer.AddErrorListener(lexerErrorListener)
-
- parserErrorListener := &base.ParseErrorListener{
- Statement: statement,
+ parseResults, err := ParseCassandraSQL(statement)
+ if err != nil {
+ return nil, err
}
- p.RemoveErrorListeners()
- p.AddErrorListener(parserErrorListener)
-
- p.BuildParseTrees = true
- tree := p.Root()
-
- if lexerErrorListener.Err != nil {
- return nil, lexerErrorListener.Err
+ if len(parseResults) == 0 {
+ return &base.QuerySpan{
+ SourceColumns: base.SourceColumnSet{},
+ Results: []base.QuerySpanResult{},
+ }, nil
}
- if parserErrorListener.Err != nil {
- return nil, parserErrorListener.Err
+ if len(parseResults) != 1 {
+ return nil, errors.Errorf("expecting only one statement to get query span, but got %d", len(parseResults))
}
+ tree := parseResults[0].Tree
+
// Create extractor and walk the tree
extractor := newQuerySpanExtractor(database, gCtx)
antlr.ParseTreeWalkerDefault.Walk(extractor, tree)
diff --git a/backend/plugin/parser/cassandra/split.go b/backend/plugin/parser/cassandra/split.go
index 28ba612625..2a44a40467 100644
--- a/backend/plugin/parser/cassandra/split.go
+++ b/backend/plugin/parser/cassandra/split.go
@@ -1,9 +1,12 @@
package cassandra
import (
+ "strings"
+
"github.com/antlr4-go/antlr/v4"
"github.com/bytebase/parser/cql"
+ "github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
@@ -12,28 +15,49 @@ func init() {
base.RegisterSplitterFunc(storepb.Engine_CASSANDRA, SplitSQL)
}
-// SplitSQL splits CQL statements into multiple single statements.
+// SplitSQL splits the input into multiple CQL statements using semicolon as delimiter.
func SplitSQL(statement string) ([]base.SingleSQL, error) {
lexer := cql.NewCqlLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
- p := cql.NewCqlParser(stream)
+ stream.Fill()
- p.BuildParseTrees = true
- p.RemoveErrorListeners()
+ tokens := stream.GetAllTokens()
+ var buf []antlr.Token
+ var sqls []base.SingleSQL
- tree := p.Root()
- if tree == nil {
- return nil, nil
- }
+ for i, token := range tokens {
+ if i < len(tokens)-1 {
+ buf = append(buf, token)
+ }
+ if (token.GetTokenType() == cql.CqlLexerSEMI || i == len(tokens)-1) && len(buf) > 0 {
+ bufStr := new(strings.Builder)
+ empty := true
- // For now, return the entire statement as a single SQL
- // CQL typically doesn't support multiple statements in one query
- // unlike SQL databases
- return []base.SingleSQL{
- {
- Text: statement,
- ByteOffsetStart: 0,
- ByteOffsetEnd: len(statement),
- },
- }, nil
+ for _, b := range buf {
+ if _, err := bufStr.WriteString(b.GetText()); err != nil {
+ return nil, err
+ }
+ if b.GetChannel() != antlr.TokenHiddenChannel {
+ empty = false
+ }
+ }
+ antlrPosition := base.FirstDefaultChannelTokenPosition(buf)
+
+ // For the End position, use the current token (semicolon or EOF)
+ // instead of the last token in buf
+ sqls = append(sqls, base.SingleSQL{
+ Text: bufStr.String(),
+ BaseLine: buf[0].GetLine() - 1,
+ End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
+ Line: int32(token.GetLine()),
+ Column: int32(token.GetColumn()),
+ }, statement),
+ Start: common.ConvertANTLRPositionToPosition(antlrPosition, statement),
+ Empty: empty,
+ })
+ buf = nil
+ continue
+ }
+ }
+ return sqls, nil
}
diff --git a/backend/plugin/parser/cassandra/split_test.go b/backend/plugin/parser/cassandra/split_test.go
new file mode 100644
index 0000000000..e844c818a5
--- /dev/null
+++ b/backend/plugin/parser/cassandra/split_test.go
@@ -0,0 +1,134 @@
+package cassandra
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestSplitSQL(t *testing.T) {
+ statement := `SELECT * FROM users;
+ SELECT * FROM orders;
+ SELECT * FROM products;`
+ want := []base.SingleSQL{
+ {
+ Text: "SELECT * FROM users;",
+ BaseLine: 0,
+ Start: &storepb.Position{Line: 1, Column: 1},
+ End: &storepb.Position{Line: 1, Column: 20},
+ Empty: false,
+ },
+ {
+ Text: "\n\tSELECT * FROM orders;",
+ BaseLine: 0,
+ Start: &storepb.Position{Line: 2, Column: 2},
+ End: &storepb.Position{Line: 2, Column: 22},
+ Empty: false,
+ },
+ {
+ Text: "\n\tSELECT * FROM products;",
+ BaseLine: 1,
+ Start: &storepb.Position{Line: 3, Column: 2},
+ End: &storepb.Position{Line: 3, Column: 24},
+ Empty: false,
+ },
+ }
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+ require.Equal(t, want, list)
+}
+
+func TestSplitSQLSingleStatement(t *testing.T) {
+ statement := "SELECT * FROM users;"
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+ require.Equal(t, 1, len(list))
+ require.Equal(t, "SELECT * FROM users;", list[0].Text)
+ require.Equal(t, 0, list[0].BaseLine)
+ require.False(t, list[0].Empty)
+}
+
+func TestSplitSQLEmpty(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ wantCount int
+ }{
+ {
+ name: "Empty string",
+ statement: "",
+ wantCount: 0,
+ },
+ {
+ name: "Only whitespace",
+ statement: " \n \t ",
+ wantCount: 0,
+ },
+ {
+ name: "Only semicolon",
+ statement: ";",
+ wantCount: 1, // Semicolon creates one statement entry
+ },
+ {
+ name: "Only comments and semicolon",
+ statement: "-- comment\n;",
+ wantCount: 1, // Cassandra might count this as one statement
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ list, err := SplitSQL(tt.statement)
+ require.NoError(t, err)
+ // Filter out empty statements
+ nonEmpty := 0
+ for _, sql := range list {
+ if !sql.Empty {
+ nonEmpty++
+ }
+ }
+ require.Equal(t, tt.wantCount, nonEmpty)
+ })
+ }
+}
+
+func TestSplitSQLWithComments(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ wantCount int
+ }{
+ {
+ name: "Statement with trailing comment",
+ statement: "SELECT * FROM users; -- This is a comment\nSELECT * FROM orders;",
+ wantCount: 2,
+ },
+ {
+ name: "Statement with leading comment",
+ statement: "-- Comment at start\nSELECT * FROM users;",
+ wantCount: 1,
+ },
+ {
+ name: "Only comment with semicolon",
+ statement: "-- comment only\n;",
+ wantCount: 1, // Semicolon makes it non-empty
+ },
+ {
+ name: "Multiple statements with comments",
+ statement: "-- First query\nSELECT * FROM users;\n-- Second query\nSELECT * FROM orders;",
+ wantCount: 2,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ list, err := SplitSQL(tt.statement)
+ require.NoError(t, err)
+ require.Equal(t, tt.wantCount, len(list))
+ })
+ }
+}