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: migrate Trino parser to return list of ParseResults (#18180)
h3n4l5fd6fc3ef0f8
diff --git a/backend/plugin/parser/trino/parser_test.go b/backend/plugin/parser/trino/parser_test.goindex 16255f5105..f9e45233aa 100644--- a/backend/plugin/parser/trino/parser_test.go+++ b/backend/plugin/parser/trino/parser_test.go@@ -15,30 +15,33 @@ func TestTrinoParser(t *testing.T) {// Simple query parsing testsql := "SELECT a.id, b.name FROM table1 a JOIN table2 b ON a.id = b.id"- result, err := ParseTrino(sql)+ results, err := ParseTrino(sql)require.NoError(t, err, "Failed to parse valid SQL")- require.NotNil(t, result.Tree, "Parse tree should not be nil")+ require.Len(t, results, 1, "Should parse exactly one statement")+ require.NotNil(t, results[0].Tree, "Parse tree should not be nil")// Verify statement type- stmtType := GetStatementType(result.Tree)+ stmtType := GetStatementType(results[0].Tree)assert.Equal(t, Select, stmtType, "Statement should be recognized as SELECT")// Verify the statement is read-only- isReadOnly := IsReadOnlyStatement(result.Tree)+ isReadOnly := IsReadOnlyStatement(results[0].Tree)assert.True(t, isReadOnly, "SELECT statement should be read-only")// Test data-changing statement detectionsqlDML := "INSERT INTO users (id, name) VALUES (1, 'John')"- resultDML, err := ParseTrino(sqlDML)+ resultsDML, err := ParseTrino(sqlDML)require.NoError(t, err)- isDML := IsDataChangingStatement(resultDML.Tree)+ require.Len(t, resultsDML, 1)+ isDML := IsDataChangingStatement(resultsDML[0].Tree)assert.True(t, isDML, "INSERT statement should be data-changing")// Test schema-changing statement detectionsqlDDL := "CREATE TABLE test (id INT, name VARCHAR)"- resultDDL, err := ParseTrino(sqlDDL)+ resultsDDL, err := ParseTrino(sqlDDL)require.NoError(t, err)- isDDL := IsSchemaChangingStatement(resultDDL.Tree)+ require.Len(t, resultsDDL, 1)+ isDDL := IsSchemaChangingStatement(resultsDDL[0].Tree)assert.True(t, isDDL, "CREATE TABLE should be schema-changing")}@@ -91,10 +94,11 @@ func TestTrinoQueryType(t *testing.T) {for _, tc := range testCases {t.Run(tc.sql, func(t *testing.T) {- result, err := ParseTrino(tc.sql)+ results, err := ParseTrino(tc.sql)require.NoError(t, err)+ require.Len(t, results, 1)- queryType, _ := getQueryType(result.Tree)+ queryType, _ := getQueryType(results[0].Tree)assert.Equal(t, tc.expected, queryType)})}diff --git a/backend/plugin/parser/trino/query.go b/backend/plugin/parser/trino/query.goindex a1c5589270..face169e87 100644--- a/backend/plugin/parser/trino/query.go+++ b/backend/plugin/parser/trino/query.go@@ -11,32 +11,55 @@ func init() {// validateQuery validates if the given SQL statement is valid for SQL editor.// We only allow read-only queries in the SQL editor.+// Returns (canRunInReadOnly, returnsData, error):+// - canRunInReadOnly: whether all queries can run in read-only mode+// - returnsData: whether all queries return data+// - error: parsing error if the statement is invalidfunc validateQuery(statement string) (bool, bool, error) {- result, err := ParseTrino(statement)+ parseResults, err := ParseTrino(statement)if err != nil {return false, false, err}- queryType, isAnalyze := getQueryType(result.Tree)+ allReadOnly := true+ allReturnData := true- // If it's an EXPLAIN ANALYZE, the query will be executed- if isAnalyze {- // Only allow EXPLAIN ANALYZE for SELECT statements- if queryType == base.Select {- return true, true, nil+ // Validate each statement+ for _, result := range parseResults {+ queryType, isAnalyze := getQueryType(result.Tree)++ // If it's an EXPLAIN ANALYZE, the query will be executed+ if isAnalyze {+ // Only allow EXPLAIN ANALYZE for SELECT statements+ if queryType != base.Select {+ return false, false, nil+ }+ // EXPLAIN ANALYZE SELECT is read-only and returns data+ continue}- return false, false, nil- }- // Determine if the statement is read-only- readOnly := queryType == base.Select ||- queryType == base.Explain ||- queryType == base.SelectInfoSchema+ // Determine if the statement is read-only+ readOnly := queryType == base.Select ||+ queryType == base.Explain ||+ queryType == base.SelectInfoSchema++ // Determine if the statement returns data+ returnsData := queryType == base.Select ||+ queryType == base.Explain ||+ queryType == base.SelectInfoSchema++ if !readOnly {+ allReadOnly = false+ }+ if !returnsData {+ allReturnData = false+ }- // Determine if the statement returns data- returnsData := queryType == base.Select ||- queryType == base.Explain ||- queryType == base.SelectInfoSchema+ // If any statement fails validation, return immediately+ if !allReadOnly {+ break+ }+ }- return readOnly, returnsData, nil+ return allReadOnly, allReturnData, nil}diff --git a/backend/plugin/parser/trino/query_span_extractor.go b/backend/plugin/parser/trino/query_span_extractor.goindex f793787a63..f89520dd87 100644--- a/backend/plugin/parser/trino/query_span_extractor.go+++ b/backend/plugin/parser/trino/query_span_extractor.go@@ -66,11 +66,18 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string)q.ctes = []*base.PseudoTable{}// Parse the statement- result, err := ParseTrino(statement)+ parseResults, err := ParseTrino(statement)if err != nil {return nil, errors.Wrapf(err, "failed to parse Trino statement")}+ // Query span extraction expects exactly one statement+ if len(parseResults) != 1 {+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(parseResults))+ }++ result := parseResults[0]+if result.Tree == nil {return nil, errors.New("failed to parse Trino statement, no parse tree found")}diff --git a/backend/plugin/parser/trino/query_type_test.go b/backend/plugin/parser/trino/query_type_test.goindex 13fd4c6777..4968621d9d 100644--- a/backend/plugin/parser/trino/query_type_test.go+++ b/backend/plugin/parser/trino/query_type_test.go@@ -191,8 +191,11 @@ func TestGetStatementType(t *testing.T) {for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {// Parse the statement- result, err := ParseTrino(tt.sql)+ results, err := ParseTrino(tt.sql)require.NoError(t, err, "Parsing should not fail")+ require.Len(t, results, 1, "Should parse exactly one statement")++ result := results[0]// Test GetStatementTypestmtType := GetStatementType(result.Tree)diff --git a/backend/plugin/parser/trino/split.go b/backend/plugin/parser/trino/split.goindex 3f72b9d64e..1b93cfc313 100644--- a/backend/plugin/parser/trino/split.go+++ b/backend/plugin/parser/trino/split.go@@ -151,11 +151,17 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {continue}- // Find the actual start position (first non-hidden token)+ // Find the actual start positionstartIdx := startToken.GetTokenIndex()endIdx := stopToken.GetTokenIndex()- // Find the first non-hidden token for accurate start position+ // Get the first token (any channel) for baseLine calculation+ // This is important because when ANTLR reparses fragments, it sees ALL tokens+ // including comments on hidden channels, so baseLine must be from the first token+ // of any channel for correct error position mapping: originalLine = antlrLine + baseLine+ firstToken := tokens[startIdx]++ // Find the first non-hidden token for accurate start position displayvar firstDefaultToken antlr.Tokenfor i := startIdx; i <= endIdx && i < len(tokens); i++ {if tokens[i].GetChannel() == antlr.TokenDefaultChannel {@@ -184,7 +190,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {result = append(result, base.SingleSQL{Text: text,- BaseLine: firstDefaultToken.GetLine() - 1,+ BaseLine: firstToken.GetLine() - 1,Start: &storepb.Position{Line: int32(firstDefaultToken.GetLine() - 1),Column: int32(firstDefaultToken.GetColumn()),diff --git a/backend/plugin/parser/trino/trino.go b/backend/plugin/parser/trino/trino.goindex c7f09e6c97..989f75373c 100644--- a/backend/plugin/parser/trino/trino.go+++ b/backend/plugin/parser/trino/trino.go@@ -7,18 +7,44 @@ import ("github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/trino"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/plugin/parser/base")// ParseResult is the result of parsing a Trino statement.type ParseResult struct {- Tree antlr.Tree- Tokens *antlr.CommonTokenStream+ Tree antlr.Tree+ Tokens *antlr.CommonTokenStream+ BaseLine int}-// ParseTrino parses the given SQL and returns the ParseResult.-func ParseTrino(sql string) (*ParseResult, error) {+// ParseTrino parses the given SQL statement and returns a list of ParseResults.+// Each ParseResult represents one statement with its AST, tokens, and base line offset.+func ParseTrino(sql string) ([]*ParseResult, error) {+ stmts, err := SplitSQL(sql)+ if err != nil {+ return nil, errors.Wrap(err, "failed to split SQL")+ }++ var results []*ParseResult+ for _, stmt := range stmts {+ if stmt.Empty {+ continue+ }++ parseResult, err := parseSingleTrino(stmt.Text, stmt.BaseLine)+ if err != nil {+ return nil, err+ }+ results = append(results, parseResult)+ }++ return results, nil+}++// parseSingleTrino parses a single Trino statement and returns the ParseResult.+func parseSingleTrino(sql string, baseLine int) (*ParseResult, error) {// Add a semicolon if it's missing to allow users to omit the semicolontrimmedSQL := strings.TrimRightFunc(sql, unicode.IsSpace)if len(trimmedSQL) > 0 && !strings.HasSuffix(trimmedSQL, ";") {@@ -59,8 +85,9 @@ func ParseTrino(sql string) (*ParseResult, error) {// Return the parse resultreturn &ParseResult{- Tree: tree,- Tokens: stream,+ Tree: tree,+ Tokens: stream,+ BaseLine: baseLine,}, nil}