Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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 treeextractor := newQuerySpanExtractor(database, gCtx)antlr.ParseTreeWalkerDefault.Walk(extractor, tree)diff --git a/backend/plugin/parser/cassandra/split.go b/backend/plugin/parser/cassandra/split.goindex 28ba612625..2a44a40467 100644--- a/backend/plugin/parser/cassandra/split.go+++ b/backend/plugin/parser/cassandra/split.go@@ -1,9 +1,12 @@package cassandraimport (+ "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.gonew file mode 100644index 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))+ })+ }+}