Skip to content

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

refactor(parser/mysql): migrate SQL split to omni lexical splitter [BYT-9112] (#19838)

rebeliceea38c2c865cf
diff --git a/backend/plugin/parser/mysql/split.go b/backend/plugin/parser/mysql/split.go
index 981a9e7112..c7fc141411 100644
--- a/backend/plugin/parser/mysql/split.go
+++ b/backend/plugin/parser/mysql/split.go
@@ -1,13 +1,8 @@
package mysql
import (
- "log/slog"
+ mysqlparser "github.com/bytebase/omni/mysql/parser"
- "github.com/antlr4-go/antlr/v4"
- parser "github.com/bytebase/parser/mysql"
- "github.com/pkg/errors"
-
- "github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
@@ -19,505 +14,32 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
+// It uses omni's lexical splitter which handles quotes, comments, compound
+// statements (BEGIN...END, IF...END IF, etc.) and DELIMITER without
+// requiring valid SQL.
func SplitSQL(statement string) ([]base.Statement, error) {
- lexer := parser.NewMySQLLexer(antlr.NewInputStream(statement))
- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
-
- list, err := splitMySQLStatement(stream, statement)
- if err != nil {
- slog.Info("failed to split MySQL statement, use parser instead", "statement", statement)
- // Use parser to split statement.
- return splitByParser(statement, lexer, stream)
- }
- return list, nil
-}
-
-func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
- var result []base.Statement
- delimiter := ";"
- tokens := stream.GetAllTokens()
- start := 0
-
- i := 0
- for i < len(tokens) {
- token := tokens[i]
- // Deal with delimiter statement.
- if token.GetChannel() == antlr.TokenDefaultChannel && token.GetTokenType() == parser.MySQLLexerDELIMITER_SYMBOL {
- newStart, delimiterStatement := extractDelimiterStatement(stream, i)
- var err error
- delimiter, err = ExtractDelimiter(delimiterStatement)
- if err != nil {
- return nil, errors.Wrapf(err, "failed to extract delimiter from statement: %s", delimiterStatement)
- }
- start = newStart
- i = newStart
- continue
- }
+ segments := mysqlparser.Split(statement)
- // Deal with normal statement.
- if delimiter == ";" && token.GetTokenType() == parser.MySQLLexerSEMICOLON_SYMBOL {
- stmtText := stream.GetTextFromTokens(tokens[start], tokens[i])
-
- // Calculate byte range by getting actual bytes from original statement
- // This works because for ASCII chars, char offset == byte offset
- // For UTF-8, we get the actual substring which handles multi-byte chars correctly
- stmtStartChar := tokens[start].GetStart()
- stmtEndChar := tokens[i].GetStop() + 1
- stmtStartByte := len(statement[:stmtStartChar])
- stmtEndByte := len(statement[:stmtEndChar])
-
- // Calculate start position from byte offset (first character of Text)
- startLine, startColumn := base.CalculateLineAndColumn(statement, stmtStartByte)
- // From antlr4, the line is ONE based, and the column is ZERO based.
- // So we should minus 1 for the line.
- result = append(result, base.Statement{
- Text: stmtText,
- Range: &storepb.Range{
- Start: int32(stmtStartByte),
- End: int32(stmtEndByte),
- },
- End: common.ConvertANTLRTokenToExclusiveEndPosition(
- int32(tokens[i].GetLine()),
- int32(tokens[i].GetColumn()),
- tokens[i].GetText(),
- ),
- Start: &storepb.Position{
- Line: int32(startLine + 1),
- Column: int32(startColumn + 1),
- },
- Empty: base.IsEmpty(tokens[start:i+1], parser.MySQLLexerSEMICOLON_SYMBOL),
- })
- i++
- start = i
- continue
- }
-
- if token.GetChannel() != antlr.TokenDefaultChannel {
- i++
- continue
+ result := make([]base.Statement, 0, len(segments))
+ for _, seg := range segments {
+ // omni Segment excludes the trailing semicolon, but downstream
+ // code expects it included. Extend the byte range to cover it.
+ byteEnd := seg.ByteEnd
+ if byteEnd < len(statement) && statement[byteEnd] == ';' {
+ byteEnd++
}
+ text := statement[seg.ByteStart:byteEnd]
- if newStart, ok := tryMatchDelimiter(stream, i, delimiter); ok {
- stmtText := stream.GetTextFromTokens(tokens[start], tokens[i-1]) + ";"
-
- // Calculate byte range by getting actual bytes from original statement
- stmtStartChar := tokens[start].GetStart()
- stmtEndChar := tokens[newStart-1].GetStop() + 1
- stmtStartByte := len(statement[:stmtStartChar])
- stmtEndByte := len(statement[:stmtEndChar])
-
- // Calculate start position from byte offset (first character of Text)
- startLine, startColumn := base.CalculateLineAndColumn(statement, stmtStartByte)
- // From antlr4, the line is ONE based, and the column is ZERO based.
- // So we should minus 1 for the line.
- result = append(result, base.Statement{
- // Use a single semicolon instead of the user defined delimiter.
- Text: stmtText,
- Range: &storepb.Range{
- Start: int32(stmtStartByte),
- End: int32(stmtEndByte),
- },
- End: common.ConvertANTLRTokenToExclusiveEndPosition(
- int32(tokens[newStart-1].GetLine()),
- int32(tokens[newStart-1].GetColumn()),
- tokens[newStart-1].GetText(),
- ),
- Start: &storepb.Position{
- Line: int32(startLine + 1),
- Column: int32(startColumn + 1),
- },
- Empty: base.IsEmpty(tokens[start:i], parser.MySQLLexerSEMICOLON_SYMBOL),
- })
- i = newStart
- start = newStart
- continue
- }
-
- i++
- }
-
- endPos := len(tokens) - 1
- if start < endPos {
- stmtText := stream.GetTextFromTokens(tokens[start], tokens[endPos-1])
-
- // Calculate byte range by getting actual bytes from original statement
- stmtStartChar := tokens[start].GetStart()
- stmtEndChar := tokens[endPos-1].GetStop() + 1
- stmtStartByte := len(statement[:stmtStartChar])
- stmtEndByte := len(statement[:stmtEndChar])
-
- // Calculate start position from byte offset (first character of Text)
- startLine, startColumn := base.CalculateLineAndColumn(statement, stmtStartByte)
- // From antlr4, the line is ONE based, and the column is ZERO based.
- // So we should minus 1 for the line.
result = append(result, base.Statement{
- Text: stmtText,
+ Text: text,
+ Empty: seg.Empty(),
+ Start: ByteOffsetToRunePosition(statement, seg.ByteStart),
+ End: ByteOffsetToRunePosition(statement, byteEnd),
Range: &storepb.Range{
- Start: int32(stmtStartByte),
- End: int32(stmtEndByte),
- },
- End: common.ConvertANTLRTokenToExclusiveEndPosition(
- int32(tokens[endPos-1].GetLine()),
- int32(tokens[endPos-1].GetColumn()),
- tokens[endPos-1].GetText(),
- ),
- Start: &storepb.Position{
- Line: int32(startLine + 1),
- Column: int32(startColumn + 1),
+ Start: int32(seg.ByteStart),
+ End: int32(byteEnd),
},
- Empty: base.IsEmpty(tokens[start:endPos], parser.MySQLLexerSEMICOLON_SYMBOL),
})
}
-
return result, nil
}
-
-func tryMatchDelimiter(stream *antlr.CommonTokenStream, pos int, delimiter string) (int, bool) {
- matchPos := 0
- length := len(stream.GetAllTokens())
- for i := pos; i < length; i++ {
- text := stream.GetTextFromInterval(antlr.Interval{Start: i, Stop: i})
- for j := 0; j < len(text); j++ {
- if j+matchPos >= len(delimiter) || text[j] != delimiter[j+matchPos] {
- return 0, false
- }
- matchPos++
- if matchPos == len(delimiter) {
- return i + 1, true
- }
- }
- }
-
- return 0, false
-}
-
-func extractDelimiterStatement(stream *antlr.CommonTokenStream, pos int) (int, string) {
- length := len(stream.GetAllTokens())
- for i := pos; i < length; i++ {
- if (stream.Get(i).GetTokenType() == parser.MySQLLexerWHITESPACE && stream.Get(i).GetText() == "\n") ||
- (stream.Get(i).GetTokenType() == antlr.TokenEOF) {
- return i + 1, stream.GetTextFromTokens(stream.Get(pos), stream.Get(i-1))
- }
- }
-
- // never reach here
- return length, stream.GetTextFromTokens(stream.Get(pos), stream.Get(length-1))
-}
-
-func hasDelimiterStatement(stream *antlr.CommonTokenStream) bool {
- tokens := stream.GetAllTokens()
- for _, token := range tokens {
- if token.GetChannel() == antlr.TokenDefaultChannel && token.GetTokenType() == parser.MySQLLexerDELIMITER_SYMBOL {
- return true
- }
- }
- return false
-}
-
-func splitByParser(statement string, lexer *parser.MySQLLexer, stream *antlr.CommonTokenStream) ([]base.Statement, error) {
- p := parser.NewMySQLParser(stream)
- lexerErrorListener := &base.ParseErrorListener{
- Statement: statement,
- }
- lexer.RemoveErrorListeners()
- lexer.AddErrorListener(lexerErrorListener)
-
- parserErrorListener := &base.ParseErrorListener{
- Statement: statement,
- }
- p.RemoveErrorListeners()
- p.AddErrorListener(parserErrorListener)
-
- p.BuildParseTrees = true
-
- tree := p.Script()
-
- if lexerErrorListener.Err != nil {
- return nil, lexerErrorListener.Err
- }
-
- if parserErrorListener.Err != nil {
- return nil, parserErrorListener.Err
- }
-
- var result []base.Statement
- tokens := stream.GetAllTokens()
-
- byteOffset := 0
- start := 0
- for _, semicolon := range tree.AllSEMICOLON_SYMBOL() {
- pos := semicolon.GetSymbol().GetStart()
- stmtText := stream.GetTextFromTokens(tokens[start], tokens[pos])
- stmtByteLength := len(stmtText)
-
- // Calculate start position from byte offset (first character of Text)
- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)
- // From antlr4, the line is ONE based, and the column is ZERO based.
- // So we should minus 1 for the line.
- result = append(result, base.Statement{
- Text: stmtText,
- Range: &storepb.Range{
- Start: int32(byteOffset),
- End: int32(byteOffset + stmtByteLength),
- },
- End: common.ConvertANTLRTokenToExclusiveEndPosition(
- int32(tokens[pos].GetLine()),
- int32(tokens[pos].GetColumn()),
- tokens[pos].GetText(),
- ),
- Start: &storepb.Position{
- Line: int32(startLine + 1),
- Column: int32(startColumn + 1),
- },
- Empty: base.IsEmpty(tokens[start:pos+1], parser.MySQLLexerSEMICOLON_SYMBOL),
- })
- byteOffset += stmtByteLength
- start = pos + 1
- }
- // For the last statement, it may not end with semicolon symbol, EOF symbol instead.
- eofPos := len(tokens) - 1
- if start < eofPos {
- stmtText := stream.GetTextFromTokens(tokens[start], tokens[eofPos-1])
- stmtByteLength := len(stmtText)
-
- // Calculate start position from byte offset (first character of Text)
- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)
- // From antlr4, the line is ONE based, and the column is ZERO based.
- // So we should minus 1 for the line.
- result = append(result, base.Statement{
- Text: stmtText,
- Range: &storepb.Range{
- Start: int32(byteOffset),
- End: int32(byteOffset + stmtByteLength),
- },
- End: common.ConvertANTLRTokenToExclusiveEndPosition(
- int32(tokens[eofPos-1].GetLine()),
- int32(tokens[eofPos-1].GetColumn()),
- tokens[eofPos-1].GetText(),
- ),
- Start: &storepb.Position{
- Line: int32(startLine + 1),
- Column: int32(startColumn + 1),
- },
- Empty: base.IsEmpty(tokens[start:eofPos], parser.MySQLLexerSEMICOLON_SYMBOL),
- })
- }
- return result, nil
-}
-
-type openParenthesis struct {
- tokenType int
- pos int
-}
-
-func splitMySQLStatement(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
- stream.Fill()
- if hasDelimiterStatement(stream) {
- return splitDelimiterModeSQL(stream, statement)
- }
-
- var result []base.Statement
- tokens := stream.GetAllTokens()
-
- var beginCaseStack, ifStack, loopStack, whileStack, repeatStack []*openParenthesis
-
- var semicolonStack []int
-
- for i, token := range tokens {
- switch token.GetTokenType() {
- case parser.MySQLParserBEGIN_SYMBOL:
- isBeginWork := base.GetDefaultChannelTokenType(tokens, i, 1) == parser.MySQLParserWORK_SYMBOL
- isBeginWork = isBeginWork || (base.GetDefaultChannelTokenType(tokens, i, 1) == parser.MySQLParserSEMICOLON_SYMBOL)
- isBeginWork = isBeginWork || (base.GetDefaultChannelTokenType(tokens, i, 1) == parser.MySQLParserEOF)
- if isBeginWork {
- continue
- }
-
- isXa := base.GetDefaultChannelTokenType(tokens, i, -1) == parser.MySQLParserXA_SYMBOL
- if isXa {
- continue
- }
-
- beginCaseStack = append(beginCaseStack, &openParenthesis{tokenType: tokens[i].GetTokenType(), pos: i})
- case parser.MySQLParserCASE_SYMBOL:
- isEndCase := base.GetDefaultChannelTokenType(tokens, i, -1) == parser.MySQLParserEND_SYMBOL
- if isEndCase {
- continue
- }
-
- beginCaseStack = append(beginCaseStack, &openParenthesis{tokenType: tokens[i].GetTokenType(), pos: i})
- case parser.MySQLParserIF_SYMBOL:
- isEndIf := base.GetDefaultChannelTokenType(tokens, i, -1) == parser.MySQLParserEND_SYMBOL
- if isEndIf {
- continue
- }
-
- isIfExists := base.GetDefaultChannelTokenType(tokens, i, 1) == parser.MySQLParserEXISTS_SYMBOL
- if isIfExists {
- continue
- }
-
- ifStack = append(ifStack, &openParenthesis{tokenType: tokens[i].GetTokenType(), pos: i})
- case parser.MySQLParserLOOP_SYMBOL:
- isEndLoop := base.GetDefaultChannelTokenType(tokens, i, -1) == parser.MySQLParserEND_SYMBOL
- if isEndLoop {
- continue
- }
-
- loopStack = append(loopStack, &openParenthesis{tokenType: tokens[i].GetTokenType(), pos: i})
- case parser.MySQLParserWHILE_SYMBOL:
- isEndWhile := base.GetDefaultChannelTokenType(tokens, i, -1) == parser.MySQLParserEND_SYMBOL
- if isEndWhile {
- continue
- }
-
- whileStack = append(whileStack, &openParenthesis{tokenType: tokens[i].GetTokenType(), pos: i})
- case parser.MySQLParserREPEAT_SYMBOL:
- isEndRepeat := base.GetDefaultChannelTokenType(tokens, i, -1) == parser.MySQLParserUNTIL_SYMBOL
- if isEndRepeat {
- continue
- }
-
- repeatStack = append(repeatStack, &openParenthesis{tokenType: tokens[i].GetTokenType(), pos: i})
- case parser.MySQLParserEND_SYMBOL:
- isXa := base.GetDefaultChannelTokenType(tokens, i, -1) == parser.MySQLParserXA_SYMBOL
- if isXa {
- continue
- }
-
- nextDefaultChannelTokenType := base.GetDefaultChannelTokenType(tokens, i, 1)
- switch nextDefaultChannelTokenType {
- case parser.MySQLParserIF_SYMBOL:
- // There are two types of IF statement:
- // 1. IF(expr1,expr2,expr3)
- // 2. IF search_condition THEN statement_list [ELSEIF search_condition THEN statement_list] ... [ELSE statement_list] END IF
- // For the first type, we will meet single IF symbol without END IF symbol.
- if len(ifStack) == 0 {
- return nil, errors.New("invalid statement: failed to split multiple statements")
- }
- semicolonStack = popSemicolonStack(semicolonStack, ifStack[0].pos)
- ifStack = ifStack[:len(ifStack)-1]
- case parser.MySQLParserLOOP_SYMBOL:
- // For the LOOP symbol, MySQL only has LOOP with END LOOP statement.
- // Other cases are invalid.
- // So we only need to do the simple parenthesis matching.
- if len(loopStack) == 0 {
- return nil, errors.New("invalid statement: failed to split multiple statements")
- }
- semicolonStack = popSemicolonStack(semicolonStack, loopStack[len(loopStack)-1].pos)
- loopStack = loopStack[:len(loopStack)-1]
- case parser.MySQLParserWHILE_SYMBOL:
- // For the WHILE symbol, MySQL only has WHILE with END WHILE statement.
- // Other cases are invalid.
- // So we only need to do the simple parenthesis matching.
- if len(whileStack) == 0 {
- return nil, errors.New("invalid statement: failed to split multiple statements")
- }
- semicolonStack = popSemicolonStack(semicolonStack, whileStack[len(whileStack)-1].pos)
- whileStack = whileStack[:len(whileStack)-1]
- case parser.MySQLParserREPEAT_SYMBOL:
- // The are two types of REPEAT statement:
- // 1. REPEAT(expr,expr)
- // 2. REPEAT statement_list UNTIL search_condition END REPEAT
- // For the first type, we will meet single REPEAT symbol without END REPEAT symbol.
- if len(repeatStack) == 0 {
- return nil, errors.New("invalid statement: failed to split multiple statements")
- }
- semicolonStack = popSemicolonStack(semicolonStack, repeatStack[0].pos)
- repeatStack = repeatStack[:len(repeatStack)-1]
- case parser.MySQLParserCASE_SYMBOL:
- if len(beginCaseStack) == 0 {
- return nil, errors.New("invalid statement: failed to split multiple statements")
- }
- semicolonStack = popSemicolonStack(semicolonStack, beginCaseStack[len(beginCaseStack)-1].pos)
- beginCaseStack = beginCaseStack[:len(beginCaseStack)-1]
- default:
- // is BEGIN ... END or CASE .. END case
- if len(beginCaseStack) == 0 {
- return nil, errors.New("invalid statement: failed to split multiple statements")
- }
- semicolonStack = popSemicolonStack(semicolonStack, beginCaseStack[len(beginCaseStack)-1].pos)
- beginCaseStack = beginCaseStack[:len(beginCaseStack)-1]
- }
- case parser.MySQLParserSEMICOLON_SYMBOL:
- semicolonStack = append(semicolonStack, i)
- default:
- // Do nothing for other token types
- }
- }
-
- byteOffset := 0
- start := 0
- for _, pos := range semicolonStack {
- stmtText := stream.GetTextFromTokens(tokens[start], tokens[pos])
- stmtByteLength := len(stmtText)
-
- // Calculate start position from byte offset (first character of Text)
- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)
- // From antlr4, the line is ONE based, and the column is ZERO based.
- // So we should minus 1 for the line.
- result = append(result, base.Statement{
- Text: stmtText,
- Range: &storepb.Range{
- Start: int32(byteOffset),
- End: int32(byteOffset + stmtByteLength),
- },
- End: common.ConvertANTLRTokenToExclusiveEndPosition(
- int32(tokens[pos].GetLine()),
- int32(tokens[pos].GetColumn()),
- tokens[pos].GetText(),
- ),
- Start: &storepb.Position{
- Line: int32(startLine + 1),
- Column: int32(startColumn + 1),
- },
- Empty: base.IsEmpty(tokens[start:pos+1], parser.MySQLLexerSEMICOLON_SYMBOL),
- })
- byteOffset += stmtByteLength
- start = pos + 1
- }
- // For the last statement, it may not end with semicolon symbol, EOF symbol instead.
- eofPos := len(tokens) - 1
- if start < eofPos {
- stmtText := stream.GetTextFromTokens(tokens[start], tokens[eofPos-1])
- stmtByteLength := len(stmtText)
-
- // Calculate start position from byte offset (first character of Text)
- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)
- // From antlr4, the line is ONE based, and the column is ZERO based.
- // So we should minus 1 for the line.
- result = append(result, base.Statement{
- Text: stmtText,
- Range: &storepb.Range{
- Start: int32(byteOffset),
- End: int32(byteOffset + stmtByteLength),
- },
- End: common.ConvertANTLRTokenToExclusiveEndPosition(
- int32(tokens[eofPos-1].GetLine()),
- int32(tokens[eofPos-1].GetColumn()),
- tokens[eofPos-1].GetText(),
- ),
- Start: &storepb.Position{
- Line: int32(startLine + 1),
- Column: int32(startColumn + 1),
- },
- Empty: base.IsEmpty(tokens[start:eofPos], parser.MySQLLexerSEMICOLON_SYMBOL),
- })
- }
-
- return result, nil
-}
-
-func popSemicolonStack(stack []int, openParPos int) []int {
- if len(stack) == 0 {
- return stack
- }
-
- for i := len(stack) - 1; i >= 0; i-- {
- if stack[i] < openParPos {
- return stack[:i+1]
- }
- }
-
- return []int{}
-}
diff --git a/backend/plugin/parser/mysql/split_test.go b/backend/plugin/parser/mysql/split_test.go
index afd971ae78..2aa8411291 100644
--- a/backend/plugin/parser/mysql/split_test.go
+++ b/backend/plugin/parser/mysql/split_test.go
@@ -3,11 +3,8 @@ package mysql
import (
"testing"
- "github.com/antlr4-go/antlr/v4"
"github.com/stretchr/testify/require"
- parser "github.com/bytebase/parser/mysql"
-
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
@@ -58,9 +55,7 @@ func TestSplitMySQLStatements(t *testing.T) {
}
for _, test := range tests {
- lexer := parser.NewMySQLLexer(antlr.NewInputStream(test.statement))
- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
- list, err := splitMySQLStatement(stream, test.statement)
+ list, err := SplitSQL(test.statement)
require.NoError(t, err)
require.Equal(t, len(test.expected), len(list))
for i, statement := range list {
diff --git a/backend/plugin/parser/mysql/test-data/test_split.yaml b/backend/plugin/parser/mysql/test-data/test_split.yaml
index 84c8204ea0..776071e63b 100644
--- a/backend/plugin/parser/mysql/test-data/test_split.yaml
+++ b/backend/plugin/parser/mysql/test-data/test_split.yaml
@@ -8,10 +8,10 @@
column: 1
end:
line: 9
- column: 9
+ column: 8
range:
start: 16
- end: 174
+ end: 173
empty: false
- text: "\t\t\tCALL dorepeat(1000);"
baseline: 10
@@ -37,18 +37,6 @@
start: 213
end: 226
empty: false
- - text: "\n\t\t\t"
- baseline: 11
- start:
- line: 12
- column: 13
- end:
- line: 13
- column: 4
- range:
- start: 226
- end: 230
- empty: true
- description: escaped double quote in string
input: select * from t;select "\"" where true;
result:
@@ -76,22 +64,10 @@
start: 16
end: 39
empty: false
-- description: comments only creates empty statement
+- description: comments only - empty segments filtered
input: "-- klsjdfjasldf\n\t\t\t-- klsjdflkjaskldfj\n"
- result:
- - text: "-- klsjdfjasldf\n\t\t\t-- klsjdflkjaskldfj\n"
- baseline: 0
- start:
- line: 1
- column: 1
- end:
- line: 2
- column: 24
- range:
- start: 0
- end: 39
- empty: true
-- description: statement followed by trailing block comment
+ result: []
+- description: statement followed by trailing block comment - trailing empty filtered
input: "select * from t;\n\t\t\t/* sdfasdf */"
result:
- text: select * from t;
@@ -106,19 +82,7 @@
start: 0
end: 16
empty: false
- - text: "\n\t\t\t/* sdfasdf */"
- baseline: 0
- start:
- line: 1
- column: 17
- end:
- line: 2
- column: 17
- range:
- start: 16
- end: 33
- empty: true
-- description: statement then empty comment statement then statement
+- description: statement then empty comment statement then statement - middle empty filtered
input: "select * from t;\n\t\t\t/* sdfasdf */;\n\t\t\tselect * from t;"
result:
- text: select * from t;
@@ -133,18 +97,6 @@
start: 0
end: 16
empty: false
- - text: "\n\t\t\t/* sdfasdf */;"
- baseline: 0
- start:
- line: 1
- column: 17
- end:
- line: 2
- column: 18
- range:
- start: 16
- end: 34
- empty: true
- text: "\n\t\t\tselect * from t;"
baseline: 1
start:
@@ -361,18 +313,6 @@
start: 208
end: 225
empty: false
- - text: "\n\t\t\t\t\t\t"
- baseline: 8
- start:
- line: 9
- column: 17
- end:
- line: 10
- column: 7
- range:
- start: 225
- end: 232
- empty: true
- description: procedure with block comment inside
input: "# test for defining stored programs\n\t\t\t\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\t\t\t\t/* This is a comment */\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t\t\tSET @x = 0;\n\t\t\t\t\t\t\tREPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;\n\t\t\t\t\t\tEND\n\t\t\t\t\t\t;\n\t\t\t\t\t\tCALL dorepeat(1000);\n\t\t\t\t\t\tSELECT @x;\n\t\t\t\t\t\t"
result:
@@ -412,18 +352,21 @@
start: 238
end: 255
empty: false
- - text: "\n\t\t\t\t\t\t"
- baseline: 9
+- description: trailing whitespace after last semicolon - empty filtered
+ input: "SELECT 1;\n\t\t\t"
+ result:
+ - text: "SELECT 1;"
+ baseline: 0
start:
- line: 10
- column: 17
+ line: 1
+ column: 1
end:
- line: 11
- column: 7
+ line: 1
+ column: 10
range:
- start: 255
- end: 262
- empty: true
+ start: 0
+ end: 9
+ empty: false
- description: CRLF line endings
input: "CREATE TABLE t\r\n(a int);\r\nCREATE TABLE t1(b int);"
result:
diff --git a/go.mod b/go.mod
index f2d0fd1ba1..c1be35f1cc 100644
--- a/go.mod
+++ b/go.mod
@@ -34,7 +34,7 @@ require (
github.com/bmatcuk/doublestar/v4 v4.10.0
github.com/bytebase/gomongo v0.0.0-20260324061529-f15b9a5add35
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0
- github.com/bytebase/omni v0.0.0-20260403030128-870fdbdfbf2e
+ github.com/bytebase/omni v0.0.0-20260403085552-f9d38cd66ef2
github.com/caarlos0/env/v11 v11.4.0
github.com/cenkalti/backoff/v5 v5.0.3
github.com/cockroachdb/cockroachdb-parser v0.25.2
diff --git a/go.sum b/go.sum
index f3fdec7ae8..b03a2bfc0b 100644
--- a/go.sum
+++ b/go.sum
@@ -253,8 +253,8 @@ github.com/bytebase/gomongo v0.0.0-20260324061529-f15b9a5add35 h1:SjcZSrUMNj6GZq
github.com/bytebase/gomongo v0.0.0-20260324061529-f15b9a5add35/go.mod h1:jHdAD+tN3bO2Hazme0crgkNiHqkDR/3Igesy1chhjLA=
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-20260403030128-870fdbdfbf2e h1:Yj4aqHR9cyrC1K7FpTMrfIoIYoyvV+LJu00HrmZFWqE=
-github.com/bytebase/omni v0.0.0-20260403030128-870fdbdfbf2e/go.mod h1:7kUVQrivlkckALafCX5j4W3M95Cg9+Kw69ZukIHKXhQ=
+github.com/bytebase/omni v0.0.0-20260403085552-f9d38cd66ef2 h1:RB/wcXhT4xSY1lLAdTpGttsYnzDPAHnJEII65AIXht0=
+github.com/bytebase/omni v0.0.0-20260403085552-f9d38cd66ef2/go.mod h1:SBAYEmMjJhA9WujfrIVIq76UFmsvNDOa5CekPhFXIis=
github.com/bytebase/parser v0.0.0-20260324092042-1d52e5412f50 h1:Kq5wlhZ586Rch39y/IQV9MnrEzHob4iiXBG6zrbvSMU=
github.com/bytebase/parser v0.0.0-20260324092042-1d52e5412f50/go.mod h1:jeak/EfutSOAuWKvrFIT2IZunhWprM7oTFBRgZ9RCxo=
github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=
@@ -999,6 +999,8 @@ github.com/testcontainers/testcontainers-go v0.41.0 h1:mfpsD0D36YgkxGj2LrIyxuwQ9
github.com/testcontainers/testcontainers-go v0.41.0/go.mod h1:pdFrEIfaPl24zmBjerWTTYaY0M6UHsqA1YSvsoU40MI=
github.com/testcontainers/testcontainers-go/modules/mongodb v0.40.0 h1:z/1qHeliTLDKNaJ7uOHOx1FjwghbcbYfga4dTFkF0hU=
github.com/testcontainers/testcontainers-go/modules/mongodb v0.40.0/go.mod h1:GaunAWwMXLtsMKG3xn2HYIBDbKddGArfcGsF2Aog81E=
+github.com/testcontainers/testcontainers-go/modules/mssql v0.41.0 h1:YAuSa+IMTn0nA6iNvSAFgJEeJsQWSghFWu0ubebWXJI=
+github.com/testcontainers/testcontainers-go/modules/mssql v0.41.0/go.mod h1:3leIIvry5kLZr8uxMIDX0iL2TRwVx2UDDSkGJGlpsvQ=
github.com/testcontainers/testcontainers-go/modules/mysql v0.41.0 h1:5rwejaJr5nIfw8NK99eKPX7O6k27lnSMklTj5DbYybM=
github.com/testcontainers/testcontainers-go/modules/mysql v0.41.0/go.mod h1:iMO/aFWnbjYkqHw8VPsJB3rVTOD9hKDsUtV0PvzD0DA=
github.com/testcontainers/testcontainers-go/modules/postgres v0.41.0 h1:AOtFXssrDlLm84A2sTTR/AhvJiYbrIuCO59d+Ro9Tb0=