Skip to content

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

chore: remove deadcode (#18542)

h3n4l8d19b16a2f2e
diff --git a/backend/plugin/db/tidb/sync.go b/backend/plugin/db/tidb/sync.go
index 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 := `
SELECT
diff --git a/backend/plugin/db/tidb/sync_test.go b/backend/plugin/db/tidb/sync_test.go
index 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 string
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index 7103200715..2cf6dd937a 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -1,7 +1,6 @@
package base
import (
- "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.go
index 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.go
index 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 directly
diff --git a/backend/plugin/parser/base/strings.go b/backend/plugin/parser/base/strings.go
deleted file mode 100644
index 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.go
index 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 statement
diff --git a/backend/plugin/parser/plsql/backup.go b/backend/plugin/parser/plsql/backup.go
index 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 = 128
maxTableNameLengthBefore12_2 = 30
- maxMixedDMLCount = 5
)
func init() {
diff --git a/backend/plugin/parser/plsql/replace.go b/backend/plugin/parser/plsql/replace.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
index 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.go
index 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.go
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
index 61195ca126..af8900744f 100644
--- a/backend/plugin/parser/tidb/split.go
+++ b/backend/plugin/parser/tidb/split.go
@@ -1,11 +1,6 @@
package tidb
import (
- "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.go
index 33db577b2c..25159245ce 100644
--- a/backend/plugin/parser/tidb/tidb.go
+++ b/backend/plugin/parser/tidb/tidb.go
@@ -1,13 +1,10 @@
package tidb
import (
- "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, er
return 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.go
index 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"