Skip to content

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

refactor(mysql): remove legacy delimiter tokenizer (#20673)

rebelice3d8bd94a38aa
diff --git a/backend/plugin/db/mysql/antlr_dependency_test.go b/backend/plugin/db/mysql/antlr_dependency_test.go
index 2fe978ebb8..43aff0287b 100644
--- a/backend/plugin/db/mysql/antlr_dependency_test.go
+++ b/backend/plugin/db/mysql/antlr_dependency_test.go
@@ -19,3 +19,11 @@ func TestMySQLQueryLimitRewriteDoesNotFallbackToANTLR(t *testing.T) {
require.NotContains(t, source, "TokenStreamRewriter")
require.NotContains(t, source, "BaseMySQLParserListener")
}
+
+func TestMySQLExecuteDoesNotPreprocessDelimiterDirectives(t *testing.T) {
+ content, err := os.ReadFile("mysql.go")
+ require.NoError(t, err)
+ source := string(content)
+
+ require.NotContains(t, source, "DealWithDelimiter")
+}
diff --git a/backend/plugin/db/mysql/mysql.go b/backend/plugin/db/mysql/mysql.go
index 6a37ee4e3a..f34cc07bed 100644
--- a/backend/plugin/db/mysql/mysql.go
+++ b/backend/plugin/db/mysql/mysql.go
@@ -307,6 +307,26 @@ func parseVersion(version string) (string, string, error) {
return "", "", errors.Errorf("failed to parse version %q", version)
}
+func buildExecuteCommands(statement string) ([]base.Statement, error) {
+ if len(statement) > common.MaxSheetCheckSize {
+ return []base.Statement{{Text: statement}}, nil
+ }
+
+ commands, err := mysqlparser.SplitSQL(statement)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to split sql")
+ }
+ commands = base.FilterEmptyStatements(commands)
+ if len(commands) == 0 {
+ return nil, nil
+ }
+ if len(commands) > common.MaximumCommands {
+ return []base.Statement{{Text: statement}}, nil
+ }
+
+ return commands, nil
+}
+
// Execute executes a SQL statement.
func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteOptions) (int64, error) {
// Parse transaction configuration from the script
@@ -318,11 +338,6 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
transactionConfig.Mode = common.GetDefaultTransactionMode()
}
- statement, err := mysqlparser.DealWithDelimiter(statement)
- if err != nil {
- return 0, errors.Wrapf(err, "failed to deal with delimiter")
- }
-
conn, err := d.db.Conn(ctx)
if err != nil {
return 0, err
@@ -335,30 +350,12 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
}
slog.Debug("connectionID", slog.String("connectionID", connectionID))
- var totalCommands int
- var commands []base.Statement
- oneshot := true
- if len(statement) <= common.MaxSheetCheckSize {
- singleSQLs, err := mysqlparser.SplitSQL(statement)
- if err != nil {
- return 0, errors.Wrapf(err, "failed to split sql")
- }
- singleSQLs = base.FilterEmptyStatements(singleSQLs)
- if len(singleSQLs) == 0 {
- return 0, nil
- }
- commands = singleSQLs
- totalCommands = len(commands)
- if totalCommands <= common.MaximumCommands {
- oneshot = false
- }
+ commands, err := buildExecuteCommands(statement)
+ if err != nil {
+ return 0, err
}
- if oneshot {
- commands = []base.Statement{
- {
- Text: statement,
- },
- }
+ if len(commands) == 0 {
+ return 0, nil
}
// Validate isolation level for MySQL if specified
diff --git a/backend/plugin/db/mysql/mysql_test.go b/backend/plugin/db/mysql/mysql_test.go
index 2be5c24087..32d326bdf5 100644
--- a/backend/plugin/db/mysql/mysql_test.go
+++ b/backend/plugin/db/mysql/mysql_test.go
@@ -1,9 +1,12 @@
package mysql
import (
+ "strings"
"testing"
"github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/common"
)
func TestValidateMySQLExtraConnectionParameters(t *testing.T) {
@@ -113,3 +116,39 @@ func TestParseVersion(t *testing.T) {
a.Equal(tc.wantRest, rest)
}
}
+
+func TestBuildExecuteCommandsNormalizesDelimiter(t *testing.T) {
+ statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND//\nDELIMITER ;\n"
+
+ commands, err := buildExecuteCommands(statement)
+ require.NoError(t, err)
+ require.Len(t, commands, 1)
+ require.NotContains(t, commands[0].Text, "DELIMITER")
+ require.Contains(t, commands[0].Text, "CREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND")
+}
+
+func TestBuildExecuteCommandsDoesNotNormalizeDelimiterForTooManyCommands(t *testing.T) {
+ var statement strings.Builder
+ statement.WriteString("DELIMITER //\n")
+ statement.WriteString("CREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND//\n")
+ statement.WriteString("DELIMITER ;\n")
+ statement.WriteString("/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE */;\n")
+ for i := 0; i < common.MaximumCommands; i++ {
+ statement.WriteString("SELECT 1;\n")
+ }
+
+ commands, err := buildExecuteCommands(statement.String())
+ require.NoError(t, err)
+ require.Len(t, commands, 1)
+ require.Equal(t, statement.String(), commands[0].Text)
+}
+
+func TestBuildExecuteCommandsDoesNotNormalizeDelimiterForLargeSheet(t *testing.T) {
+ statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND//\nDELIMITER ;\n" +
+ strings.Repeat(" ", common.MaxSheetCheckSize)
+
+ commands, err := buildExecuteCommands(statement)
+ require.NoError(t, err)
+ require.Len(t, commands, 1)
+ require.Equal(t, statement, commands[0].Text)
+}
diff --git a/backend/plugin/db/tidb/antlr_dependency_test.go b/backend/plugin/db/tidb/antlr_dependency_test.go
new file mode 100644
index 0000000000..d21e0d5a83
--- /dev/null
+++ b/backend/plugin/db/tidb/antlr_dependency_test.go
@@ -0,0 +1,20 @@
+package tidb
+
+import (
+ "os"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestTiDBExecuteDoesNotUseMySQLParserPackage(t *testing.T) {
+ content, err := os.ReadFile("tidb.go")
+ require.NoError(t, err)
+ source := string(content)
+
+ require.NotContains(t, source, "github.com/antlr4-go/antlr/v4")
+ require.NotContains(t, source, "github.com/bytebase/parser/mysql")
+ require.NotContains(t, source, "plugin/parser/mysql\"")
+ require.NotContains(t, source, "mysqlutil")
+ require.NotContains(t, source, "DealWithDelimiter")
+}
diff --git a/backend/plugin/db/tidb/tidb.go b/backend/plugin/db/tidb/tidb.go
index cd5bed1a13..a0250ed3bf 100644
--- a/backend/plugin/db/tidb/tidb.go
+++ b/backend/plugin/db/tidb/tidb.go
@@ -26,7 +26,6 @@ import (
"github.com/bytebase/bytebase/backend/plugin/db"
"github.com/bytebase/bytebase/backend/plugin/db/util"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
tidbparser "github.com/bytebase/bytebase/backend/plugin/parser/tidb"
)
@@ -178,6 +177,26 @@ func parseVersion(version string) (string, error) {
return "", errors.Errorf("failed to parse version %q", version)
}
+func buildExecuteCommands(statement string) ([]base.Statement, error) {
+ if len(statement) > common.MaxSheetCheckSize {
+ return []base.Statement{{Text: statement}}, nil
+ }
+
+ commands, err := tidbparser.SplitSQL(statement)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to split sql")
+ }
+ commands = base.FilterEmptyStatements(commands)
+ if len(commands) == 0 {
+ return nil, nil
+ }
+ if len(commands) > common.MaximumCommands {
+ return []base.Statement{{Text: statement}}, nil
+ }
+
+ return commands, nil
+}
+
// Execute executes a SQL statement.
func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteOptions) (int64, error) {
// Parse transaction mode from the script
@@ -190,11 +209,6 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
transactionMode = common.GetDefaultTransactionMode()
}
- statement, err := mysqlparser.DealWithDelimiter(statement)
- if err != nil {
- return 0, errors.Wrapf(err, "failed to deal with delimiter")
- }
-
conn, err := d.db.Conn(ctx)
if err != nil {
return 0, err
@@ -207,30 +221,12 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
}
slog.Debug("connectionID", slog.String("connectionID", connectionID))
- var totalCommands int
- var commands []base.Statement
- oneshot := true
- if len(statement) <= common.MaxSheetCheckSize {
- singleSQLs, err := tidbparser.SplitSQL(statement)
- if err != nil {
- return 0, errors.Wrapf(err, "failed to split sql")
- }
- singleSQLs = base.FilterEmptyStatements(singleSQLs)
- if len(singleSQLs) == 0 {
- return 0, nil
- }
- commands = singleSQLs
- totalCommands = len(commands)
- if totalCommands <= common.MaximumCommands {
- oneshot = false
- }
+ commands, err := buildExecuteCommands(statement)
+ if err != nil {
+ return 0, err
}
- if oneshot {
- commands = []base.Statement{
- {
- Text: statement,
- },
- }
+ if len(commands) == 0 {
+ return 0, nil
}
// Execute based on transaction mode
diff --git a/backend/plugin/db/tidb/tidb_test.go b/backend/plugin/db/tidb/tidb_test.go
index 3ae7d122f4..4b4f8f9036 100644
--- a/backend/plugin/db/tidb/tidb_test.go
+++ b/backend/plugin/db/tidb/tidb_test.go
@@ -1,10 +1,12 @@
package tidb
import (
+ "strings"
"testing"
"github.com/stretchr/testify/require"
+ "github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/db"
)
@@ -96,3 +98,39 @@ func TestTiDBVersionAtLeast(t *testing.T) {
a.Equal(tc.want, got, "version=%s threshold=%s", tc.version, tc.threshold)
}
}
+
+func TestBuildExecuteCommandsNormalizesDelimiter(t *testing.T) {
+ statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND//\nDELIMITER ;\n"
+
+ commands, err := buildExecuteCommands(statement)
+ require.NoError(t, err)
+ require.Len(t, commands, 1)
+ require.NotContains(t, commands[0].Text, "DELIMITER")
+ require.Contains(t, commands[0].Text, "CREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND")
+}
+
+func TestBuildExecuteCommandsDoesNotNormalizeDelimiterForTooManyCommands(t *testing.T) {
+ var statement strings.Builder
+ statement.WriteString("DELIMITER //\n")
+ statement.WriteString("CREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND//\n")
+ statement.WriteString("DELIMITER ;\n")
+ statement.WriteString("/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE */;\n")
+ for i := 0; i < common.MaximumCommands; i++ {
+ statement.WriteString("SELECT 1;\n")
+ }
+
+ commands, err := buildExecuteCommands(statement.String())
+ require.NoError(t, err)
+ require.Len(t, commands, 1)
+ require.Equal(t, statement.String(), commands[0].Text)
+}
+
+func TestBuildExecuteCommandsDoesNotNormalizeDelimiterForLargeSheet(t *testing.T) {
+ statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND//\nDELIMITER ;\n" +
+ strings.Repeat(" ", common.MaxSheetCheckSize)
+
+ commands, err := buildExecuteCommands(statement)
+ require.NoError(t, err)
+ require.Len(t, commands, 1)
+ require.Equal(t, statement, commands[0].Text)
+}
diff --git a/backend/plugin/parser/base/statement.go b/backend/plugin/parser/base/statement.go
index 34861c3e54..2d085b6641 100644
--- a/backend/plugin/parser/base/statement.go
+++ b/backend/plugin/parser/base/statement.go
@@ -32,6 +32,23 @@ func (s *Statement) BaseLine() int {
return int(s.Start.Line) - 1
}
+// NewStatementFromRange builds a Statement from a split segment range.
+func NewStatementFromRange(sql string, mapper *ByteOffsetPositionMapper, byteStart, byteEnd int, empty bool) Statement {
+ if byteEnd < len(sql) && sql[byteEnd] == ';' {
+ byteEnd++
+ }
+ return Statement{
+ Text: sql[byteStart:byteEnd],
+ Empty: empty,
+ Start: mapper.Position(byteStart),
+ End: mapper.Position(byteEnd),
+ Range: &storepb.Range{
+ Start: int32(byteStart),
+ End: int32(byteEnd),
+ },
+ }
+}
+
// ParsedStatement is the result of parsing SQL (Statement + AST).
// AST is guaranteed to be non-nil after successful parsing.
type ParsedStatement struct {
diff --git a/backend/plugin/parser/mysql/antlr_dependency_test.go b/backend/plugin/parser/mysql/antlr_dependency_test.go
index e48ccbcb2f..4497be3d99 100644
--- a/backend/plugin/parser/mysql/antlr_dependency_test.go
+++ b/backend/plugin/parser/mysql/antlr_dependency_test.go
@@ -18,3 +18,14 @@ func TestMySQLOmniASTDoesNotFallbackToANTLR(t *testing.T) {
require.NotContains(t, source, "antlrAST")
require.NotContains(t, source, "parseSingleStatementLenient")
}
+
+func TestMySQLDelimiterHandlingDoesNotUseLegacyTokenizer(t *testing.T) {
+ content, err := os.ReadFile("mysql.go")
+ require.NoError(t, err)
+ source := string(content)
+
+ require.NotContains(t, source, "plugin/parser/tokenizer")
+ require.NotContains(t, source, "SplitTiDBMultiSQL")
+ require.NotContains(t, source, "mysqlutil")
+ require.NotContains(t, source, "DealWithDelimiter")
+}
diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.go
index 4109c20e4a..32f6fc3663 100644
--- a/backend/plugin/parser/mysql/mysql.go
+++ b/backend/plugin/parser/mysql/mysql.go
@@ -3,17 +3,14 @@ package mysql
import (
"errors"
"fmt"
- "regexp"
"strings"
"github.com/antlr4-go/antlr/v4"
mysqlomniparser "github.com/bytebase/omni/mysql/parser"
parser "github.com/bytebase/parser/mysql"
- pkgerrors "github.com/pkg/errors"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/tokenizer"
)
func init() {
@@ -92,10 +89,6 @@ func convertOmniError(err error, stmt base.Statement) error {
// ParseMySQL parses the given SQL statement and returns the AST.
func ParseMySQL(statement string) ([]*base.ANTLRAST, error) {
- statement, err := DealWithDelimiter(statement)
- if err != nil {
- return nil, err
- }
stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
@@ -108,15 +101,11 @@ func ParseMySQL(statement string) ([]*base.ANTLRAST, error) {
func parseMySQLStatementsInternal(stmts []base.Statement) ([]*base.ANTLRAST, error) {
var result []*base.ANTLRAST
- if len(stmts) > 0 {
- // Add semicolon to the last statement if needed
- stmts[len(stmts)-1].Text = mysqlAddSemicolonIfNeeded(stmts[len(stmts)-1].Text)
- }
-
for _, s := range stmts {
if s.Empty {
continue
}
+ s.Text = mysqlAddSemicolonIfNeeded(s.Text)
tree, tokens, err := parseSingleStatement(s.BaseLine(), s.Text)
if err != nil {
@@ -137,45 +126,6 @@ func parseMySQLStatementsInternal(stmts []base.Statement) ([]*base.ANTLRAST, err
return result, nil
}
-// DealWithDelimiter converts the delimiter statement to comment, also converts the following statement's delimiter to semicolon(`;`).
-func DealWithDelimiter(statement string) (string, error) {
- has, list, err := hasDelimiter(statement)
- if err != nil {
- return "", err
- }
- if has {
- var result strings.Builder
- delimiter := `;`
- for _, sql := range list {
- if IsDelimiter(sql.Text) {
- delimiter, err = ExtractDelimiter(sql.Text)
- if err != nil {
- return "", err
- }
- // Comment out only the DELIMITER line, preserving all other lines for correct line numbers
- lines := strings.Split(sql.Text, "\n")
- for i, line := range lines {
- if IsDelimiter(line) {
- lines[i] = "-- " + strings.TrimLeft(line, " \t")
- break
- }
- }
- result.WriteString(strings.Join(lines, "\n"))
- continue
- }
- if delimiter != ";" && !sql.Empty {
- result.WriteString(strings.TrimSuffix(sql.Text, delimiter))
- result.WriteString(";")
- } else {
- result.WriteString(sql.Text)
- }
- }
-
- statement = result.String()
- }
- return statement, nil
-}
-
func parseSingleStatement(baseLine int, statement string) (antlr.Tree, *antlr.CommonTokenStream, error) {
input := antlr.NewInputStream(statement)
lexer := parser.NewMySQLLexer(input)
@@ -253,42 +203,6 @@ func isEmptyStatement(tokens *antlr.CommonTokenStream) bool {
return true
}
-// IsDelimiter returns true if the statement is a delimiter statement.
-func IsDelimiter(stmt string) bool {
- delimiterRegex := `(?i)^\s*DELIMITER\s+`
- re := regexp.MustCompile(delimiterRegex)
- return re.MatchString(stmt)
-}
-
-// ExtractDelimiter extracts the delimiter from the delimiter statement.
-func ExtractDelimiter(stmt string) (string, error) {
- delimiterRegex := `(?i)^\s*DELIMITER\s+(?P<DELIMITER>[^\s\\]+)\s*`
- re := regexp.MustCompile(delimiterRegex)
- matchList := re.FindStringSubmatch(stmt)
- index := re.SubexpIndex("DELIMITER")
- if index >= 0 && index < len(matchList) {
- return matchList[index], nil
- }
- return "", pkgerrors.Errorf("cannot extract delimiter from %q", stmt)
-}
-
-func hasDelimiter(statement string) (bool, []base.Statement, error) {
- // use splitTiDBMultiSQL to check if the statement has delimiter
- t := tokenizer.NewTokenizer(statement)
- list, err := t.SplitTiDBMultiSQL()
- if err != nil {
- return false, nil, pkgerrors.Errorf("failed to split multi sql: %v", err)
- }
-
- for _, sql := range list {
- if IsDelimiter(sql.Text) {
- return true, list, nil
- }
- }
-
- return false, list, nil
-}
-
// IsTopMySQLRule returns true if the given context is a top-level MySQL rule.
func IsTopMySQLRule(ctx *antlr.BaseParserRuleContext) bool {
if ctx.GetParent() == nil {
diff --git a/backend/plugin/parser/mysql/mysql_test.go b/backend/plugin/parser/mysql/mysql_test.go
index ba7231e0ba..6e4f5084b5 100644
--- a/backend/plugin/parser/mysql/mysql_test.go
+++ b/backend/plugin/parser/mysql/mysql_test.go
@@ -9,60 +9,6 @@ import (
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
-func TestExtractDelimiter(t *testing.T) {
- tests := []struct {
- stmt string
- want string
- wantErr bool
- }{
- {
- stmt: "DELIMITER ;;",
- want: ";;",
- wantErr: false,
- },
- {
- stmt: "DELIMITER //",
- want: "//",
- wantErr: false,
- },
- {
- stmt: "DELIMITER $$",
- want: "$$",
- wantErr: false,
- },
- {
- stmt: "DELIMITER @@ ",
- want: "@@",
- wantErr: false,
- },
- {
- stmt: "DELIMITER @@//",
- want: "@@//",
- wantErr: false,
- },
- {
- stmt: "DELIMITER @@//",
- want: "@@//",
- wantErr: false,
- },
- // DELIMITER cannot contain a backslash character
- {
- stmt: "DELIMITER \\",
- wantErr: true,
- },
- }
- a := require.New(t)
- for _, test := range tests {
- got, err := ExtractDelimiter(test.stmt)
- if test.wantErr {
- a.Error(err)
- } else {
- a.NoError(err)
- a.Equal(test.want, got)
- }
- }
-}
-
func TestMySQLParser(t *testing.T) {
tests := []struct {
statement string
@@ -155,6 +101,14 @@ func TestMySQLParser(t *testing.T) {
}
}
+func TestParseMySQLAddsSemicolonToEachDelimiterSegment(t *testing.T) {
+ statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT 1;\nEND//\nDELIMITER ;\nCALL p();"
+
+ list, err := ParseMySQL(statement)
+ require.NoError(t, err)
+ require.Len(t, list, 2)
+}
+
func TestParseMySQLStatements(t *testing.T) {
statement := "SELECT 1; SELECT 2;"
diff --git a/backend/plugin/parser/mysql/split.go b/backend/plugin/parser/mysql/split.go
index 5ca5ac9c05..c51bf93d46 100644
--- a/backend/plugin/parser/mysql/split.go
+++ b/backend/plugin/parser/mysql/split.go
@@ -23,24 +23,7 @@ func SplitSQL(statement string) ([]base.Statement, error) {
result := make([]base.Statement, 0, len(segments))
positionMapper := base.NewByteOffsetPositionMapper(statement)
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]
-
- result = append(result, base.Statement{
- Text: text,
- Empty: seg.Empty(),
- Start: positionMapper.Position(seg.ByteStart),
- End: positionMapper.Position(byteEnd),
- Range: &storepb.Range{
- Start: int32(seg.ByteStart),
- End: int32(byteEnd),
- },
- })
+ result = append(result, base.NewStatementFromRange(statement, positionMapper, seg.ByteStart, seg.ByteEnd, seg.Empty()))
}
return result, nil
}
diff --git a/backend/plugin/parser/mysql/split_test.go b/backend/plugin/parser/mysql/split_test.go
index d566b3fdec..b5a0e65f5e 100644
--- a/backend/plugin/parser/mysql/split_test.go
+++ b/backend/plugin/parser/mysql/split_test.go
@@ -34,6 +34,43 @@ func TestMySQLSplitSQLLargeInsertScriptScalesLinearly(t *testing.T) {
require.Less(t, elapsed, time.Second)
}
+func TestMySQLSplitSQLDelimiterDirectives(t *testing.T) {
+ statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT delimiter FROM t;\nEND//\nDELIMITER ;\nCALL p();"
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+
+ list = base.FilterEmptyStatements(list)
+ require.Len(t, list, 2)
+ require.Equal(t, "CREATE PROCEDURE p()\nBEGIN\n SELECT delimiter FROM t;\nEND", list[0].Text)
+ require.Equal(t, "CALL p();", list[1].Text)
+ require.Equal(t, statement[list[0].Range.Start:list[0].Range.End], list[0].Text)
+ require.Equal(t, statement[list[1].Range.Start:list[1].Range.End], list[1].Text)
+}
+
+func TestMySQLSplitSQLDelimiterLabelIsNotDirective(t *testing.T) {
+ statement := "DELIMITER: LOOP\n SELECT 1;\n LEAVE DELIMITER;\nEND LOOP DELIMITER;"
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+
+ list = base.FilterEmptyStatements(list)
+ require.Len(t, list, 1)
+ require.Equal(t, statement, list[0].Text)
+}
+
+func TestMySQLSplitSQLDelimiterIdentifierIsNotDirective(t *testing.T) {
+ statement := "CREATE TABLE t (\n delimiter INT\n);\nSELECT delimiter FROM t;"
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+
+ list = base.FilterEmptyStatements(list)
+ require.Len(t, list, 2)
+ require.Equal(t, "CREATE TABLE t (\n delimiter INT\n);", list[0].Text)
+ require.Equal(t, "\nSELECT delimiter FROM t;", list[1].Text)
+}
+
func TestSplitMySQLStatements(t *testing.T) {
tests := []struct {
statement string
diff --git a/backend/plugin/parser/tidb/split.go b/backend/plugin/parser/tidb/split.go
index af8900744f..060ef2f3d1 100644
--- a/backend/plugin/parser/tidb/split.go
+++ b/backend/plugin/parser/tidb/split.go
@@ -1,9 +1,10 @@
package tidb
import (
+ tidbparser "github.com/bytebase/omni/tidb/parser"
+
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/tokenizer"
)
func init() {
@@ -12,10 +13,12 @@ func init() {
// SplitSQL splits the given SQL statement into multiple SQL statements.
func SplitSQL(statement string) ([]base.Statement, error) {
- t := tokenizer.NewTokenizer(statement)
- list, err := t.SplitTiDBMultiSQL()
- if err != nil {
- return nil, err
+ segments := tidbparser.Split(statement)
+
+ result := make([]base.Statement, 0, len(segments))
+ positionMapper := base.NewByteOffsetPositionMapper(statement)
+ for _, seg := range segments {
+ result = append(result, base.NewStatementFromRange(statement, positionMapper, seg.ByteStart, seg.ByteEnd, seg.Empty()))
}
- return list, nil
+ return result, nil
}
diff --git a/backend/plugin/parser/tidb/split_test.go b/backend/plugin/parser/tidb/split_test.go
index 060729e5cd..edea3646b8 100644
--- a/backend/plugin/parser/tidb/split_test.go
+++ b/backend/plugin/parser/tidb/split_test.go
@@ -3,6 +3,8 @@ package tidb
import (
"testing"
+ "github.com/stretchr/testify/require"
+
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
@@ -11,3 +13,39 @@ func TestTiDBSplitSQL(t *testing.T) {
SplitFunc: SplitSQL,
})
}
+
+func TestTiDBSplitSQLDelimiterDirectives(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []string
+ }{
+ {
+ name: "common custom delimiter",
+ statement: "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT delimiter FROM t;\nEND//\nDELIMITER ;\nCALL p();",
+ want: []string{
+ "CREATE PROCEDURE p()\nBEGIN\n SELECT delimiter FROM t;\nEND",
+ "CALL p();",
+ },
+ },
+ {
+ name: "label is not directive",
+ statement: "DELIMITER: LOOP\n SELECT 1;\n LEAVE DELIMITER;\nEND LOOP DELIMITER;",
+ want: []string{"DELIMITER: LOOP\n SELECT 1;\n LEAVE DELIMITER;\nEND LOOP DELIMITER;"},
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ list, err := SplitSQL(test.statement)
+ require.NoError(t, err)
+ list = base.FilterEmptyStatements(list)
+
+ require.Len(t, list, len(test.want))
+ for i, stmt := range list {
+ require.Equal(t, test.want[i], stmt.Text)
+ require.Equal(t, test.statement[stmt.Range.Start:stmt.Range.End], stmt.Text)
+ }
+ })
+ }
+}