Skip to content

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

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.go
index 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 test
sql := "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 detection
sqlDML := "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 detection
sqlDDL := "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.go
index 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 invalid
func 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.go
index 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.go
index 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 GetStatementType
stmtType := GetStatementType(result.Tree)
diff --git a/backend/plugin/parser/trino/split.go b/backend/plugin/parser/trino/split.go
index 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 position
startIdx := 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 display
var firstDefaultToken antlr.Token
for 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.go
index 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 semicolon
trimmedSQL := 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 result
return &ParseResult{
- Tree: tree,
- Tokens: stream,
+ Tree: tree,
+ Tokens: stream,
+ BaseLine: baseLine,
}, nil
}