Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
chore: remove deadcode (#18542)
h3n4l8d19b16a2f2e
diff --git a/backend/plugin/db/tidb/sync.go b/backend/plugin/db/tidb/sync.goindex 50935b03c0..2a8851015b 100644--- a/backend/plugin/db/tidb/sync.go+++ b/backend/plugin/db/tidb/sync.go@@ -781,60 +781,6 @@ func stripSingleQuote(s string) string {return s}-// unquoteMySQLString unescapes a string that was escaped by MySQL's QUOTE() function.-// MySQL's QUOTE() function escapes:-// - \ → \\-// - ' → \'-// - ASCII NUL (0x00) → \0-// - Control-Z (0x1A) → \Z-func unquoteMySQLString(s string) string {- if len(s) == 0 {- return s- }-- // First remove surrounding quotes if present- s = stripSingleQuote(s)-- // Now unescape the content- result := make([]byte, 0, len(s))- for i := 0; i < len(s); i++ {- if s[i] == '\\' && i+1 < len(s) {- switch s[i+1] {- case '\\':- result = append(result, '\\')- i++ // skip next character- case '\'':- result = append(result, '\'')- i++ // skip next character- case '0':- result = append(result, 0) // ASCII NUL- i++ // skip next character- case 'Z':- result = append(result, 0x1A) // Control-Z- i++ // skip next character- case 'n':- result = append(result, '\n') // newline- i++ // skip next character- case 't':- result = append(result, '\t') // tab- i++ // skip next character- case 'r':- result = append(result, '\r') // carriage return- i++ // skip next character- case 'b':- result = append(result, '\b') // backspace- i++ // skip next character- default:- // Unknown escape sequence, keep the backslash- result = append(result, s[i])- }- } else {- result = append(result, s[i])- }- }- return string(result)-}-func (d *Driver) getSequenceList(ctx context.Context, databaseName string) ([]*storepb.SequenceMetadata, error) {query := `SELECTdiff --git a/backend/plugin/db/tidb/sync_test.go b/backend/plugin/db/tidb/sync_test.goindex e833dbb49a..fb79c3a21a 100644--- a/backend/plugin/db/tidb/sync_test.go+++ b/backend/plugin/db/tidb/sync_test.go@@ -277,32 +277,6 @@ func TestConvertCollationToCharset(t *testing.T) {}}-func TestUnquoteMySQLString(t *testing.T) {- tests := []struct {- input string- expected string- }{- {"'simple'", "simple"},- {"'Has\\nNewline'", "Has\nNewline"},- {"'Has\\tTab'", "Has\tTab"},- {"'Path: C:\\\\Users\\\\File'", "Path: C:\\Users\\File"},- {"'Quote\\'s test'", "Quote's test"},- {"'Control\\Z'", "Control\x1a"},- {"'Null\\0byte'", "Null\x00byte"},- {"''", ""},- {"'single'", "single"},- {"no quotes", "no quotes"},- {"'Mixed\\nescapes\\tand\\\\backslashes'", "Mixed\nescapes\tand\\backslashes"},- }-- for _, test := range tests {- t.Run(fmt.Sprintf("input: %s", test.input), func(t *testing.T) {- result := unquoteMySQLString(test.input)- require.Equal(t, test.expected, result, "Failed to unescape: %q", test.input)- })- }-}-func TestStripSingleQuote(t *testing.T) {tests := []struct {input stringdiff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.goindex 7103200715..2cf6dd937a 100644--- a/backend/plugin/parser/base/interface.go+++ b/backend/plugin/parser/base/interface.go@@ -1,7 +1,6 @@package baseimport (- "bytes""context""fmt""regexp"@@ -354,17 +353,6 @@ type ChangeSummary struct {InsertCount int}-// NewRange creates a new Range with index range of singleSQL in statement.-func NewRange(statement, singleSQL string) *storepb.Range {- statementBytes := []byte(statement)- singleSQLBytes := []byte(singleSQL)- start := bytes.Index(statementBytes, singleSQLBytes)- return &storepb.Range{- Start: int32(start),- End: int32(start + len(singleSQLBytes)),- }-}-// REFACTOR(zp): Put it here to avoid circular import for now.var (showplanReg = regexp.MustCompile(`(?mi)^\s*SET\s+SHOWPLAN_(ALL|XML|TEXT)\s+(?P<status>(ON|OFF))\s*;?$`)diff --git a/backend/plugin/parser/base/statement.go b/backend/plugin/parser/base/statement.goindex 7f1469b6d5..a2a6c2fa56 100644--- a/backend/plugin/parser/base/statement.go+++ b/backend/plugin/parser/base/statement.go@@ -44,17 +44,6 @@ func FilterEmptyStatements(list []Statement) []Statement {return result}-// FilterEmptyParsedStatements removes empty parsed statements from the list.-func FilterEmptyParsedStatements(list []ParsedStatement) []ParsedStatement {- var result []ParsedStatement- for _, stmt := range list {- if !stmt.Empty {- result = append(result, stmt)- }- }- return result-}-// ExtractASTs extracts non-nil ASTs from a slice of ParsedStatements.// Empty statements (with nil AST) are skipped.// Returns nil if no ASTs are found (preserves nil-check compatibility).@@ -68,13 +57,3 @@ func ExtractASTs(stmts []ParsedStatement) []AST {}return asts}--// ExtractStatements extracts Statements from a slice of ParsedStatements.-// This is useful when you only need the text/position information without AST.-func ExtractStatements(stmts []ParsedStatement) []Statement {- result := make([]Statement, len(stmts))- for i, stmt := range stmts {- result[i] = stmt.Statement- }- return result-}diff --git a/backend/plugin/parser/base/statement_test.go b/backend/plugin/parser/base/statement_test.goindex e046db345a..f60b3e0769 100644--- a/backend/plugin/parser/base/statement_test.go+++ b/backend/plugin/parser/base/statement_test.go@@ -23,20 +23,6 @@ func TestFilterEmptyStatements(t *testing.T) {require.Equal(t, "SELECT 2", result[1].Text)}-func TestFilterEmptyParsedStatements(t *testing.T) {- statements := []ParsedStatement{- {Statement: Statement{Text: "SELECT 1", Empty: false}, AST: &ANTLRAST{}},- {Statement: Statement{Text: "", Empty: true}, AST: &ANTLRAST{}},- {Statement: Statement{Text: "SELECT 2", Empty: false}, AST: &ANTLRAST{}},- }-- result := FilterEmptyParsedStatements(statements)-- require.Len(t, result, 2)- require.Equal(t, "SELECT 1", result[0].Text)- require.Equal(t, "SELECT 2", result[1].Text)-}-func TestExtractASTs(t *testing.T) {ast1 := &ANTLRAST{StartPosition: &storepb.Position{Line: 1}}ast2 := &ANTLRAST{StartPosition: &storepb.Position{Line: 2}}@@ -53,21 +39,6 @@ func TestExtractASTs(t *testing.T) {require.Equal(t, ast2, asts[1])}-func TestExtractStatements(t *testing.T) {- statements := []ParsedStatement{- {Statement: Statement{Text: "SELECT 1", BaseLine: 0}, AST: &ANTLRAST{}},- {Statement: Statement{Text: "SELECT 2", BaseLine: 1}, AST: &ANTLRAST{}},- }-- result := ExtractStatements(statements)-- require.Len(t, result, 2)- require.Equal(t, "SELECT 1", result[0].Text)- require.Equal(t, "SELECT 2", result[1].Text)- require.Equal(t, 0, result[0].BaseLine)- require.Equal(t, 1, result[1].BaseLine)-}-func TestParsedStatementEmbedding(t *testing.T) {// Test that ParsedStatement embeds Statement correctly// Fields should be accessible directlydiff --git a/backend/plugin/parser/base/strings.go b/backend/plugin/parser/base/strings.godeleted file mode 100644index a54c500dc2..0000000000--- a/backend/plugin/parser/base/strings.go+++ /dev/null@@ -1,60 +0,0 @@-package base--type StringsManipulatorActionType int--const (- StringsManipulatorActionTypeNone StringsManipulatorActionType = iota- StringsManipulatorActionTypeDropTable- StringsManipulatorActionTypeAddTable- StringsManipulatorActionTypeDropColumn- StringsManipulatorActionTypeAddColumn- StringsManipulatorActionTypeModifyColumnType- StringsManipulatorActionTypeDropColumnOption- StringsManipulatorActionTypeAddColumnOption- StringsManipulatorActionTypeModifyColumnOption- StringsManipulatorActionTypeDropTableConstraint- StringsManipulatorActionTypeModifyTableConstraint- StringsManipulatorActionTypeAddTableConstraint- StringsManipulatorActionTypeDropTableOption- StringsManipulatorActionTypeModifyTableOption- StringsManipulatorActionTypeAddTableOption- StringsManipulatorActionTypeDropIndex- StringsManipulatorActionTypeAddIndex- StringsManipulatorActionTypeModifyIndex-)--type StringsManipulatorAction interface {- GetType() StringsManipulatorActionType- GetSchemaName() string- GetTopLevelNaming() string- GetSecondLevelNaming() string-}--type StringsManipulatorActionBase struct {- Type StringsManipulatorActionType- SchemaName string-}--func (s *StringsManipulatorActionBase) GetType() StringsManipulatorActionType {- return s.Type-}--func (s *StringsManipulatorActionBase) GetSchemaName() string {- return s.SchemaName-}--type ColumnOptionType int--const (- ColumnOptionTypeNone ColumnOptionType = iota- ColumnOptionTypeNotNull- ColumnOptionTypeDefault-)--type TableConstraintType int--const (- TableConstraintTypeNone TableConstraintType = iota- TableConstraintTypePrimaryKey- TableConstraintTypeUnique-)diff --git a/backend/plugin/parser/mysql/mysql_test.go b/backend/plugin/parser/mysql/mysql_test.goindex a00f35990a..96f7a129b4 100644--- a/backend/plugin/parser/mysql/mysql_test.go+++ b/backend/plugin/parser/mysql/mysql_test.go@@ -455,9 +455,6 @@ func TestParseMySQLStatements(t *testing.T) {statements, err := base.ParseStatements(storepb.Engine_MYSQL, statement)require.NoError(t, err)- // Filter empty statements for assertion- statements = base.FilterEmptyParsedStatements(statements)-require.Len(t, statements, 2)// Check first statementdiff --git a/backend/plugin/parser/plsql/backup.go b/backend/plugin/parser/plsql/backup.goindex 81069716ce..93d7e65fdf 100644--- a/backend/plugin/parser/plsql/backup.go+++ b/backend/plugin/parser/plsql/backup.go@@ -19,7 +19,6 @@ import (const (maxTableNameLengthAfter12_2 = 128maxTableNameLengthBefore12_2 = 30- maxMixedDMLCount = 5)func init() {diff --git a/backend/plugin/parser/plsql/replace.go b/backend/plugin/parser/plsql/replace.godeleted file mode 100644index 6689e850b7..0000000000--- a/backend/plugin/parser/plsql/replace.go+++ /dev/null@@ -1,247 +0,0 @@-package plsql--import (- "fmt"- "log/slog"- "strings"-- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/plsql"-- "github.com/bytebase/bytebase/backend/common/log"-)--type EraseContext struct {- eraseSchemaName bool-- eraseIndexName bool- normalizeIndexName bool-- eraseConstraintName bool-- eraseStoreOption bool-}--func EraseString(ctx EraseContext, rule antlr.ParserRuleContext, tokens antlr.TokenStream) string {- listener := &eraseListener{- ctx: ctx,- rewriter: *antlr.NewTokenStreamRewriter(tokens),- }- antlr.ParseTreeWalkerDefault.Walk(listener, rule)- return listener.rewriter.GetText(antlr.DefaultProgramName, antlr.Interval{- Start: rule.GetStart().GetTokenIndex(),- Stop: rule.GetStop().GetTokenIndex(),- })-}--type eraseListener struct {- *parser.BasePlSqlParserListener-- ctx EraseContext- rewriter antlr.TokenStreamRewriter-}--func (l *eraseListener) EnterRelational_table(ctx *parser.Relational_tableContext) {- if l.ctx.eraseStoreOption {- if ctx.RIGHT_PAREN() != nil {- start := ctx.RIGHT_PAREN().GetSymbol().GetTokenIndex() + 1- stop := ctx.GetStop().GetTokenIndex()- if start > stop {- return- }- l.rewriter.DeleteDefault(- start,- stop,- )- }- }-}--func (l *eraseListener) EnterTableview_name(ctx *parser.Tableview_nameContext) {- if l.ctx.eraseSchemaName && ctx.Id_expression() != nil {- l.rewriter.DeleteDefault(- ctx.Identifier().GetStart().GetTokenIndex(),- ctx.Id_expression().GetStart().GetTokenIndex()-1,- )- }-}--func (l *eraseListener) EnterSchema_name(ctx *parser.Schema_nameContext) {- if l.ctx.eraseSchemaName {- stop := getPeriodIdx(ctx)- if stop == -1 {- stop = ctx.Identifier().GetStop().GetTokenIndex()- }- l.rewriter.DeleteDefault(- ctx.Identifier().GetStart().GetTokenIndex(),- stop,- )- }-}--func getPeriodIdx(ctx *parser.Schema_nameContext) int {- for i := ctx.GetStop().GetTokenIndex() + 1; i < ctx.GetParser().GetTokenStream().Size(); i++ {- token := ctx.GetParser().GetTokenStream().Get(i)- if token.GetTokenType() == parser.PlSqlParserPERIOD {- return i- }- if token.GetChannel() == antlr.TokenDefaultChannel || token.GetTokenType() == parser.PlSqlParserEOF {- return -1- }- }-- return -1-}--func (l *eraseListener) EnterCreate_index(ctx *parser.Create_indexContext) {- if l.ctx.eraseIndexName && ctx.Index_name() != nil {- l.rewriter.DeleteDefault(- ctx.Index_name().GetStart().GetTokenIndex(),- ctx.Index_name().GetStop().GetTokenIndex(),- )- } else if l.ctx.normalizeIndexName && ctx.Index_name() != nil {- l.rewriter.ReplaceDefault(- ctx.Index_name().GetStart().GetTokenIndex(),- ctx.Index_name().GetStop().GetTokenIndex(),- "\""+getNormalizeIndexName(ctx)+"\"",- )- }-}--func (l *eraseListener) EnterTable_index_clause(ctx *parser.Table_index_clauseContext) {- if l.ctx.eraseStoreOption {- if ctx.Index_properties() != nil {- l.rewriter.DeleteDefault(- ctx.Index_properties().GetStart().GetTokenIndex(),- ctx.Index_properties().GetStop().GetTokenIndex(),- )- }- }-}--func getNormalizeIndexName(ctx *parser.Create_indexContext) string {- var buf strings.Builder- // table name as prefix- switch {- case ctx.Table_index_clause() != nil:- _, _, tableName := NormalizeTableViewName("", ctx.Table_index_clause().Tableview_name())- if _, err := buf.WriteString(tableName); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- case ctx.Bitmap_join_index_clause() != nil:- _, _, tableName := NormalizeTableViewName("", ctx.Bitmap_join_index_clause().Tableview_name(0))- if _, err := buf.WriteString(tableName); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- case ctx.Cluster_index_clause() != nil:- _, clusterName := normalizeClusterName(ctx.Cluster_index_clause().Cluster_name())- if _, err := buf.WriteString(clusterName); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- default:- // No table/cluster name to add- }- if err := buf.WriteByte('_'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }-- // UNIQUE, BITMAP OR NON- switch {- case ctx.UNIQUE() != nil:- if err := buf.WriteByte('1'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- case ctx.BITMAP() != nil:- if err := buf.WriteByte('2'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- default:- if err := buf.WriteByte('0'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- }-- // cluster_index_clause, table_index_clause or bitmap_join_index_clause- switch {- case ctx.Cluster_index_clause() != nil:- if err := buf.WriteByte('1'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- case ctx.Table_index_clause() != nil:- if err := buf.WriteByte('2'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- if _, err := buf.WriteString(fmt.Sprintf("%d", len(ctx.Table_index_clause().AllIndex_expr_option()))); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- case ctx.Bitmap_join_index_clause() != nil:- if err := buf.WriteByte('3'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- default:- // No index type specified- if err := buf.WriteByte('0'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- }-- // USABLE or UNUSABLE- switch {- case ctx.USABLE() != nil:- if err := buf.WriteByte('1'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- case ctx.UNUSABLE() != nil:- if err := buf.WriteByte('2'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- default:- if err := buf.WriteByte('0'); err != nil {- slog.Debug("Failed to write byte", log.BBError(err))- return ""- }- }-- return buf.String()-}--func (l *eraseListener) EnterConstraint_name(ctx *parser.Constraint_nameContext) {- if l.ctx.eraseConstraintName {- start := getConstraintKeywordIdx(ctx)- if start == -1 {- start = ctx.Identifier().GetStart().GetTokenIndex()- }- l.rewriter.DeleteDefault(- start,- ctx.Identifier().GetStop().GetTokenIndex(),- )- }-}--func getConstraintKeywordIdx(ctx *parser.Constraint_nameContext) int {- for i := ctx.GetStart().GetTokenIndex() - 1; i >= 0; i-- {- token := ctx.GetParser().GetTokenStream().Get(i)- if token.GetTokenType() == parser.PlSqlParserCONSTRAINT {- return i- }- if token.GetChannel() == antlr.TokenDefaultChannel {- return -1- }- }-- return -1-}diff --git a/backend/plugin/parser/plsql/strings.go b/backend/plugin/parser/plsql/strings.godeleted file mode 100644index 0a392f9ff9..0000000000--- a/backend/plugin/parser/plsql/strings.go+++ /dev/null@@ -1,1043 +0,0 @@-package plsql--import (- "strings"-- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/plsql"- "github.com/pkg/errors"-- "github.com/bytebase/bytebase/backend/plugin/parser/base"-)--type StringsManipulator struct {- tree antlr.Tree- stream antlr.TokenStream-}--func NewStringsManipulator(tree antlr.Tree, stream antlr.TokenStream) *StringsManipulator {- return &StringsManipulator{tree, stream}-}--type StringsManipulatorActionDropTable struct {- base.StringsManipulatorActionBase- Table string-}--func (s *StringsManipulatorActionDropTable) GetTopLevelNaming() string {- return s.Table-}--func (*StringsManipulatorActionDropTable) GetSecondLevelNaming() string {- return ""-}--func NewDropTableAction(schemaName, tableName string) *StringsManipulatorActionDropTable {- return &StringsManipulatorActionDropTable{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeDropTable,- SchemaName: schemaName,- },- Table: tableName,- }-}--type StringsManipulatorActionAddTable struct {- base.StringsManipulatorActionBase- Table string- TableDefinition string-}--func (s *StringsManipulatorActionAddTable) GetTopLevelNaming() string {- return s.Table-}--func (*StringsManipulatorActionAddTable) GetSecondLevelNaming() string {- return ""-}--func NewAddTableAction(schemaName, tableName, tableDefinition string) *StringsManipulatorActionAddTable {- return &StringsManipulatorActionAddTable{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeAddTable,- SchemaName: schemaName,- },- Table: tableName,- TableDefinition: tableDefinition,- }-}--type StringsManipulatorActionDropColumn struct {- base.StringsManipulatorActionBase- Table string- Column string-}--func (s *StringsManipulatorActionDropColumn) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionDropColumn) GetSecondLevelNaming() string {- return s.Column-}--func NewDropColumnAction(schemaName, tableName, columnName string) *StringsManipulatorActionDropColumn {- return &StringsManipulatorActionDropColumn{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeDropColumn,- SchemaName: schemaName,- },- Table: tableName,- Column: columnName,- }-}--type StringsManipulatorActionModifyColumnType struct {- base.StringsManipulatorActionBase- Table string- Column string- Type string-}--func (s *StringsManipulatorActionModifyColumnType) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionModifyColumnType) GetSecondLevelNaming() string {- return s.Column-}--func NewModifyColumnTypeAction(schemaName, tableName, columnName, columnType string) *StringsManipulatorActionModifyColumnType {- return &StringsManipulatorActionModifyColumnType{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeModifyColumnType,- SchemaName: schemaName,- },- Table: tableName,- Column: columnName,- Type: columnType,- }-}--type StringsManipulatorActionAddColumn struct {- base.StringsManipulatorActionBase- Table string- ColumnDefinition string-}--func (s *StringsManipulatorActionAddColumn) GetTopLevelNaming() string {- return s.Table-}--func (*StringsManipulatorActionAddColumn) GetSecondLevelNaming() string {- return ""-}--func NewAddColumnAction(schemaName, tableName, columnDefinition string) *StringsManipulatorActionAddColumn {- return &StringsManipulatorActionAddColumn{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeAddColumn,- SchemaName: schemaName,- },- Table: tableName,- ColumnDefinition: columnDefinition,- }-}--type StringsManipulatorActionColumnOptionBase struct {- base.StringsManipulatorActionBase- Type base.ColumnOptionType-}--func (s *StringsManipulatorActionColumnOptionBase) GetOptionType() base.ColumnOptionType {- return s.Type-}--type StringsManipulatorActionDropColumnOption struct {- StringsManipulatorActionColumnOptionBase- Table string- Column string-}--func (s *StringsManipulatorActionDropColumnOption) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionDropColumnOption) GetSecondLevelNaming() string {- return s.Column-}--func NewDropColumnOptionAction(schemaName, tableName string, columnName string, option base.ColumnOptionType) *StringsManipulatorActionDropColumnOption {- return &StringsManipulatorActionDropColumnOption{- StringsManipulatorActionColumnOptionBase: StringsManipulatorActionColumnOptionBase{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeDropColumnOption,- SchemaName: schemaName,- },- Type: option,- },- Table: tableName,- Column: columnName,- }-}--type StringsManipulatorActionModifyColumnOption struct {- StringsManipulatorActionColumnOptionBase- Table string- Column string- NewOptionDefine string-}--func (s *StringsManipulatorActionModifyColumnOption) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionModifyColumnOption) GetSecondLevelNaming() string {- return s.Column-}--func NewModifyColumnOptionAction(schemaName, tableName string, columnName string, oldOption base.ColumnOptionType, newOptionDefine string) *StringsManipulatorActionModifyColumnOption {- return &StringsManipulatorActionModifyColumnOption{- StringsManipulatorActionColumnOptionBase: StringsManipulatorActionColumnOptionBase{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeModifyColumnOption,- SchemaName: schemaName,- },- Type: oldOption,- },- Table: tableName,- Column: columnName,- NewOptionDefine: newOptionDefine,- }-}--type StringsManipulatorActionAddColumnOption struct {- StringsManipulatorActionColumnOptionBase- Table string- Column string- NewOptionDefine string-}--func (s *StringsManipulatorActionAddColumnOption) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionAddColumnOption) GetSecondLevelNaming() string {- return s.Column-}--func NewAddColumnOptionAction(schemaName, tableName string, columnName string, optionType base.ColumnOptionType, newOptionDefine string) *StringsManipulatorActionAddColumnOption {- return &StringsManipulatorActionAddColumnOption{- StringsManipulatorActionColumnOptionBase: StringsManipulatorActionColumnOptionBase{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeAddColumnOption,- SchemaName: schemaName,- },- Type: optionType,- },- Table: tableName,- Column: columnName,- NewOptionDefine: newOptionDefine,- }-}--type StringsManipulatorActionDropTableConstraint struct {- base.StringsManipulatorActionBase- Table string- Constraint base.TableConstraintType- ConstraintName string-}--func (s *StringsManipulatorActionDropTableConstraint) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionDropTableConstraint) GetSecondLevelNaming() string {- return s.ConstraintName-}--func NewDropTableConstraintAction(schemaName, tableName string, constraintName string) *StringsManipulatorActionDropTableConstraint {- return &StringsManipulatorActionDropTableConstraint{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeDropTableConstraint,- SchemaName: schemaName,- },- Table: tableName,- ConstraintName: constraintName,- }-}--type StringsManipulatorActionModifyTableConstraint struct {- base.StringsManipulatorActionBase- Table string- OldConstraint base.TableConstraintType- OldConstraintName string- NewConstraintDefine string-}--func (s *StringsManipulatorActionModifyTableConstraint) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionModifyTableConstraint) GetSecondLevelNaming() string {- return s.OldConstraintName-}--func NewModifyTableConstraintAction(schemaName, tableName string, oldConstraint base.TableConstraintType, oldConstraintName string, newConstraintDefine string) *StringsManipulatorActionModifyTableConstraint {- return &StringsManipulatorActionModifyTableConstraint{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeModifyTableConstraint,- SchemaName: schemaName,- },- Table: tableName,- OldConstraint: oldConstraint,- OldConstraintName: oldConstraintName,- NewConstraintDefine: newConstraintDefine,- }-}--type StringsManipulatorActionAddTableConstraint struct {- base.StringsManipulatorActionBase- Table string- Type base.TableConstraintType- NewConstraintDefine string-}--func (s *StringsManipulatorActionAddTableConstraint) GetTopLevelNaming() string {- return s.Table-}--func (*StringsManipulatorActionAddTableConstraint) GetSecondLevelNaming() string {- return ""-}--func NewAddTableConstraintAction(schemaName, tableName string, constraintType base.TableConstraintType, newConstraintDefine string) *StringsManipulatorActionAddTableConstraint {- return &StringsManipulatorActionAddTableConstraint{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeAddTableConstraint,- SchemaName: schemaName,- },- Table: tableName,- Type: constraintType,- NewConstraintDefine: newConstraintDefine,- }-}--type StringsManipulatorActionDropIndex struct {- base.StringsManipulatorActionBase- Table string- Index string-}--func (s *StringsManipulatorActionDropIndex) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionDropIndex) GetSecondLevelNaming() string {- return s.Index-}--func NewDropIndexAction(schemaName, tableName, indexName string) *StringsManipulatorActionDropIndex {- return &StringsManipulatorActionDropIndex{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeDropIndex,- SchemaName: schemaName,- },- Table: tableName,- Index: indexName,- }-}--type StringsManipulatorActionAddIndex struct {- base.StringsManipulatorActionBase- Table string- IndexDefine string-}--func (s *StringsManipulatorActionAddIndex) GetTopLevelNaming() string {- return s.Table-}--func (*StringsManipulatorActionAddIndex) GetSecondLevelNaming() string {- return ""-}--func NewAddIndexAction(schemaName, tableName, indexDefine string) *StringsManipulatorActionAddIndex {- return &StringsManipulatorActionAddIndex{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeAddIndex,- SchemaName: schemaName,- },- Table: tableName,- IndexDefine: indexDefine,- }-}--type StringsManipulatorActionModifyIndex struct {- base.StringsManipulatorActionBase- Table string- IndexName string- NewIndexDefine string-}--func (s *StringsManipulatorActionModifyIndex) GetTopLevelNaming() string {- return s.Table-}--func (s *StringsManipulatorActionModifyIndex) GetSecondLevelNaming() string {- return s.IndexName-}--func NewModifyIndexAction(schemaName, tableName, indexName string, newIndexDefine string) *StringsManipulatorActionModifyIndex {- return &StringsManipulatorActionModifyIndex{- StringsManipulatorActionBase: base.StringsManipulatorActionBase{- Type: base.StringsManipulatorActionTypeModifyIndex,- SchemaName: schemaName,- },- Table: tableName,- IndexName: indexName,- NewIndexDefine: newIndexDefine,- }-}--type tableID struct {- schema string- table string-}--type indexID struct {- schema string- table string- index string-}--func (s *StringsManipulator) Manipulate(actions ...base.StringsManipulatorAction) (string, error) {- tableActions := make(map[tableID][]base.StringsManipulatorAction)- var addTables []base.StringsManipulatorAction-- indexActions := make(map[indexID][]base.StringsManipulatorAction)-- for _, action := range actions {- switch action := action.(type) {- case *StringsManipulatorActionAddTable:- addTables = append(addTables, action)- case *StringsManipulatorActionDropIndex:- indexID := indexID{- schema: action.SchemaName,- table: action.GetTopLevelNaming(),- index: action.GetSecondLevelNaming(),- }- indexActions[indexID] = append(indexActions[indexID], action)- case *StringsManipulatorActionModifyIndex:- indexID := indexID{- schema: action.SchemaName,- table: action.GetTopLevelNaming(),- index: action.GetSecondLevelNaming(),- }- indexActions[indexID] = append(indexActions[indexID], action)- default:- table := tableID{- schema: action.GetSchemaName(),- table: action.GetTopLevelNaming(),- }- tableActions[table] = append(tableActions[table], action)- }- }-- listener := &statementListener{- actions: tableActions,- indexActions: indexActions,- addTables: addTables,- }- antlr.ParseTreeWalkerDefault.Walk(listener, s.tree)- return strings.Join(listener.results, "\n"), listener.err-}--type statementListener struct {- *parser.BasePlSqlParserListener-- actions map[tableID][]base.StringsManipulatorAction- indexActions map[indexID][]base.StringsManipulatorAction- addTables []base.StringsManipulatorAction- results []string- err error-}--func (l *statementListener) EnterSql_script(ctx *parser.Sql_scriptContext) {- for _, statement := range ctx.AllUnit_statement() {- switch {- case statement.Create_table() != nil:- rewriter := &rewriter{- actions: l.actions,- state: statementStateRemaining,- buf: &strings.Builder{},- tableActions: make(map[string][]base.StringsManipulatorAction),- }- antlr.ParseTreeWalkerDefault.Walk(rewriter, statement.Create_table())- if rewriter.err != nil {- l.err = rewriter.err- return- }- l.results = append(l.results, rewriter.buf.String())- case statement.Create_index() != nil:- rewriter := &rewriter{- actions: l.actions,- indexActions: l.indexActions,- state: statementStateRemaining,- buf: &strings.Builder{},- }- antlr.ParseTreeWalkerDefault.Walk(rewriter, statement.Create_index())- if rewriter.err != nil {- l.err = rewriter.err- return- }- l.results = append(l.results, rewriter.buf.String())- default:- l.results = append(l.results, statement.GetParser().GetTokenStream().GetTextFromRuleContext(statement)+";\n")- }- }- for _, action := range l.addTables {- l.results = append(l.results, action.(*StringsManipulatorActionAddTable).TableDefinition)- tableID := tableID{- schema: action.GetSchemaName(),- table: action.GetTopLevelNaming(),- }- actions, ok := l.actions[tableID]- if !ok || len(actions) == 0 {- continue- }- for _, action := range actions {- switch action := action.(type) {- case *StringsManipulatorActionAddIndex:- l.results = append(l.results, action.IndexDefine)- default:- // Do nothing.- }- }- }-}--type statementState int--const (- statementStateRemaining statementState = iota- statementStateModify- statementStateDelete-)--type rewriter struct {- *parser.BasePlSqlParserListener-- actions map[tableID][]base.StringsManipulatorAction- indexActions map[indexID][]base.StringsManipulatorAction- buf *strings.Builder- err error-- // per-statement state- currentTableID *tableID- tableActions map[string][]base.StringsManipulatorAction- state statementState- columnDefines []string- constraintDefines []string-- newIndexDefine string-}--func (r *rewriter) EnterCreate_index(ctx *parser.Create_indexContext) {- if r.err != nil {- return- }-- if ctx.Table_index_clause() == nil {- return- }-- indexDefinition := ctx.Table_index_clause()- schema, indexName := NormalizeIndexName(ctx.Index_name())- _, _, table := NormalizeTableViewName("", indexDefinition.Tableview_name())- indexID := indexID{- schema: schema,- table: table,- index: indexName,- }-- actions, ok := r.indexActions[indexID]- if !ok || len(actions) == 0 {- return- }-- for _, action := range actions {- switch action := action.(type) {- case *StringsManipulatorActionDropIndex:- r.state = statementStateDelete- case *StringsManipulatorActionModifyIndex:- r.state = statementStateModify- r.newIndexDefine = action.NewIndexDefine- }- }-}--func (r *rewriter) ExitCreate_index(ctx *parser.Create_indexContext) {- if r.err != nil {- return- }-- switch r.state {- case statementStateDelete:- return- case statementStateRemaining:- if _, err := r.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx)); err != nil {- r.err = err- return- }- case statementStateModify:- if _, err := r.buf.WriteString(r.newIndexDefine); err != nil {- r.err = err- return- }- default:- // Other states- }-}--func (r *rewriter) EnterCreate_table(ctx *parser.Create_tableContext) {- if r.err != nil {- return- }-- if ctx.Relational_table() == nil {- return- }-- schema := ""- if ctx.Schema_name() != nil {- schema = NormalizeSchemaName(ctx.Schema_name())- }- table := NormalizeTableName(ctx.Table_name())- r.currentTableID = &tableID{- schema: schema,- table: table,- }- actions, ok := r.actions[*r.currentTableID]- if !ok || len(actions) == 0 {- r.currentTableID = nil- return- }- r.state = statementStateModify-- hasDropTable := false- for _, action := range actions {- // do copy- action := action- secondName := action.GetSecondLevelNaming()- r.tableActions[secondName] = append(r.tableActions[secondName], action)- if action.GetType() == base.StringsManipulatorActionTypeDropTable {- hasDropTable = true- }- }-- if hasDropTable {- r.state = statementStateDelete- return- }-}--func (r *rewriter) ExitCreate_table(ctx *parser.Create_tableContext) {- if r.err != nil {- return- }-- addIndexFunc := func() error {- for _, action := range r.tableActions[""] {- if action.GetType() == base.StringsManipulatorActionTypeAddIndex {- addIndex, ok := action.(*StringsManipulatorActionAddIndex)- if !ok {- return errors.New("unexpected action type")- }- if _, err := r.buf.WriteString("\n"); err != nil {- return err- }- if _, err := r.buf.WriteString(addIndex.IndexDefine); err != nil {- return err- }- }- }- return nil- }-- switch r.state {- case statementStateDelete:- return- case statementStateRemaining:- if _, err := r.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx)); err != nil {- r.err = err- return- }- // Keep the original format with dump.- if _, err := r.buf.WriteString("\n"); err != nil {- r.err = err- return- }- if err := addIndexFunc(); err != nil {- r.err = err- }- return- case statementStateModify:- actions, exists := r.tableActions[""]- if exists && len(actions) > 0 {- for _, action := range actions {- switch action := action.(type) {- case *StringsManipulatorActionAddColumn:- r.columnDefines = append(r.columnDefines, action.ColumnDefinition)- case *StringsManipulatorActionAddTableConstraint:- r.constraintDefines = append(r.constraintDefines, action.NewConstraintDefine)- }- }- }-- if err := r.assembleCreateTable(ctx); err != nil {- r.err = err- return- }-- if err := addIndexFunc(); err != nil {- r.err = err- return- }- default:- // Other states- }-}--func (r *rewriter) assembleCreateTable(ctx *parser.Create_tableContext) error {- // Write the prefix part.- if _, err := r.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.Interval{- Start: ctx.GetStart().GetTokenIndex(),- Stop: ctx.Relational_table().GetStart().GetTokenIndex() - 1,- })); err != nil {- return errors.Wrap(err, "failed to write string")- }- if _, err := r.buf.WriteString(" ("); err != nil {- return errors.Wrap(err, "failed to write string")- }- if len(r.columnDefines) > 0 {- if _, err := r.buf.WriteString("\n "); err != nil {- return errors.Wrap(err, "failed to write string")- }- if _, err := r.buf.WriteString(strings.Join(r.columnDefines, ",\n ")); err != nil {- return errors.Wrap(err, "failed to write string")- }- }- if len(r.constraintDefines) > 0 {- if len(r.columnDefines) > 0 {- if _, err := r.buf.WriteString(",\n "); err != nil {- return errors.Wrap(err, "failed to write string")- }- }- if _, err := r.buf.WriteString(strings.Join(r.constraintDefines, ",\n ")); err != nil {- return errors.Wrap(err, "failed to write string")- }- }- if _, err := r.buf.WriteString("\n)"); err != nil {- return errors.Wrap(err, "failed to write string")- }- // Write the suffix part.- start := ctx.Relational_table().RIGHT_PAREN().GetSymbol().GetTokenIndex() + 1- if _, err := r.buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.Interval{- Start: start,- Stop: ctx.GetStop().GetTokenIndex(),- })); err != nil {- return errors.Wrap(err, "failed to write string")- }- // Keep the original format with dump.- if _, err := r.buf.WriteString("\n"); err != nil {- return errors.Wrap(err, "failed to write string")- }- return nil-}--func (r *rewriter) EnterOut_of_line_constraint(ctx *parser.Out_of_line_constraintContext) {- if r.err != nil {- return- }-- if r.state == statementStateDelete || r.currentTableID == nil {- return- }-- if ctx.Constraint_name() == nil {- // Remaining constraints are not supported.- r.constraintDefines = append(r.constraintDefines, ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx))- return- }-- switch {- case ctx.UNIQUE() != nil, ctx.PRIMARY() != nil:- default:- // Remaining constraints are not supported.- r.constraintDefines = append(r.constraintDefines, ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx))- return- }-- _, constraintName := NormalizeConstraintName(ctx.Constraint_name())- var constraintActions []base.StringsManipulatorAction- if actions, exists := r.tableActions[constraintName]; exists {- for _, action := range actions {- switch action := action.(type) {- case *StringsManipulatorActionDropTableConstraint, *StringsManipulatorActionModifyTableConstraint:- constraintActions = append(constraintActions, action)- }- }- }- if len(constraintActions) == 0 {- // We need to remain the original constraint definition if no action is found.- r.constraintDefines = append(r.constraintDefines, ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx))- return- }- for _, action := range constraintActions {- switch action := action.(type) {- case *StringsManipulatorActionDropTableConstraint:- // Drop constraint.- return- case *StringsManipulatorActionModifyTableConstraint:- r.constraintDefines = append(r.constraintDefines, action.NewConstraintDefine)- }- }-}--func (r *rewriter) EnterColumn_definition(ctx *parser.Column_definitionContext) {- if r.err != nil {- return- }-- if r.state == statementStateDelete || r.currentTableID == nil {- return- }-- _, _, columnName := NormalizeColumnName(ctx.Column_name())- if columnName == "" {- r.err = errors.New("invalid column name")- return- }-- var columnActions []base.StringsManipulatorAction- if actions, exists := r.tableActions[columnName]; exists {- for _, action := range actions {- switch action := action.(type) {- case *StringsManipulatorActionDropColumn,- *StringsManipulatorActionModifyColumnType,- *StringsManipulatorActionAddColumnOption,- *StringsManipulatorActionDropColumnOption,- *StringsManipulatorActionModifyColumnOption:- columnActions = append(columnActions, action)- }- }- }- if len(columnActions) == 0 {- // We need to remain the original column definition if no action is found.- r.columnDefines = append(r.columnDefines, ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx))- return- }- actionsMap := make(map[base.StringsManipulatorActionType][]base.StringsManipulatorAction)- for _, action := range columnActions {- if action.GetType() == base.StringsManipulatorActionTypeDropColumn {- return- }- actionsMap[action.GetType()] = append(actionsMap[action.GetType()], action)- }-- buf := strings.Builder{}- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.Column_name())); err != nil {- r.err = errors.Wrap(err, "failed to write column name")- return- }- if _, err := buf.WriteString(" "); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }-- if modifyType, exists := actionsMap[base.StringsManipulatorActionTypeModifyColumnType]; exists {- if len(modifyType) != 1 {- r.err = errors.New("multiple modify type actions found")- return- }- modifyType, ok := modifyType[0].(*StringsManipulatorActionModifyColumnType)- if !ok {- r.err = errors.New("invalid modify type action")- return- }- if _, err := buf.WriteString(modifyType.Type); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }- } else {- if ctx.Datatype() != nil {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.Datatype())); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }- } else if ctx.Regular_id() != nil {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.Regular_id())); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }- }-- if ctx.COLLATE() != nil {- if err := buf.WriteByte(' '); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.Interval{- Start: ctx.COLLATE().GetSymbol().GetTokenIndex(),- Stop: ctx.Column_collation_name().GetStop().GetTokenIndex(),- })); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }- }- }-- if ctx.VISIBLE() != nil {- if _, err := buf.WriteString(" VISIBLE"); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }- } else if ctx.INVISIBLE() != nil {- if _, err := buf.WriteString(" INVISIBLE"); err != nil {- r.err = errors.Wrap(err, "failed to write string")- return- }- }-- optionActionMap := make(map[base.ColumnOptionType]base.StringsManipulatorAction)- for _, action := range actionsMap[base.StringsManipulatorActionTypeAddColumnOption] {- action, ok := action.(*StringsManipulatorActionAddColumnOption)- if !ok {- r.err = errors.New("invalid add column option action")- return- }- optionActionMap[action.GetOptionType()] = action- }- for _, action := range actionsMap[base.StringsManipulatorActionTypeDropColumnOption] {- action, ok := action.(*StringsManipulatorActionDropColumnOption)- if !ok {- r.err = errors.New("invalid drop column option action")- return- }- optionActionMap[action.GetOptionType()] = action- }- for _, action := range actionsMap[base.StringsManipulatorActionTypeModifyColumnOption] {- action, ok := action.(*StringsManipulatorActionModifyColumnOption)- if !ok {- r.err = errors.New("invalid modify column option action")- return- }- optionActionMap[action.GetOptionType()] = action- }-- // Generate column default.- if err := writeDefaultOption(&buf, ctx, optionActionMap); err != nil {- r.err = err- return- }-- for _, constraint := range ctx.AllInline_constraint() {- // Cause we only write NOT NULL in Oracle dump, so we don't need to handle NULL.- if constraint.NULL_() != nil && constraint.NOT() != nil {- if err := writeNotNullOption(&buf, ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.Interval{- Start: constraint.NOT().GetSymbol().GetTokenIndex(),- Stop: constraint.NULL_().GetSymbol().GetTokenIndex(),- }), optionActionMap); err != nil {- r.err = err- return- }- }- }-- r.columnDefines = append(r.columnDefines, buf.String())-}--func writeNotNullOption(buf *strings.Builder, origin string, optionActionMap map[base.ColumnOptionType]base.StringsManipulatorAction) error {- needOrigin := true- if action, exists := optionActionMap[base.ColumnOptionTypeNotNull]; exists {- switch action := action.(type) {- case *StringsManipulatorActionDropColumnOption:- // Drop not null.- needOrigin = false- case *StringsManipulatorActionModifyColumnOption:- needOrigin = false- if err := buf.WriteByte(' '); err != nil {- return errors.Wrap(err, "failed to write string")- }- if _, err := buf.WriteString(action.NewOptionDefine); err != nil {- return errors.Wrap(err, "failed to write string")- }- case *StringsManipulatorActionAddColumnOption:- needOrigin = false- if err := buf.WriteByte(' '); err != nil {- return errors.Wrap(err, "failed to write string")- }- if _, err := buf.WriteString(action.NewOptionDefine); err != nil {- return errors.Wrap(err, "failed to write string")- }- }- }- if needOrigin {- if err := buf.WriteByte(' '); err != nil {- return errors.Wrap(err, "failed to write string")- }- if _, err := buf.WriteString(origin); err != nil {- return errors.Wrap(err, "failed to write string")- }- }- return nil-}--func writeDefaultOption(buf *strings.Builder, ctx *parser.Column_definitionContext, optionActionMap map[base.ColumnOptionType]base.StringsManipulatorAction) error {- needOrigin := true- if action, exists := optionActionMap[base.ColumnOptionTypeDefault]; exists {- switch action := action.(type) {- case *StringsManipulatorActionDropColumnOption:- // Drop default.- needOrigin = false- case *StringsManipulatorActionModifyColumnOption:- needOrigin = false- if err := buf.WriteByte(' '); err != nil {- return errors.Wrap(err, "failed to write string")- }- if _, err := buf.WriteString(action.NewOptionDefine); err != nil {- return errors.Wrap(err, "failed to write string")- }- case *StringsManipulatorActionAddColumnOption:- needOrigin = false- if err := buf.WriteByte(' '); err != nil {- return errors.Wrap(err, "failed to write string")- }- if _, err := buf.WriteString(action.NewOptionDefine); err != nil {- return errors.Wrap(err, "failed to write string")- }- }- }- if ctx.DEFAULT() != nil && needOrigin {- if err := buf.WriteByte(' '); err != nil {- return errors.Wrap(err, "failed to write string")- }- if ctx.Expression() != nil {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.Interval{- Start: ctx.DEFAULT().GetSymbol().GetTokenIndex(),- Stop: ctx.Expression().GetStop().GetTokenIndex(),- })); err != nil {- return errors.Wrap(err, "failed to write string")- }- } else if ctx.Identity_clause() != nil {- if _, err := buf.WriteString(ctx.GetParser().GetTokenStream().GetTextFromInterval(antlr.Interval{- Start: ctx.DEFAULT().GetSymbol().GetTokenIndex(),- Stop: ctx.Identity_clause().GetStop().GetTokenIndex(),- })); err != nil {- return errors.Wrap(err, "failed to write string")- }- }- }- return nil-}diff --git a/backend/plugin/parser/plsql/strings_test.go b/backend/plugin/parser/plsql/strings_test.godeleted file mode 100644index c38d106524..0000000000--- a/backend/plugin/parser/plsql/strings_test.go+++ /dev/null@@ -1,131 +0,0 @@-package plsql--import (- "io"- "os"- "testing"-- "github.com/stretchr/testify/require"- "gopkg.in/yaml.v3"-- "github.com/bytebase/bytebase/backend/plugin/parser/base"-)--const (- schemaName = "BYTEBASE"-)--type stringsManipulateTest struct {- Input string- Actions []testAction- Want string-}--type testAction struct {- Type string- Arguments []string-}--func TestStringsManipulate(t *testing.T) {- tests := []stringsManipulateTest{}-- const (- record = false- )- var (- filepath = "test-data/test_strings_manipulate.yaml"- )-- a := require.New(t)- yamlFile, err := os.Open(filepath)- a.NoError(err)-- byteValue, err := io.ReadAll(yamlFile)- a.NoError(yamlFile.Close())- a.NoError(err)- a.NoError(yaml.Unmarshal(byteValue, &tests))-- for i, t := range tests {- tree, stream, err := ParsePLSQLForStringsManipulation(t.Input)- a.NoError(err)- a.NotNil(tree)- manipulator := NewStringsManipulator(tree, stream)- actions := convertActionsForTest(t.Actions)- result, err := manipulator.Manipulate(actions...)- a.NoError(err)- if record {- tests[i].Want = result- } else {- a.Equal(t.Want, result, t.Input)- }- }-- if record {- byteValue, err := yaml.Marshal(tests)- a.NoError(err)- err = os.WriteFile(filepath, byteValue, 0644)- a.NoError(err)- }-}--func convertActionsForTest(actions []testAction) []base.StringsManipulatorAction {- var result []base.StringsManipulatorAction- for _, action := range actions {- switch action.Type {- case "dropTable":- result = append(result, NewDropTableAction(schemaName, action.Arguments[0]))- case "addTable":- result = append(result, NewAddTableAction(schemaName, action.Arguments[0], action.Arguments[1]))- case "dropColumn":- result = append(result, NewDropColumnAction(schemaName, action.Arguments[0], action.Arguments[1]))- case "addColumn":- result = append(result, NewAddColumnAction(schemaName, action.Arguments[0], action.Arguments[1]))- case "modifyColumnType":- result = append(result, NewModifyColumnTypeAction(schemaName, action.Arguments[0], action.Arguments[1], action.Arguments[2]))- case "dropColumnOption":- result = append(result, NewDropColumnOptionAction(schemaName, action.Arguments[0], action.Arguments[1], convertColumnOptionTypeForTest(action.Arguments[2])))- case "modifyColumnOption":- result = append(result, NewModifyColumnOptionAction(schemaName, action.Arguments[0], action.Arguments[1], convertColumnOptionTypeForTest(action.Arguments[2]), action.Arguments[3]))- case "addColumnOption":- result = append(result, NewAddColumnOptionAction(schemaName, action.Arguments[0], action.Arguments[1], convertColumnOptionTypeForTest(action.Arguments[2]), action.Arguments[3]))- case "dropTableConstraint":- result = append(result, NewDropTableConstraintAction(schemaName, action.Arguments[0], action.Arguments[1]))- case "modifyTableConstraint":- result = append(result, NewModifyTableConstraintAction(schemaName, action.Arguments[0], convertConstraintTypeForTest(action.Arguments[1]), action.Arguments[2], action.Arguments[3]))- case "addTableConstraint":- result = append(result, NewAddTableConstraintAction(schemaName, action.Arguments[0], convertConstraintTypeForTest(action.Arguments[1]), action.Arguments[2]))- case "addIndex":- result = append(result, NewAddIndexAction(schemaName, action.Arguments[0], action.Arguments[1]))- case "dropIndex":- result = append(result, NewDropIndexAction(schemaName, action.Arguments[0], action.Arguments[1]))- case "modifyIndex":- result = append(result, NewModifyIndexAction(schemaName, action.Arguments[0], action.Arguments[1], action.Arguments[2]))- default:- // Unknown action type, skip- }- }-- return result-}--func convertConstraintTypeForTest(s string) base.TableConstraintType {- switch s {- case "primaryKey":- return base.TableConstraintTypePrimaryKey- case "unique":- return base.TableConstraintTypeUnique- default:- return base.TableConstraintTypeNone- }-}--func convertColumnOptionTypeForTest(s string) base.ColumnOptionType {- switch s {- case "notNull":- return base.ColumnOptionTypeNotNull- case "defaultValue":- return base.ColumnOptionTypeDefault- default:- return base.ColumnOptionTypeNone- }-}diff --git a/backend/plugin/parser/plsql/util.go b/backend/plugin/parser/plsql/util.goindex 3b89a3020f..198df54d4e 100644--- a/backend/plugin/parser/plsql/util.go+++ b/backend/plugin/parser/plsql/util.go@@ -64,19 +64,3 @@ func NormalizeQuotedString(ctx plsql.IQuoted_stringContext) string {raw := ctx.GetText()return raw[1 : len(raw)-1]}--func normalizeClusterName(ctx plsql.ICluster_nameContext) (string, string) {- var list []string- for _, idExpression := range ctx.AllId_expression() {- list = append(list, NormalizeIDExpression(idExpression))- }-- switch len(list) {- case 1:- return "", list[0]- case 2:- return list[0], list[1]- default:- return "", ""- }-}diff --git a/backend/plugin/parser/spanner/dignose.go b/backend/plugin/parser/spanner/dignose.goindex b2a3269d00..a9d8b89e48 100644--- a/backend/plugin/parser/spanner/dignose.go+++ b/backend/plugin/parser/spanner/dignose.go@@ -13,7 +13,7 @@ import ()func init() {- base.RegisterDiagnoseFunc(storepb.Engine_BIGQUERY, Diagnose)+ base.RegisterDiagnoseFunc(storepb.Engine_SPANNER, Diagnose)}func Diagnose(_ context.Context, _ base.DiagnoseContext, statement string) ([]base.Diagnostic, error) {diff --git a/backend/plugin/parser/standard/split.go b/backend/plugin/parser/standard/split.goindex 08b308d6f6..9da972dd5a 100644--- a/backend/plugin/parser/standard/split.go+++ b/backend/plugin/parser/standard/split.go@@ -15,7 +15,6 @@ import (func init() {base.RegisterSplitterFunc(storepb.Engine_CLICKHOUSE, SplitSQL)base.RegisterSplitterFunc(storepb.Engine_SQLITE, SplitSQL)- base.RegisterSplitterFunc(storepb.Engine_SPANNER, SplitSQL)base.RegisterSplitterFunc(storepb.Engine_HIVE, SplitSQL)base.RegisterSplitterFunc(storepb.Engine_DATABRICKS, SplitSQL)}diff --git a/backend/plugin/parser/tidb/compatible.go b/backend/plugin/parser/tidb/compatible.godeleted file mode 100644index 84ad302ff9..0000000000--- a/backend/plugin/parser/tidb/compatible.go+++ /dev/null@@ -1,35 +0,0 @@-package tidb--import (- "fmt"- "regexp"-)--// IsTiDBUnsupportDDLStmt checks whether the `stmt` is unsupported DDL statement in TiDB, the following statements are unsupported:-// 1. `CREATE TRIGGER`-// 2. `CREATE EVENT`-// 3. `CREATE FUNCTION`-// 4. `CREATE PROCEDURE`.-func IsTiDBUnsupportDDLStmt(stmt string) bool {- objects := []string{- "TRIGGER",- "EVENT",- "FUNCTION",- "PROCEDURE",- }- createRegexFmt := "(?i)^\\s*CREATE\\s+(DEFINER=(`(.)+`|(.)+)@(`(.)+`|(.)+)(\\s)+)?%s\\s+"- dropRegexFmt := "(?i)^\\s*DROP\\s+%s\\s+"- for _, obj := range objects {- createRegexp := fmt.Sprintf(createRegexFmt, obj)- re := regexp.MustCompile(createRegexp)- if re.MatchString(stmt) {- return true- }- dropRegexp := fmt.Sprintf(dropRegexFmt, obj)- re = regexp.MustCompile(dropRegexp)- if re.MatchString(stmt) {- return true- }- }- return false-}diff --git a/backend/plugin/parser/tidb/normalize.go b/backend/plugin/parser/tidb/normalize.godeleted file mode 100644index bdd6a04eab..0000000000--- a/backend/plugin/parser/tidb/normalize.go+++ /dev/null@@ -1,28 +0,0 @@-package tidb--import (- parser "github.com/bytebase/parser/tidb"-)--// NormalizeTiDBIdentifier normalizes the given identifier.-func NormalizeTiDBIdentifier(identifier parser.IIdentifierContext) string {- if identifier.PureIdentifier() != nil {- if identifier.PureIdentifier().IDENTIFIER() != nil {- return identifier.PureIdentifier().IDENTIFIER().GetText()- }- // For back tick quoted identifier, we need to remove the back tick.- text := identifier.PureIdentifier().BACK_TICK_QUOTED_ID().GetText()- return text[1 : len(text)-1]- }- return identifier.GetText()-}--// NormalizeTiDBTextOrIdentifier normalizes the given TextOrIdentifier.-func NormalizeTiDBTextOrIdentifier(ctx parser.ITextOrIdentifierContext) string {- if ctx.Identifier() != nil {- return NormalizeTiDBIdentifier(ctx.Identifier())- }- textString := ctx.TextStringLiteral().GetText()- // remove the quotations.- return textString[1 : len(textString)-1]-}diff --git a/backend/plugin/parser/tidb/split.go b/backend/plugin/parser/tidb/split.goindex 61195ca126..af8900744f 100644--- a/backend/plugin/parser/tidb/split.go+++ b/backend/plugin/parser/tidb/split.go@@ -1,11 +1,6 @@package tidbimport (- "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""github.com/bytebase/bytebase/backend/plugin/parser/tokenizer"@@ -24,383 +19,3 @@ func SplitSQL(statement string) ([]base.Statement, error) {}return list, nil}--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 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 splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {- var result []base.Statement- delimiter := ";"- tokens := stream.GetAllTokens()- start := 0- byteOffset := 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- }-- // Deal with normal statement.- if delimiter == ";" && token.GetTokenType() == parser.MySQLLexerSEMICOLON_SYMBOL {- stmtText := stream.GetTextFromTokens(tokens[start], tokens[i])- stmtByteLength := len(stmtText)-- antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : i+1])- // 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,- BaseLine: tokens[start].GetLine() - 1,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRPositionToPosition(- &common.ANTLRPosition{- Line: int32(tokens[i].GetLine()),- Column: int32(tokens[i].GetColumn()),- },- statement,- ),- Start: common.ConvertANTLRPositionToPosition(antlrPosition, statement),- Empty: base.IsEmpty(tokens[start:i+1], parser.MySQLLexerSEMICOLON_SYMBOL),- })- byteOffset += stmtByteLength- i++- start = i- continue- }-- if token.GetChannel() != antlr.TokenDefaultChannel {- i++- continue- }-- if newStart, ok := tryMatchDelimiter(stream, i, delimiter); ok {- stmtText := stream.GetTextFromTokens(tokens[start], tokens[newStart-1])- stmtByteLength := len(stmtText)-- antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:newStart])- // 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: stream.GetTextFromTokens(tokens[start], tokens[i-1]) + ";",- BaseLine: tokens[start].GetLine() - 1,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRPositionToPosition(- &common.ANTLRPosition{- Line: int32(tokens[newStart-1].GetLine()),- Column: int32(tokens[newStart-1].GetColumn()),- },- statement,- ),- Start: common.ConvertANTLRPositionToPosition(antlrPosition, statement),- Empty: base.IsEmpty(tokens[start:i], parser.MySQLLexerSEMICOLON_SYMBOL),- })- byteOffset += stmtByteLength- i = newStart- start = newStart- continue- }-- i++- }-- endPos := len(tokens) - 1- if start < endPos {- stmtText := stream.GetTextFromTokens(tokens[start], tokens[endPos-1])- stmtByteLength := len(stmtText)-- antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])- // 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,- BaseLine: tokens[start].GetLine() - 1,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRPositionToPosition(- &common.ANTLRPosition{- Line: int32(tokens[endPos-1].GetLine()),- Column: int32(tokens[endPos-1].GetColumn()),- },- statement,- ),- Start: common.ConvertANTLRPositionToPosition(antlrPosition, statement),- Empty: base.IsEmpty(tokens[start:endPos], parser.MySQLLexerSEMICOLON_SYMBOL),- })- }-- return result, nil-}--type openParenthesis struct {- tokenType int- pos int-}--func splitTiDBStatement(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:- // Continue processing other token types- }- }-- byteOffset := 0- start := 0- for _, pos := range semicolonStack {- stmtText := stream.GetTextFromTokens(tokens[start], tokens[pos])- stmtByteLength := len(stmtText)-- antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])- // 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,- BaseLine: tokens[start].GetLine() - 1,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRPositionToPosition(- &common.ANTLRPosition{- Line: int32(tokens[pos].GetLine()),- Column: int32(tokens[pos].GetColumn()),- },- statement,- ),- Start: common.ConvertANTLRPositionToPosition(antlrPosition, statement),- 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)-- antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])- // From antlr4, the line is ONE based, and the column is ZERO based.- // So we should minus 1 for the line.s- result = append(result, base.Statement{- Text: stmtText,- BaseLine: tokens[start].GetLine() - 1,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRPositionToPosition(- &common.ANTLRPosition{- Line: int32(tokens[eofPos-1].GetLine()),- Column: int32(tokens[eofPos-1].GetColumn()),- },- statement,- ),- Start: common.ConvertANTLRPositionToPosition(antlrPosition, statement),- 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/tidb/tidb.go b/backend/plugin/parser/tidb/tidb.goindex 33db577b2c..25159245ce 100644--- a/backend/plugin/parser/tidb/tidb.go+++ b/backend/plugin/parser/tidb/tidb.go@@ -1,13 +1,10 @@package tidbimport (- "fmt"- "log/slog""regexp""strconv""strings"- "github.com/antlr4-go/antlr/v4"tidbparser "github.com/pingcap/tidb/pkg/parser""github.com/pingcap/tidb/pkg/parser/ast""github.com/pingcap/tidb/pkg/parser/mysql"@@ -16,8 +13,6 @@ import (// The packege parser_driver has to be imported._ "github.com/pingcap/tidb/pkg/types/parser_driver"- parser "github.com/bytebase/parser/tidb"-"github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -142,132 +137,6 @@ func ParseTiDB(sql string, charset string, collation string) ([]ast.StmtNode, erreturn nodes, nil}-func ANTLRParseTiDB(statement string) ([]*base.ANTLRAST, error) {- statement, err := DealWithDelimiter(statement)- if err != nil {- return nil, err- }- list, err := parseInputStream(antlr.NewInputStream(statement), statement)- // HACK(p0ny): the callee may end up in an infinite loop, we print the statement here to help debug.- if err != nil && strings.Contains(err.Error(), "split SQL statement timed out") {- slog.Info("split SQL statement timed out", "statement", statement)- }- return list, err-}--func parseSingleStatement(baseLine int, statement string) (antlr.Tree, *antlr.CommonTokenStream, error) {- input := antlr.NewInputStream(statement)- lexer := parser.NewTiDBLexer(input)- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)-- p := parser.NewTiDBParser(stream)-- startPosition := &storepb.Position{Line: int32(baseLine) + 1}- lexerErrorListener := &base.ParseErrorListener{- Statement: statement,- StartPosition: startPosition,- }- lexer.RemoveErrorListeners()- lexer.AddErrorListener(lexerErrorListener)-- parserErrorListener := &base.ParseErrorListener{- Statement: statement,- StartPosition: startPosition,- }- p.RemoveErrorListeners()- p.AddErrorListener(parserErrorListener)-- p.BuildParseTrees = true-- tree := p.Script()-- if lexerErrorListener.Err != nil {- return nil, nil, lexerErrorListener.Err- }-- if parserErrorListener.Err != nil {- return nil, nil, parserErrorListener.Err- }-- return tree, stream, nil-}--func parseInputStream(input *antlr.InputStream, statement string) ([]*base.ANTLRAST, error) {- var result []*base.ANTLRAST- lexer := parser.NewTiDBLexer(input)- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)-- list, err := splitTiDBStatement(stream, statement)- if err != nil {- return nil, err- }-- if len(list) > 0 {- list[len(list)-1].Text = tidbAddSemicolonIfNeeded(list[len(list)-1].Text)- }-- baseLine := 0- for _, s := range list {- tree, tokens, err := parseSingleStatement(baseLine, s.Text)- if err != nil {- return nil, err- }-- if isEmptyStatement(tokens) {- continue- }-- result = append(result, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(s.BaseLine) + 1},- Tree: tree,- Tokens: tokens,- })- baseLine = int(s.End.GetLine())- }-- return result, nil-}--func isEmptyStatement(tokens *antlr.CommonTokenStream) bool {- for _, token := range tokens.GetAllTokens() {- if token.GetChannel() == antlr.TokenDefaultChannel && token.GetTokenType() != parser.TiDBParserSEMICOLON_SYMBOL && token.GetTokenType() != parser.TiDBParserEOF {- return false- }- }- return true-}--// 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 []string- delimiter := `;`- for _, sql := range list {- if IsDelimiter(sql.Text) {- delimiter, err = ExtractDelimiter(sql.Text)- if err != nil {- return "", err- }- result = append(result, "-- "+sql.Text)- continue- }- // TODO(rebelice): after deal with delimiter, we may cannot get the right line number, fix it.- if delimiter != ";" && !sql.Empty {- result = append(result, fmt.Sprintf("%s;", strings.TrimSuffix(sql.Text, delimiter)))- } else {- result = append(result, sql.Text)- }- }-- statement = strings.Join(result, "\n")- }- return statement, nil-}-// IsDelimiter returns true if the statement is a delimiter statement.func IsDelimiter(stmt string) bool {delimiterRegex := `(?i)^\s*DELIMITER\s+`@@ -287,23 +156,6 @@ func ExtractDelimiter(stmt string) (string, error) {return "", errors.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, errors.Errorf("failed to split multi sql: %v", err)- }-- for _, sql := range list {- if IsDelimiter(sql.Text) {- return true, list, nil- }- }-- return false, list, nil-}-var (lineColumnRegex = regexp.MustCompile(`line (\d+) column (\d+)`))@@ -398,36 +250,3 @@ func TypeString(tp byte) string {return "unknown"}}--func tidbAddSemicolonIfNeeded(sql string) string {- lexer := parser.NewTiDBLexer(antlr.NewInputStream(sql))- lexerErrorListener := &base.ParseErrorListener{- Statement: sql,- }- lexer.RemoveErrorListeners()- lexer.AddErrorListener(lexerErrorListener)- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)- stream.Fill()- if lexerErrorListener.Err != nil {- // If the lexer fails, we cannot add semicolon.- return sql- }- tokens := stream.GetAllTokens()- for i := len(tokens) - 1; i >= 0; i-- {- if tokens[i].GetChannel() != antlr.TokenDefaultChannel || tokens[i].GetTokenType() == parser.TiDBParserEOF {- continue- }-- // The last default channel token is a semicolon.- if tokens[i].GetTokenType() == parser.TiDBParserSEMICOLON_SYMBOL {- return sql- }-- var result []string- result = append(result, stream.GetTextFromInterval(antlr.NewInterval(0, tokens[i].GetTokenIndex())))- result = append(result, ";")- result = append(result, stream.GetTextFromInterval(antlr.NewInterval(tokens[i].GetTokenIndex()+1, tokens[len(tokens)-1].GetTokenIndex())))- return strings.Join(result, "")- }- return sql-}diff --git a/backend/server/ultimate.go b/backend/server/ultimate.goindex 8c38d8cb4b..6a667158c6 100644--- a/backend/server/ultimate.go+++ b/backend/server/ultimate.go@@ -39,6 +39,7 @@ import (_ "github.com/bytebase/bytebase/backend/plugin/parser/redis"_ "github.com/bytebase/bytebase/backend/plugin/parser/redshift"_ "github.com/bytebase/bytebase/backend/plugin/parser/snowflake"+ _ "github.com/bytebase/bytebase/backend/plugin/parser/spanner"_ "github.com/bytebase/bytebase/backend/plugin/parser/standard"_ "github.com/bytebase/bytebase/backend/plugin/parser/tidb"_ "github.com/bytebase/bytebase/backend/plugin/parser/trino"@@ -50,6 +51,7 @@ import (_ "github.com/bytebase/bytebase/backend/plugin/advisor/oceanbase"_ "github.com/bytebase/bytebase/backend/plugin/advisor/oracle"_ "github.com/bytebase/bytebase/backend/plugin/advisor/pg"+ _ "github.com/bytebase/bytebase/backend/plugin/advisor/redshift"_ "github.com/bytebase/bytebase/backend/plugin/advisor/snowflake"_ "github.com/bytebase/bytebase/backend/plugin/advisor/tidb"