Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: move walk-through logic to engine-specific schema packages (#18128)
Danny Xu0f6f4849727b
diff --git a/backend/plugin/advisor/catalog/walk_through_test.go b/backend/plugin/advisor/catalog/walk_through_test.godeleted file mode 100644index 7d1f0f5575..0000000000--- a/backend/plugin/advisor/catalog/walk_through_test.go+++ /dev/null@@ -1,362 +0,0 @@-package catalog--import (- "io"- "os"- "path/filepath"- "testing"-- "github.com/google/go-cmp/cmp"- "github.com/stretchr/testify/require"- "google.golang.org/protobuf/testing/protocmp"- "gopkg.in/yaml.v3"-- "github.com/bytebase/bytebase/backend/common"- "github.com/bytebase/bytebase/backend/component/sheet"- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"- "github.com/bytebase/bytebase/backend/store/model"-)--type testData struct {- Statement string- // Use custom yaml tag to avoid generate field name `ignorecasesensitive`.- IgnoreCaseSensitive bool `yaml:"ignore_case_sensitive"`- Want string- Err *WalkThroughError-}--func TestTiDBWalkThrough(t *testing.T) {- originDatabase := &storepb.DatabaseSchemaMetadata{- Name: "test",- }-- tests := []string{- "tidb_walk_through",- }-- for _, test := range tests {- runWalkThroughTest(t, test, storepb.Engine_TIDB, originDatabase)- }-}--func TestMySQLWalkThrough(t *testing.T) {- originDatabase := &storepb.DatabaseSchemaMetadata{- Name: "test",- }-- tests := []string{- "mysql_walk_through",- }-- for _, test := range tests {- runWalkThroughTest(t, test, storepb.Engine_MYSQL, originDatabase)- }-}--func TestPostgreSQLWalkThrough(t *testing.T) {- originDatabase := &storepb.DatabaseSchemaMetadata{- Name: "postgres",- Schemas: []*storepb.SchemaMetadata{- {- Name: "public",- Tables: []*storepb.TableMetadata{- {- Name: "test",- Columns: []*storepb.ColumnMetadata{- {- Name: "id",- Type: "int",- Nullable: false,- Position: 1,- },- {- Name: "name",- Type: "varchar(20)",- Nullable: true,- Position: 2,- },- },- },- },- Views: []*storepb.ViewMetadata{- {- Name: "v1",- Definition: "SELECT id, name FROM test",- DependencyColumns: []*storepb.DependencyColumn{- {- Schema: "public",- Table: "test",- Column: "id",- },- {- Schema: "public",- Table: "test",- Column: "name",- },- },- },- },- },- },- }-- tests := []string{- "pg_walk_through",- }-- for _, test := range tests {- runWalkThroughTest(t, test, storepb.Engine_POSTGRES, originDatabase)- }-}--func TestPostgreSQLANTLRWalkThrough(t *testing.T) {- originDatabase := &storepb.DatabaseSchemaMetadata{- Name: "postgres",- Schemas: []*storepb.SchemaMetadata{- {- Name: "public",- Tables: []*storepb.TableMetadata{- {- Name: "test",- Columns: []*storepb.ColumnMetadata{- {- Name: "id",- Type: "int",- Nullable: false,- Position: 1,- },- {- Name: "name",- Type: "varchar(20)",- Nullable: true,- Position: 2,- },- },- },- },- Views: []*storepb.ViewMetadata{- {- Name: "v1",- Definition: "SELECT id, name FROM test",- DependencyColumns: []*storepb.DependencyColumn{- {- Schema: "public",- Table: "test",- Column: "id",- },- {- Schema: "public",- Table: "test",- Column: "name",- },- },- },- },- },- },- }-- tests := []string{- "pg_walk_through",- }-- for _, test := range tests {- runANTLRWalkThroughTest(t, test, storepb.Engine_POSTGRES, originDatabase)- }-}--func runWalkThroughTest(t *testing.T, file string, engineType storepb.Engine, originDatabase *storepb.DatabaseSchemaMetadata) {- tests := []testData{}- filepath := filepath.Join("test", file+".yaml")- yamlFile, err := os.Open(filepath)- require.NoError(t, err)- defer yamlFile.Close()-- byteValue, err := io.ReadAll(yamlFile)- require.NoError(t, err)- err = yaml.Unmarshal(byteValue, &tests)- require.NoError(t, err)- sm := sheet.NewManager(nil)-- for _, test := range tests {- var proto *storepb.DatabaseSchemaMetadata- if originDatabase != nil {- // Make a deep copy to avoid mutation across tests- proto = cloneDatabaseSchemaMetadata(originDatabase)- } else {- proto = &storepb.DatabaseSchemaMetadata{}- }-- // Create DatabaseMetadata for walk-through- state := model.NewDatabaseMetadata(proto, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)-- asts, _ := sm.GetASTsForChecks(engineType, test.Statement)- err := WalkThrough(state, engineType, asts)- if err != nil {- err, yes := err.(*WalkThroughError)- require.True(t, yes)- require.Equal(t, test.Err, err)- continue- }- require.NoError(t, err, test.Statement)-- // Skip comparison if want is empty (error cases)- if test.Want == "" {- continue- }-- want := &storepb.DatabaseSchemaMetadata{}- err = common.ProtojsonUnmarshaler.Unmarshal([]byte(test.Want), want)- require.NoError(t, err)- // Sort proto for deterministic comparison- state.SortProto()- result := state.GetProto()- diff := cmp.Diff(want, result, protocmp.Transform())- require.Empty(t, diff)- }-}--func runANTLRWalkThroughTest(t *testing.T, file string, engineType storepb.Engine, originDatabase *storepb.DatabaseSchemaMetadata) {- tests := []testData{}- filepath := filepath.Join("test", file+".yaml")- yamlFile, err := os.Open(filepath)- require.NoError(t, err)- defer yamlFile.Close()-- byteValue, err := io.ReadAll(yamlFile)- require.NoError(t, err)- err = yaml.Unmarshal(byteValue, &tests)- require.NoError(t, err)-- for _, test := range tests {- var proto *storepb.DatabaseSchemaMetadata- if originDatabase != nil {- // Make a deep copy to avoid mutation across tests- proto = cloneDatabaseSchemaMetadata(originDatabase)- } else {- proto = &storepb.DatabaseSchemaMetadata{}- }-- // Create DatabaseMetadata for walk-through- state := model.NewDatabaseMetadata(proto, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)-- // Parse using ANTLR parser instead of legacy parser- parseResult, parseErr := pgparser.ParsePostgreSQL(test.Statement)- if parseErr != nil {- t.Fatalf("Failed to parse SQL with ANTLR: %v\nSQL: %s", parseErr, test.Statement)- }-- // Call WalkThrough with ANTLR tree- err := WalkThrough(state, engineType, parseResult)- if err != nil {- err, yes := err.(*WalkThroughError)- require.True(t, yes)- require.Equal(t, test.Err, err)- continue- }- require.NoError(t, err, test.Statement)-- // Skip comparison if want is empty (error cases)- if test.Want == "" {- continue- }-- want := &storepb.DatabaseSchemaMetadata{}- err = common.ProtojsonUnmarshaler.Unmarshal([]byte(test.Want), want)- require.NoError(t, err)- // Sort proto for deterministic comparison- state.SortProto()- result := state.GetProto()- diff := cmp.Diff(want, result, protocmp.Transform())- require.Empty(t, diff)- }-}--// cloneDatabaseSchemaMetadata creates a deep copy of the database schema metadata.-func cloneDatabaseSchemaMetadata(original *storepb.DatabaseSchemaMetadata) *storepb.DatabaseSchemaMetadata {- if original == nil {- return nil- }-- clone := &storepb.DatabaseSchemaMetadata{- Name: original.Name,- CharacterSet: original.CharacterSet,- Collation: original.Collation,- Owner: original.Owner,- SearchPath: original.SearchPath,- Schemas: make([]*storepb.SchemaMetadata, 0, len(original.Schemas)),- }-- for _, schema := range original.Schemas {- cloneSchema := &storepb.SchemaMetadata{- Name: schema.Name,- Tables: make([]*storepb.TableMetadata, 0, len(schema.Tables)),- Views: make([]*storepb.ViewMetadata, 0, len(schema.Views)),- }-- for _, table := range schema.Tables {- cloneTable := &storepb.TableMetadata{- Name: table.Name,- Engine: table.Engine,- Collation: table.Collation,- Comment: table.Comment,- Columns: make([]*storepb.ColumnMetadata, 0, len(table.Columns)),- Indexes: make([]*storepb.IndexMetadata, 0, len(table.Indexes)),- ForeignKeys: make([]*storepb.ForeignKeyMetadata, 0, len(table.ForeignKeys)),- }-- for _, col := range table.Columns {- cloneCol := &storepb.ColumnMetadata{- Name: col.Name,- Position: col.Position,- Default: col.Default,- Nullable: col.Nullable,- Type: col.Type,- CharacterSet: col.CharacterSet,- Collation: col.Collation,- Comment: col.Comment,- }- cloneTable.Columns = append(cloneTable.Columns, cloneCol)- }-- for _, idx := range table.Indexes {- cloneIdx := &storepb.IndexMetadata{- Name: idx.Name,- Expressions: append([]string{}, idx.Expressions...),- Type: idx.Type,- Unique: idx.Unique,- Primary: idx.Primary,- Visible: idx.Visible,- Comment: idx.Comment,- }- cloneTable.Indexes = append(cloneTable.Indexes, cloneIdx)- }-- cloneSchema.Tables = append(cloneSchema.Tables, cloneTable)- }-- for _, view := range schema.Views {- cloneView := &storepb.ViewMetadata{- Name: view.Name,- Definition: view.Definition,- }- if len(view.DependencyColumns) > 0 {- cloneView.DependencyColumns = make([]*storepb.DependencyColumn, 0, len(view.DependencyColumns))- for _, dep := range view.DependencyColumns {- cloneDep := &storepb.DependencyColumn{- Schema: dep.Schema,- Table: dep.Table,- Column: dep.Column,- }- cloneView.DependencyColumns = append(cloneView.DependencyColumns, cloneDep)- }- }- cloneSchema.Views = append(cloneSchema.Views, cloneView)- }-- clone.Schemas = append(clone.Schemas, cloneSchema)- }-- return clone-}diff --git a/backend/plugin/advisor/pg/test_helper.go b/backend/plugin/advisor/pg/test_helper.goindex b34add362c..7d57a2262e 100644--- a/backend/plugin/advisor/pg/test_helper.go+++ b/backend/plugin/advisor/pg/test_helper.go@@ -15,8 +15,8 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/advisor/catalog""github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/store/model")@@ -85,7 +85,7 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyprequire.NoError(t, err, "Failed to parse SQL: %s", tc.Statement)// Always walk through the catalog to build metadata.- err = catalog.WalkThrough(finalMetadata, dbType, tree)+ err = schema.WalkThrough(dbType, finalMetadata, tree)require.NoError(t, err, "Failed to walk through final catalog: %s", tc.Statement)ruleList := []*storepb.SQLReviewRule{diff --git a/backend/plugin/advisor/sql_review.go b/backend/plugin/advisor/sql_review.goindex 467e3b0384..f79029c884 100644--- a/backend/plugin/advisor/sql_review.go+++ b/backend/plugin/advisor/sql_review.go@@ -11,10 +11,16 @@ import ("github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/component/sheet"storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/advisor/catalog""github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/plugin/schema"+ "github.com/bytebase/bytebase/backend/plugin/schema/catalogutil""github.com/bytebase/bytebase/backend/store/model"++ // Register walk-through implementations+ _ "github.com/bytebase/bytebase/backend/plugin/schema/mysql"+ _ "github.com/bytebase/bytebase/backend/plugin/schema/pg"+ _ "github.com/bytebase/bytebase/backend/plugin/schema/tidb")// How to add a SQL review rule:@@ -535,7 +541,7 @@ func SQLReviewCheck(if !builtinOnly && checkContext.FinalMetadata != nil {switch checkContext.DBType {case storepb.Engine_TIDB, storepb.Engine_MYSQL, storepb.Engine_MARIADB, storepb.Engine_POSTGRES, storepb.Engine_OCEANBASE:- if err := catalog.WalkThrough(checkContext.FinalMetadata, checkContext.DBType, asts); err != nil {+ if err := schema.WalkThrough(checkContext.DBType, checkContext.FinalMetadata, asts); err != nil {return convertWalkThroughErrorToAdvice(err)}default:@@ -603,7 +609,7 @@ func SQLReviewCheck(}func convertWalkThroughErrorToAdvice(err error) ([]*storepb.Advice, error) {- walkThroughError, ok := err.(*catalog.WalkThroughError)+ walkThroughError, ok := err.(*catalogutil.WalkThroughError)if !ok {return nil, err}diff --git a/backend/plugin/advisor/catalog/walk_through.go b/backend/plugin/schema/catalogutil/types.gosimilarity index 65%rename from backend/plugin/advisor/catalog/walk_through.gorename to backend/plugin/schema/catalogutil/types.goindex b9e696e201..c8b3c1e598 100644--- a/backend/plugin/advisor/catalog/walk_through.go+++ b/backend/plugin/schema/catalogutil/types.go@@ -1,25 +1,10 @@-package catalog+package catalogutilimport ("fmt""strings"- "github.com/pkg/errors"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor/code"- "github.com/bytebase/bytebase/backend/store/model"-)--const (- // PrimaryKeyName is the string for PK.- PrimaryKeyName string = "PRIMARY"- // FullTextName is the string for FULLTEXT.- FullTextName string = "FULLTEXT"- // SpatialName is the string for SPATIAL.- SpatialName string = "SPATIAL"-- publicSchemaName = "public")// WalkThroughError is the error for walking-through.@@ -31,6 +16,20 @@ type WalkThroughError struct {Line int}+// Error implements the error interface.+func (e *WalkThroughError) Error() string {+ return e.Content+}++// CompareIdentifier returns true if the engine will regard the two identifiers as the same one.+// This is kept in catalogutil for the isCurrentDatabase helper functions in engine packages.+func CompareIdentifier(a, b string, ignoreCaseSensitive bool) bool {+ if ignoreCaseSensitive {+ return strings.EqualFold(a, b)+ }+ return a == b+}+// NewRelationExistsError returns a new RelationExists error.func NewRelationExistsError(relationName string, schemaName string) *WalkThroughError {return &WalkThroughError{@@ -86,35 +85,3 @@ func NewTableExistsError(tableName string) *WalkThroughError {Content: fmt.Sprintf("Table `%s` already exists", tableName),}}--// Error implements the error interface.-func (e *WalkThroughError) Error() string {- return e.Content-}--// WalkThrough will collect the catalog schema in the database metadata as it walks through the stmt.-func WalkThrough(d *model.DatabaseMetadata, engineType storepb.Engine, ast any) error {- switch engineType {- case storepb.Engine_TIDB:- return TiDBWalkThrough(d, ast)- case storepb.Engine_MYSQL, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:- return MySQLWalkThrough(d, ast)- case storepb.Engine_POSTGRES:- return PgWalkThrough(d, ast)- default:- return errors.Errorf("Walk-through doesn't support engine type: %s", engineType)- }-}--// compareIdentifier returns true if the engine will regard the two identifiers as the same one.-func compareIdentifier(a, b string, ignoreCaseSensitive bool) bool {- if ignoreCaseSensitive {- return strings.EqualFold(a, b)- }- return a == b-}--// isCurrentDatabase returns true if the given database is the current database.-func isCurrentDatabase(d *model.DatabaseMetadata, database string) bool {- return compareIdentifier(d.DatabaseName(), database, !d.GetIsObjectCaseSensitive())-}diff --git a/backend/plugin/advisor/catalog/test/mysql_walk_through.yaml b/backend/plugin/schema/mysql/testdata/walk_through.yamlsimilarity index 100%rename from backend/plugin/advisor/catalog/test/mysql_walk_through.yamlrename to backend/plugin/schema/mysql/testdata/walk_through.yamldiff --git a/backend/plugin/advisor/catalog/walk_through_for_mysql.go b/backend/plugin/schema/mysql/walk_through.gosimilarity index 85%rename from backend/plugin/advisor/catalog/walk_through_for_mysql.gorename to backend/plugin/schema/mysql/walk_through.goindex eff1866c23..2a424a23b0 100644--- a/backend/plugin/advisor/catalog/walk_through_for_mysql.go+++ b/backend/plugin/schema/mysql/walk_through.go@@ -1,4 +1,4 @@-package catalog+package mysqlimport ("fmt"@@ -7,6 +7,8 @@ import ("github.com/antlr4-go/antlr/v4""github.com/bytebase/parser/mysql"tidbast "github.com/pingcap/tidb/pkg/parser/ast"+ mysqldriver "github.com/pingcap/tidb/pkg/parser/mysql"+ "github.com/pingcap/tidb/pkg/types""github.com/pkg/errors""google.golang.org/protobuf/proto"@@ -14,11 +16,28 @@ import ("github.com/bytebase/bytebase/backend/plugin/advisor/code"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql""github.com/bytebase/bytebase/backend/plugin/parser/tidb"+ "github.com/bytebase/bytebase/backend/plugin/schema"+ "github.com/bytebase/bytebase/backend/plugin/schema/catalogutil""github.com/bytebase/bytebase/backend/store/model")-// MySQLWalkThrough walks through MySQL AST and updates the database metadata.-func MySQLWalkThrough(d *model.DatabaseMetadata, ast any) error {+const (+ // PrimaryKeyName is the string for PK.+ PrimaryKeyName string = "PRIMARY"+ // FullTextName is the string for FULLTEXT.+ FullTextName string = "FULLTEXT"+ // SpatialName is the string for SPATIAL.+ SpatialName string = "SPATIAL"+)++func init() {+ schema.RegisterWalkThrough(storepb.Engine_MYSQL, WalkThrough)+ schema.RegisterWalkThrough(storepb.Engine_MARIADB, WalkThrough)+ schema.RegisterWalkThrough(storepb.Engine_OCEANBASE, WalkThrough)+}++// WalkThrough walks through MySQL AST and updates the database metadata.+func WalkThrough(d *model.DatabaseMetadata, ast any) error {// We define the Catalog as Database -> Schema -> Table. The Schema is only for PostgreSQL.// So we use a Schema whose name is empty for other engines, such as MySQL.// If there is no empty-string-name schema, create it to avoid corner cases.@@ -46,7 +65,7 @@ type mysqlListener struct {lineNumber inttext stringdatabaseMetadata *model.DatabaseMetadata- err *WalkThroughError+ err *catalogutil.WalkThroughError}func (l *mysqlListener) EnterQuery(ctx *mysql.QueryContext) {@@ -54,7 +73,7 @@ func (l *mysqlListener) EnterQuery(ctx *mysql.QueryContext) {l.lineNumber = l.baseLine + ctx.GetStart().GetLine()}-func mysqlChangeState(d *model.DatabaseMetadata, in *mysqlparser.ParseResult) (err *WalkThroughError) {+func mysqlChangeState(d *model.DatabaseMetadata, in *mysqlparser.ParseResult) (err *catalogutil.WalkThroughError) {defer func() {if err == nil {return@@ -88,7 +107,7 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {}databaseName, tableName := mysqlparser.NormalizeMySQLTableName(ctx.TableName())if databaseName != "" && !isCurrentDatabase(l.databaseMetadata, databaseName) {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database `%s` is not the current database `%s`", databaseName, l.databaseMetadata.DatabaseName()),}@@ -97,7 +116,7 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {schema := l.databaseMetadata.GetSchema("")if schema == nil {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: "Schema does not exist",}@@ -107,7 +126,7 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {if ctx.IfNotExists() != nil {return}- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.TableExists,Content: fmt.Sprintf("Table `%s` already exists", tableName),}@@ -115,7 +134,7 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {}if ctx.DuplicateAsQueryExpression() != nil {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.StatementCreateTableAs,Content: fmt.Sprintf("Disallow the CREATE TABLE AS statement but \"%s\" uses", l.text),}@@ -130,7 +149,7 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {table, err := schema.CreateTable(tableName)if err != nil {- l.err = &WalkThroughError{Code: code.TableExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.TableExists, Content: err.Error()}return}@@ -148,7 +167,7 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {}if mysqlparser.IsAutoIncrement(tableElement.ColumnDefinition().FieldDefinition()) {if hasAutoIncrement {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.AutoIncrementExists,// The content comes from MySQL error content.Content: fmt.Sprintf("There can be only one auto column for table `%s`", table.GetProto().Name),@@ -186,7 +205,7 @@ func (l *mysqlListener) EnterDropTable(ctx *mysql.DropTableContext) {for _, tableRef := range ctx.TableRefList().AllTableRef() {databaseName, tableName := mysqlparser.NormalizeMySQLTableRef(tableRef)if databaseName != "" && !isCurrentDatabase(l.databaseMetadata, databaseName) {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database `%s` is not the current database `%s`", databaseName, tableName),}@@ -194,7 +213,7 @@ func (l *mysqlListener) EnterDropTable(ctx *mysql.DropTableContext) {schema := l.databaseMetadata.GetSchema("")if schema == nil {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: "Schema does not exist",}@@ -206,7 +225,7 @@ func (l *mysqlListener) EnterDropTable(ctx *mysql.DropTableContext) {if ctx.IfExists() != nil {return}- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.TableNotExists,Content: fmt.Sprintf("Table `%s` does not exist", tableName),}@@ -215,7 +234,7 @@ func (l *mysqlListener) EnterDropTable(ctx *mysql.DropTableContext) {// MySQL doesn't check view dependencies for DROP TABLEif err := schema.DropTable(tableName); err != nil {- l.err = &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}return}}@@ -319,24 +338,24 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {columnName := mysqlparser.NormalizeMySQLColumnInternalRef(item.ColumnInternalRef())// Validate column existsif table.GetColumn(columnName) == nil {- l.err = NewColumnNotExistsError(table.GetProto().Name, columnName)+ l.err = catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName)return}if err := table.DropColumn(columnName); err != nil {- l.err = &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)}+ l.err = &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)}return}// drop primary key.case item.PRIMARY_SYMBOL() != nil && item.KEY_SYMBOL() != nil:if err := table.DropIndex(PrimaryKeyName); err != nil {- l.err = &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}return}// drop key/index.case item.KeyOrIndex() != nil && item.IndexRef() != nil:_, _, indexName := mysqlparser.NormalizeIndexRef(item.IndexRef())if err := table.DropIndex(indexName); err != nil {- l.err = &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}return}default:@@ -363,19 +382,19 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {newColumnName := mysqlparser.NormalizeMySQLIdentifier(item.Identifier())// Validate old column existsif table.GetColumn(oldColumnName) == nil {- l.err = NewColumnNotExistsError(table.GetProto().Name, oldColumnName)+ l.err = catalogutil.NewColumnNotExistsError(table.GetProto().Name, oldColumnName)return}// Validate new column doesn't already existif table.GetColumn(newColumnName) != nil {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("Column `%s` already exists in table `%s`", newColumnName, table.GetProto().Name),}return}if err := table.RenameColumn(oldColumnName, newColumnName); err != nil {- l.err = &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}+ l.err = &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}return}case item.ALTER_SYMBOL() != nil:@@ -400,14 +419,14 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {_, newTableName := mysqlparser.NormalizeMySQLTableName(item.TableName())schema := l.databaseMetadata.GetSchema("")if schema == nil {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: "Schema does not exist",}return}if err := schema.RenameTable(table.GetProto().Name, newTableName); err != nil {- l.err = &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}return}// rename index.@@ -415,7 +434,7 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {_, _, oldIndexName := mysqlparser.NormalizeIndexRef(item.IndexRef())newIndexName := mysqlparser.NormalizeIndexName(item.IndexName())if err := table.RenameIndex(oldIndexName, newIndexName); err != nil {- l.err = &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}return}default:@@ -445,7 +464,7 @@ func (l *mysqlListener) EnterDropIndex(ctx *mysql.DropIndexContext) {_, _, indexName := mysqlparser.NormalizeIndexRef(ctx.IndexRef())if err := table.DropIndex(indexName); err != nil {- l.err = &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}}@@ -515,7 +534,7 @@ func (l *mysqlListener) EnterAlterDatabase(ctx *mysql.AlterDatabaseContext) {if ctx.SchemaRef() != nil {databaseName := mysqlparser.NormalizeMySQLSchemaRef(ctx.SchemaRef())if !isCurrentDatabase(l.databaseMetadata, databaseName) {- l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)+ l.err = catalogutil.NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)return}}@@ -549,7 +568,7 @@ func (l *mysqlListener) EnterDropDatabase(ctx *mysql.DropDatabaseContext) {databaseName := mysqlparser.NormalizeMySQLSchemaRef(ctx.SchemaRef())if !isCurrentDatabase(l.databaseMetadata, databaseName) {- l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)+ l.err = catalogutil.NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)return}@@ -565,7 +584,7 @@ func (l *mysqlListener) EnterCreateDatabase(ctx *mysql.CreateDatabaseContext) {return}databaseName := mysqlparser.NormalizeMySQLSchemaName(ctx.SchemaName())- l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)+ l.err = catalogutil.NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)}// EnterRenameTableStatement is called when production renameTableStatement is entered.@@ -576,7 +595,7 @@ func (l *mysqlListener) EnterRenameTableStatement(ctx *mysql.RenameTableStatemenfor _, pair := range ctx.AllRenamePair() {schema := l.databaseMetadata.GetSchema("")if schema == nil {- l.err = &WalkThroughError{+ l.err = &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: "Schema does not exist",}@@ -591,28 +610,28 @@ func (l *mysqlListener) EnterRenameTableStatement(ctx *mysql.RenameTableStatemenreturn}if schema.GetTable(oldTableName) == nil {- l.err = NewTableNotExistsError(oldTableName)+ l.err = catalogutil.NewTableNotExistsError(oldTableName)return}if schema.GetTable(newTableName) != nil {- l.err = NewTableExistsError(newTableName)+ l.err = catalogutil.NewTableExistsError(newTableName)return}if err := schema.RenameTable(oldTableName, newTableName); err != nil {- l.err = &WalkThroughError{Code: code.Internal, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.Internal, Content: err.Error()}return}} else if mysqlMoveToOtherDatabase(l.databaseMetadata, pair) {if schema.GetTable(oldTableName) == nil {- l.err = NewTableNotExistsError(oldTableName)+ l.err = catalogutil.NewTableNotExistsError(oldTableName)return}if err := schema.DropTable(oldTableName); err != nil {- l.err = &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ l.err = &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}return}} else {- l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), mysqlTargetDatabase(l.databaseMetadata, pair))+ l.err = catalogutil.NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), mysqlTargetDatabase(l.databaseMetadata, pair))return}}@@ -688,10 +707,10 @@ func mysqlTheCurrentDatabase(d *model.DatabaseMetadata, renamePair mysql.IRenamereturn true}-func mysqlChangeIndexVisibility(table *model.TableMetadata, indexName string, visibility mysql.IVisibilityContext) *WalkThroughError {+func mysqlChangeIndexVisibility(table *model.TableMetadata, indexName string, visibility mysql.IVisibilityContext) *catalogutil.WalkThroughError {index := table.GetIndex(indexName)if index == nil {- return NewIndexNotExistsError(table.GetProto().Name, indexName)+ return catalogutil.NewIndexNotExistsError(table.GetProto().Name, indexName)}indexProto := index.GetProto()switch {@@ -705,7 +724,7 @@ func mysqlChangeIndexVisibility(table *model.TableMetadata, indexName string, vireturn nil}-func mysqlAlterColumn(table *model.TableMetadata, itemDef mysql.IAlterListItemContext) *WalkThroughError {+func mysqlAlterColumn(table *model.TableMetadata, itemDef mysql.IAlterListItemContext) *catalogutil.WalkThroughError {if itemDef.ColumnInternalRef() == nil {// should not reach here.return nil@@ -713,7 +732,7 @@ func mysqlAlterColumn(table *model.TableMetadata, itemDef mysql.IAlterListItemCocolumnName := mysqlparser.NormalizeMySQLColumnInternalRef(itemDef.ColumnInternalRef())col := table.GetColumn(columnName)if col == nil {- return NewColumnNotExistsError(table.GetProto().Name, columnName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName)}switch {@@ -728,7 +747,7 @@ func mysqlAlterColumn(table *model.TableMetadata, itemDef mysql.IAlterListItemCo"text", "tinytext", "mediumtext", "longtext","json","geometry":- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.InvalidColumnDefault,// Content comes from MySQL Error content.Content: fmt.Sprintf("BLOB, TEXT, GEOMETRY or JSON column `%s` can't have a default value", columnName),@@ -751,7 +770,7 @@ func mysqlAlterColumn(table *model.TableMetadata, itemDef mysql.IAlterListItemCocol.Default = defaultValue} else {if !col.Nullable {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.Content: fmt.Sprintf("Invalid default value for column `%s`", columnName),@@ -777,23 +796,23 @@ func mysqlAlterColumn(table *model.TableMetadata, itemDef mysql.IAlterListItemCo// 1. rename column if name changed// 2. update column properties from fieldDef// 3. handle position changes by reordering columns in the table-func mysqlChangeColumn(table *model.TableMetadata, oldColumnName string, newColumnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *WalkThroughError {+func mysqlChangeColumn(table *model.TableMetadata, oldColumnName string, newColumnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *catalogutil.WalkThroughError {column := table.GetColumn(oldColumnName)if column == nil {- return NewColumnNotExistsError(table.GetProto().Name, oldColumnName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, oldColumnName)}// If renaming, validate and use RenameColumnif oldColumnName != newColumnName {// Validate new column doesn't already existif table.GetColumn(newColumnName) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("Column `%s` already exists in table `%s`", newColumnName, table.GetProto().Name),}}if err := table.RenameColumn(oldColumnName, newColumnName); err != nil {- return &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}}// Get the renamed columncolumn = table.GetColumn(newColumnName)@@ -913,7 +932,7 @@ func positionFromPlaceContext(place mysql.IPlaceContext) *mysqlColumnPosition {return columnPosition}-func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTable string) *WalkThroughError {+func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTable string) *catalogutil.WalkThroughError {targetTable, err := mysqlFindTableState(d, databaseName, referTable)if err != nil {return err@@ -921,7 +940,7 @@ func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTabschema := d.GetSchema("")if schema == nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: "Schema does not exist",}@@ -930,7 +949,7 @@ func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTab// Create the new tablenewTable, createErr := schema.CreateTable(tableName)if createErr != nil {- return &WalkThroughError{Code: code.TableExists, Content: createErr.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableExists, Content: createErr.Error()}}// Copy table properties@@ -944,10 +963,10 @@ func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTabfor _, col := range targetTable.GetColumns() {colCopy, ok := proto.Clone(col).(*storepb.ColumnMetadata)if !ok {- return &WalkThroughError{Code: code.Internal, Content: "failed to clone column metadata"}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: "failed to clone column metadata"}}if err := newTable.CreateColumn(colCopy); err != nil {- return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.ColumnExists, Content: err.Error()}}}@@ -955,24 +974,24 @@ func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTabfor _, idx := range targetProto.Indexes {idxCopy, ok := proto.Clone(idx).(*storepb.IndexMetadata)if !ok {- return &WalkThroughError{Code: code.Internal, Content: "failed to clone index metadata"}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: "failed to clone index metadata"}}if err := newTable.CreateIndex(idxCopy); err != nil {- return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()}}}return nil}-func mysqlFindTableState(d *model.DatabaseMetadata, databaseName, tableName string) (*model.TableMetadata, *WalkThroughError) {+func mysqlFindTableState(d *model.DatabaseMetadata, databaseName, tableName string) (*model.TableMetadata, *catalogutil.WalkThroughError) {if databaseName != "" && !isCurrentDatabase(d, databaseName) {- return nil, NewAccessOtherDatabaseError(d.DatabaseName(), databaseName)+ return nil, catalogutil.NewAccessOtherDatabaseError(d.DatabaseName(), databaseName)}schema := d.GetSchema("")if schema == nil {- return nil, &WalkThroughError{+ return nil, &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: "Schema does not exist",}@@ -980,13 +999,13 @@ func mysqlFindTableState(d *model.DatabaseMetadata, databaseName, tableName stritable := schema.GetTable(tableName)if table == nil {- return nil, NewTableNotExistsError(tableName)+ return nil, catalogutil.NewTableNotExistsError(tableName)}return table, nil}-func mysqlCreateConstraint(table *model.TableMetadata, constraintDef mysql.ITableConstraintDefContext) *WalkThroughError {+func mysqlCreateConstraint(table *model.TableMetadata, constraintDef mysql.ITableConstraintDefContext) *catalogutil.WalkThroughError {if constraintDef.GetType_() != nil {switch constraintDef.GetType_().GetTokenType() {// PRIMARY KEY.@@ -1071,7 +1090,7 @@ func mysqlCreateConstraint(table *model.TableMetadata, constraintDef mysql.ITabl}// mysqlValidateKeyListVariants validates the key list variants.-func mysqlValidateKeyListVariants(table *model.TableMetadata, keyList mysql.IKeyListVariantsContext, primary bool, isSpatial bool) *WalkThroughError {+func mysqlValidateKeyListVariants(table *model.TableMetadata, keyList mysql.IKeyListVariantsContext, primary bool, isSpatial bool) *catalogutil.WalkThroughError {if keyList.KeyList() != nil {columns := mysqlparser.NormalizeKeyList(keyList.KeyList())if err := mysqlValidateColumnList(table, columns, primary, isSpatial); err != nil {@@ -1087,17 +1106,17 @@ func mysqlValidateKeyListVariants(table *model.TableMetadata, keyList mysql.IKeyreturn nil}-func mysqlValidateColumnList(table *model.TableMetadata, columnList []string, primary bool, isSpatial bool) *WalkThroughError {+func mysqlValidateColumnList(table *model.TableMetadata, columnList []string, primary bool, isSpatial bool) *catalogutil.WalkThroughError {for _, columnName := range columnList {column := table.GetColumn(columnName)if column == nil {- return NewColumnNotExistsError(table.GetProto().Name, columnName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName)}if primary {column.Nullable = false}if isSpatial && column.Nullable {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SpatialIndexKeyNullable,// The error content comes from MySQL.Content: fmt.Sprintf("All parts of a SPATIAL index must be NOT NULL, but `%s` is nullable", column.Name),@@ -1109,7 +1128,7 @@ func mysqlValidateColumnList(table *model.TableMetadata, columnList []string, pr// mysqlValidateExpressionList validates the expression list.// TODO: update expression validation.-func mysqlValidateExpressionList(table *model.TableMetadata, expressionList []string, primary bool, isSpatial bool) *WalkThroughError {+func mysqlValidateExpressionList(table *model.TableMetadata, expressionList []string, primary bool, isSpatial bool) *catalogutil.WalkThroughError {for _, expression := range expressionList {column := table.GetColumn(expression)// If expression is not a column, we do not need to validate it.@@ -1121,7 +1140,7 @@ func mysqlValidateExpressionList(table *model.TableMetadata, expressionList []stcolumn.Nullable = false}if isSpatial && column.Nullable {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SpatialIndexKeyNullable,// The error content comes from MySQL.Content: fmt.Sprintf("All parts of a SPATIAL index must be NOT NULL, but `%s` is nullable", column.Name),@@ -1169,9 +1188,9 @@ func mysqlGetIndexType(tableConstraint mysql.ITableConstraintDefContext) stringreturn "BTREE"}-func mysqlCreateColumn(table *model.TableMetadata, columnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *WalkThroughError {+func mysqlCreateColumn(table *model.TableMetadata, columnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *catalogutil.WalkThroughError {if table.GetColumn(columnName) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("Column `%s` already exists in table `%s`", columnName, table.GetProto().Name),}@@ -1242,7 +1261,7 @@ func mysqlCreateColumn(table *model.TableMetadata, columnName string, fieldDef mcontinue}if !mysqlparser.IsTimeType(fieldDef.DataType()) {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.OnUpdateColumnNotDatetimeOrTimestamp,Content: fmt.Sprintf("Column `%s` use ON UPDATE but is not DATETIME or TIMESTAMP", col.Name),}@@ -1277,7 +1296,7 @@ func mysqlCreateColumn(table *model.TableMetadata, columnName string, fieldDef m}if !col.Nullable && setNullDefault {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.Content: fmt.Sprintf("Invalid default value for column `%s`", col.Name),@@ -1285,7 +1304,7 @@ func mysqlCreateColumn(table *model.TableMetadata, columnName string, fieldDef m}if err := table.CreateColumn(col); err != nil {- return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.ColumnExists, Content: err.Error()}}// Handle position by reordering columns in the proto@@ -1337,9 +1356,9 @@ func mysqlCreateColumn(table *model.TableMetadata, columnName string, fieldDef mreturn nil}-func mysqlCreateIndex(table *model.TableMetadata, name string, keyList []string, unique bool, tp string, tableConstraint mysql.ITableConstraintDefContext, createIndexDef mysql.ICreateIndexContext) *WalkThroughError {+func mysqlCreateIndex(table *model.TableMetadata, name string, keyList []string, unique bool, tp string, tableConstraint mysql.ITableConstraintDefContext, createIndexDef mysql.ICreateIndexContext) *catalogutil.WalkThroughError {if len(keyList) == 0 {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.IndexEmptyKeys,Content: fmt.Sprintf("Index `%s` in table `%s` has empty key", name, table.GetProto().Name),}@@ -1347,7 +1366,7 @@ func mysqlCreateIndex(table *model.TableMetadata, name string, keyList []string,// construct a index name if name is empty.if name != "" {if table.GetIndex(name) != nil {- return NewIndexExistsError(table.GetProto().Name, name)+ return catalogutil.NewIndexExistsError(table.GetProto().Name, name)}} else {suffix := 1@@ -1433,14 +1452,14 @@ func mysqlCreateIndex(table *model.TableMetadata, name string, keyList []string,}if err := table.CreateIndex(index); err != nil {- return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()}}return nil}-func mysqlCreatePrimaryKey(table *model.TableMetadata, keys []string, tp string) *WalkThroughError {+func mysqlCreatePrimaryKey(table *model.TableMetadata, keys []string, tp string) *catalogutil.WalkThroughError {if table.GetPrimaryKey() != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.PrimaryKeyExists,Content: fmt.Sprintf("Primary key exists in table `%s`", table.GetProto().Name),}@@ -1455,12 +1474,12 @@ func mysqlCreatePrimaryKey(table *model.TableMetadata, keys []string, tp string)Visible: true,}if err := table.CreateIndex(pk); err != nil {- return &WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}}return nil}-func mysqlCheckDefault(_ *model.TableMetadata, columnName string, fieldDefinition mysql.IFieldDefinitionContext) *WalkThroughError {+func mysqlCheckDefault(_ *model.TableMetadata, columnName string, fieldDefinition mysql.IFieldDefinitionContext) *catalogutil.WalkThroughError {if fieldDefinition.DataType() == nil || fieldDefinition.DataType().GetType_() == nil {return nil}@@ -1485,7 +1504,7 @@ func mysqlCheckDefault(_ *model.TableMetadata, columnName string, fieldDefinitiomysql.MySQLParserMULTILINESTRING_SYMBOL,mysql.MySQLParserPOLYGON_SYMBOL,mysql.MySQLParserMULTIPOLYGON_SYMBOL:- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.InvalidColumnDefault,// Content comes from MySQL Error content.Content: fmt.Sprintf("BLOB, TEXT, GEOMETRY or JSON column `%s` can't have a default value", columnName),@@ -1497,7 +1516,7 @@ func mysqlCheckDefault(_ *model.TableMetadata, columnName string, fieldDefinitioreturn checkDefaultConvert(columnName, fieldDefinition)}-func checkDefaultConvert(columnName string, fieldDefinition mysql.IFieldDefinitionContext) *WalkThroughError {+func checkDefaultConvert(columnName string, fieldDefinition mysql.IFieldDefinitionContext) *catalogutil.WalkThroughError {if fieldDefinition == nil {return nil}@@ -1526,3 +1545,42 @@ func checkDefaultConvert(columnName string, fieldDefinition mysql.IFieldDefinitireturn nil}++func checkDefault(columnName string, columnType *types.FieldType, value tidbast.ExprNode) *catalogutil.WalkThroughError {+ if value.GetType().GetType() != mysqldriver.TypeNull {+ switch columnType.GetType() {+ case mysqldriver.TypeBlob, mysqldriver.TypeTinyBlob, mysqldriver.TypeMediumBlob, mysqldriver.TypeLongBlob, mysqldriver.TypeJSON, mysqldriver.TypeGeometry:+ return &catalogutil.WalkThroughError{+ Code: code.InvalidColumnDefault,+ // Content comes from MySQL Error content.+ Content: fmt.Sprintf("BLOB, TEXT, GEOMETRY or JSON column `%s` can't have a default value", columnName),+ }+ default:+ // Other column types allow default values+ }+ }++ if valueExpr, yes := value.(tidbast.ValueExpr); yes {+ datum := types.NewDatum(valueExpr.GetValue())+ if _, err := datum.ConvertTo(types.Context{}, columnType); err != nil {+ return &catalogutil.WalkThroughError{+ Code: code.InvalidColumnDefault,+ Content: err.Error(),+ }+ }+ }+ return nil+}++// compareIdentifier returns true if the engine will regard the two identifiers as the same one.+func compareIdentifier(a, b string, ignoreCaseSensitive bool) bool {+ if ignoreCaseSensitive {+ return strings.EqualFold(a, b)+ }+ return a == b+}++// isCurrentDatabase returns true if the given database is the current database.+func isCurrentDatabase(d *model.DatabaseMetadata, database string) bool {+ return compareIdentifier(d.DatabaseName(), database, !d.GetIsObjectCaseSensitive())+}diff --git a/backend/plugin/schema/mysql/walk_through_test.go b/backend/plugin/schema/mysql/walk_through_test.gonew file mode 100644index 0000000000..1760c812fa--- /dev/null+++ b/backend/plugin/schema/mysql/walk_through_test.go@@ -0,0 +1,79 @@+package mysql++import (+ "io"+ "os"+ "path/filepath"+ "testing"++ "github.com/google/go-cmp/cmp"+ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto"+ "google.golang.org/protobuf/testing/protocmp"+ "gopkg.in/yaml.v3"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/component/sheet"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema/catalogutil"+ "github.com/bytebase/bytebase/backend/store/model"+)++type testData struct {+ Statement string+ // Use custom yaml tag to avoid generate field name `ignorecasesensitive`.+ IgnoreCaseSensitive bool `yaml:"ignore_case_sensitive"`+ Want string+ Err *catalogutil.WalkThroughError+}++func TestWalkThrough(t *testing.T) {+ originDatabase := &storepb.DatabaseSchemaMetadata{+ Name: "test",+ }++ tests := []testData{}+ filepath := filepath.Join("testdata", "walk_through.yaml")+ yamlFile, err := os.Open(filepath)+ require.NoError(t, err)+ defer yamlFile.Close()++ byteValue, err := io.ReadAll(yamlFile)+ require.NoError(t, err)+ err = yaml.Unmarshal(byteValue, &tests)+ require.NoError(t, err)+ sm := sheet.NewManager(nil)++ for _, test := range tests {+ // Make a deep copy to avoid mutation across tests+ protoData, ok := proto.Clone(originDatabase).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok)++ // Create DatabaseMetadata for walk-through+ state := model.NewDatabaseMetadata(protoData, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)++ asts, _ := sm.GetASTsForChecks(storepb.Engine_MYSQL, test.Statement)+ err := WalkThrough(state, asts)+ if err != nil {+ walkErr, yes := err.(*catalogutil.WalkThroughError)+ require.True(t, yes)+ require.Equal(t, test.Err, walkErr)+ continue+ }+ require.NoError(t, err, test.Statement)++ // Skip comparison if want is empty (error cases)+ if test.Want == "" {+ continue+ }++ want := &storepb.DatabaseSchemaMetadata{}+ err = common.ProtojsonUnmarshaler.Unmarshal([]byte(test.Want), want)+ require.NoError(t, err)+ // Sort proto for deterministic comparison+ state.SortProto()+ result := state.GetProto()+ diff := cmp.Diff(want, result, protocmp.Transform())+ require.Empty(t, diff)+ }+}diff --git a/backend/plugin/advisor/catalog/test/pg_walk_through.yaml b/backend/plugin/schema/pg/testdata/walk_through.yamlsimilarity index 100%rename from backend/plugin/advisor/catalog/test/pg_walk_through.yamlrename to backend/plugin/schema/pg/testdata/walk_through.yamldiff --git a/backend/plugin/advisor/catalog/walk_through_for_pg.go b/backend/plugin/schema/pg/walk_through.gosimilarity index 87%rename from backend/plugin/advisor/catalog/walk_through_for_pg.gorename to backend/plugin/schema/pg/walk_through.goindex beba5181d7..c38689d05c 100644--- a/backend/plugin/advisor/catalog/walk_through_for_pg.go+++ b/backend/plugin/schema/pg/walk_through.go@@ -1,4 +1,4 @@-package catalog+package pgimport ("fmt"@@ -11,11 +11,22 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor/code"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/schema"+ "github.com/bytebase/bytebase/backend/plugin/schema/catalogutil""github.com/bytebase/bytebase/backend/store/model")-// PgWalkThrough walks through the PostgreSQL ANTLR parse tree and builds catalog metadata.-func PgWalkThrough(d *model.DatabaseMetadata, ast any) error {+const (+ // PublicSchemaName is the default schema name for PostgreSQL.+ PublicSchemaName = "public"+)++func init() {+ schema.RegisterWalkThrough(storepb.Engine_POSTGRES, WalkThrough)+}++// WalkThrough walks through the PostgreSQL ANTLR parse tree and builds catalog metadata.+func WalkThrough(d *model.DatabaseMetadata, ast any) error {// ANTLR-based walkthroughparseResult, ok := ast.(*pgparser.ParseResult)if !ok {@@ -43,12 +54,12 @@ func PgWalkThrough(d *model.DatabaseMetadata, ast any) error {type pgCatalogListener struct {*parser.BasePostgreSQLParserListenerdatabaseState *model.DatabaseMetadata- err *WalkThroughError+ err *catalogutil.WalkThroughErrorcurrentLine int}// Helper method to set error with line number-func (l *pgCatalogListener) setError(err *WalkThroughError) {+func (l *pgCatalogListener) setError(err *catalogutil.WalkThroughError) {if l.err != nil {return // Keep first error}@@ -80,7 +91,7 @@ func (l *pgCatalogListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {// Check database name if specifieddatabaseName := extractDatabaseName(qualifiedNames[0])if databaseName != "" && l.databaseState.DatabaseName() != databaseName {- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.DatabaseName()),})@@ -99,7 +110,7 @@ func (l *pgCatalogListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {if ifNotExists {return}- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.TableExists,Content: fmt.Sprintf(`The table %q already exists in the schema %q`, tableName, schema.GetProto().Name),})@@ -108,7 +119,7 @@ func (l *pgCatalogListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {// Create tabletable, createErr := schema.CreateTable(tableName)if createErr != nil {- l.setError(&WalkThroughError{Code: code.TableExists, Content: createErr.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.TableExists, Content: createErr.Error()})return}// Process column definitions@@ -134,7 +145,7 @@ func (l *pgCatalogListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {}// pgCreateColumn creates a column in the table.-func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, columnDef parser.IColumnDefContext) *WalkThroughError {+func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, columnDef parser.IColumnDefContext) *catalogutil.WalkThroughError {if columnDef == nil {return nil}@@ -148,7 +159,7 @@ func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, co}// Check if column already existsif table.GetColumn(columnName) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("The column %q already exists in table %q", columnName, table.GetProto().Name),}@@ -156,7 +167,7 @@ func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, co// Get column typevar columnType stringif columnDef.Typename() != nil {- columnType = extractTypeName(columnDef.Typename())+ columnType = extractTypeNameFromContext(columnDef.Typename())}// Create column metadatacol := &storepb.ColumnMetadata{@@ -207,7 +218,7 @@ func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, coIsConstraint: true,}if err := table.CreateIndex(index); err != nil {- return &WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}}}// Handle UNIQUE@@ -229,20 +240,20 @@ func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, coIsConstraint: true,}if err := table.CreateIndex(index); err != nil {- return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()}}}}}// Create the columnif err := table.CreateColumn(col); err != nil {- return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.ColumnExists, Content: err.Error()}}return nil}// createTableConstraint creates a table-level constraint.-func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetadata, constraint parser.ITableconstraintContext) *WalkThroughError {+func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetadata, constraint parser.ITableconstraintContext) *catalogutil.WalkThroughError {if constraint == nil || constraint.Constraintelem() == nil {return nil}@@ -270,7 +281,7 @@ func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetadif column != nil {column.Nullable = false} else {- return NewColumnNotExistsError(table.GetProto().Name, colName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, colName)}}// Generate PK name if not provided@@ -280,7 +291,7 @@ func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetad}// Check if primary key already existsif table.GetPrimaryKey() != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.PrimaryKeyExists,Content: fmt.Sprintf("Primary key already exists in table %q", table.GetProto().Name),}@@ -295,7 +306,7 @@ func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetadIsConstraint: true,}if err := table.CreateIndex(index); err != nil {- return &WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}}}// Handle UNIQUE constraint@@ -317,7 +328,7 @@ func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetad}// Check if index already existsif table.GetIndex(indexName) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.IndexExists,Content: fmt.Sprintf("Index %q already exists in table %q", indexName, table.GetProto().Name),}@@ -325,7 +336,7 @@ func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetad// Validate columns existfor _, colName := range columnList {if table.GetColumn(colName) == nil {- return NewColumnNotExistsError(table.GetProto().Name, colName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, colName)}}// Create unique index (from UNIQUE constraint)@@ -338,7 +349,7 @@ func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetadIsConstraint: true,}if err := table.CreateIndex(index); err != nil {- return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()}}}// Note: We skip CHECK, FOREIGN KEY, EXCLUSION constraints for now@@ -369,7 +380,7 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {}table := schema.GetTable(tableName)if table == nil {- l.setError(NewTableNotExistsError(tableName))+ l.setError(catalogutil.NewTableNotExistsError(tableName))return}// Extract index name (can be empty for auto-generated names)@@ -394,7 +405,7 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {}}if len(columnList) == 0 {- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.IndexEmptyKeys,Content: fmt.Sprintf("Index %q in table %q has empty key", indexName, tableName),})@@ -415,7 +426,7 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {if wasAutoGenerated {indexName = generateUniqueIndexName(schema, tableName, columnList, isUnique)} else {- l.setError(NewRelationExistsError(indexName, schema.GetProto().Name))+ l.setError(catalogutil.NewRelationExistsError(indexName, schema.GetProto().Name))return}}@@ -423,7 +434,7 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {for _, colName := range columnList {if colName != "expr" {if table.GetColumn(colName) == nil {- l.setError(NewColumnNotExistsError(tableName, colName))+ l.setError(catalogutil.NewColumnNotExistsError(tableName, colName))return}}@@ -443,7 +454,7 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {Primary: false,}if err := table.CreateIndex(index); err != nil {- l.setError(&WalkThroughError{Code: code.IndexExists, Content: err.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()})}}@@ -485,7 +496,7 @@ func (l *pgCatalogListener) EnterAltertablestmt(ctx *parser.AltertablestmtContexdatabaseName := extractDatabaseName(ctx.Relation_expr().Qualified_name())// Check database accessif databaseName != "" && l.databaseState.DatabaseName() != databaseName {- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.DatabaseName()),})@@ -499,7 +510,7 @@ func (l *pgCatalogListener) EnterAltertablestmt(ctx *parser.AltertablestmtContex}table := schema.GetTable(tableName)if table == nil {- l.setError(NewTableNotExistsError(tableName))+ l.setError(catalogutil.NewTableNotExistsError(tableName))return}// Process alter table commands@@ -558,7 +569,7 @@ func (l *pgCatalogListener) processAlterTableCmd(schema *model.SchemaMetadata, tcolumnName := pgparser.NormalizePostgreSQLColid(allColids[0])// Check for SET DATA TYPEif cmd.TYPE_P() != nil && cmd.Typename() != nil {- typeString := extractTypeName(cmd.Typename())+ typeString := extractTypeNameFromContext(cmd.Typename())l.alterTableAlterColumnType(schema, table, columnName, typeString)return}@@ -592,7 +603,7 @@ func (l *pgCatalogListener) alterTableDropColumn(schema *model.SchemaMetadata, tif ifExists {return}- l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))+ l.setError(catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName))return}// Check if any views depend on this column@@ -603,7 +614,7 @@ func (l *pgCatalogListener) alterTableDropColumn(schema *model.SchemaMetadata, tfor _, v := range dependentViews {viewNames = append(viewNames, fmt.Sprintf("%q.%q", schema.GetProto().Name, v))}- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.ColumnIsReferencedByView,Content: fmt.Sprintf("Cannot drop column %q in table %q.%q, it's referenced by view: %s", columnName, schema.GetProto().Name, table.GetProto().Name, strings.Join(viewNames, ", ")),})@@ -622,7 +633,7 @@ func (l *pgCatalogListener) alterTableDropColumn(schema *model.SchemaMetadata, t}for _, indexName := range dropIndexList {if err := table.DropIndex(indexName); err != nil {- l.setError(&WalkThroughError{Code: code.IndexNotExists, Content: err.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()})return}}@@ -630,13 +641,13 @@ func (l *pgCatalogListener) alterTableDropColumn(schema *model.SchemaMetadata, t// TODO(zp): deal with CASCADE.// Validate column exists before droppingif table.GetColumn(columnName) == nil {- l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))+ l.setError(catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName))return}// Delete the column without renumbering positions// PostgreSQL maintains stable column positions (attnum) even after dropping columnsif err := table.DropColumnWithoutRenumbering(columnName); err != nil {- l.setError(&WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)})+ l.setError(&catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)})}}@@ -644,7 +655,7 @@ func (l *pgCatalogListener) alterTableDropColumn(schema *model.SchemaMetadata, tfunc (l *pgCatalogListener) alterTableAlterColumnType(schema *model.SchemaMetadata, table *model.TableMetadata, columnName string, typeString string) {column := table.GetColumn(columnName)if column == nil {- l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))+ l.setError(catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName))return}// Check if any views depend on this column@@ -655,7 +666,7 @@ func (l *pgCatalogListener) alterTableAlterColumnType(schema *model.SchemaMetadafor _, v := range dependentViews {viewNames = append(viewNames, fmt.Sprintf("%q.%q", schema.GetProto().Name, v))}- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.ColumnIsReferencedByView,Content: fmt.Sprintf("Cannot alter type of column %q in table %q.%q, it's referenced by view: %s", columnName, schema.GetProto().Name, table.GetProto().Name, strings.Join(viewNames, ", ")),})@@ -676,7 +687,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, taif ifNotExists {return}- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("The column %q already exists in table %q", columnName, table.GetProto().Name),})@@ -685,7 +696,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, ta// Extract column typevar typeString stringif columndef.Typename() != nil {- typeString = extractTypeName(columndef.Typename())+ typeString = extractTypeNameFromContext(columndef.Typename())}// Create column metadatacol := &storepb.ColumnMetadata{@@ -736,7 +747,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, taPrimary: false,}if err := table.CreateIndex(index); err != nil {- l.setError(&WalkThroughError{Code: code.IndexExists, Content: err.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()})return}}@@ -751,7 +762,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, ta}// Check for collisionif table.GetIndex(constraintName) != nil {- l.setError(NewRelationExistsError(constraintName, schema.GetProto().Name))+ l.setError(catalogutil.NewRelationExistsError(constraintName, schema.GetProto().Name))return}col.Nullable = false@@ -765,7 +776,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, taIsConstraint: true,}if err := table.CreateIndex(index); err != nil {- l.setError(&WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()})return}}@@ -773,7 +784,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, ta}// Create the columnif err := table.CreateColumn(col); err != nil {- l.setError(&WalkThroughError{Code: code.ColumnExists, Content: err.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.ColumnExists, Content: err.Error()})}}@@ -794,12 +805,12 @@ func (l *pgCatalogListener) alterTableDropConstraint(_ *model.SchemaMetadata, ta// Check if constraint exists as an indexif table.GetIndex(constraintName) != nil {if err := table.DropIndex(constraintName); err != nil {- l.setError(&WalkThroughError{Code: code.IndexNotExists, Content: err.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()})}return}if !ifExists {- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.ConstraintNotExists,Content: fmt.Sprintf("Constraint %q for table %q does not exist", constraintName, table.GetProto().Name),})@@ -810,7 +821,7 @@ func (l *pgCatalogListener) alterTableDropConstraint(_ *model.SchemaMetadata, tafunc (l *pgCatalogListener) alterTableSetDefault(table *model.TableMetadata, columnName string, defaultValue string) {column := table.GetColumn(columnName)if column == nil {- l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))+ l.setError(catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName))return}column.Default = defaultValue@@ -820,7 +831,7 @@ func (l *pgCatalogListener) alterTableSetDefault(table *model.TableMetadata, colfunc (l *pgCatalogListener) alterTableDropDefault(table *model.TableMetadata, columnName string) {column := table.GetColumn(columnName)if column == nil {- l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))+ l.setError(catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName))return}column.Default = ""@@ -830,45 +841,45 @@ func (l *pgCatalogListener) alterTableDropDefault(table *model.TableMetadata, cofunc (l *pgCatalogListener) alterTableSetNotNull(table *model.TableMetadata, columnName string) {column := table.GetColumn(columnName)if column == nil {- l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))+ l.setError(catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName))return}column.Nullable = false}// renameTable handles RENAME TO for tables.-func (*pgCatalogListener) pgRenameTable(schema *model.SchemaMetadata, table *model.TableMetadata, newName string) *WalkThroughError {+func (*pgCatalogListener) pgRenameTable(schema *model.SchemaMetadata, table *model.TableMetadata, newName string) *catalogutil.WalkThroughError {// Check if new name already existsif schema.GetTable(newName) != nil {- return NewRelationExistsError(newName, schema.GetProto().Name)+ return catalogutil.NewRelationExistsError(newName, schema.GetProto().Name)}// Use the RenameTable method from schemaoldName := table.GetProto().Nameif err := schema.RenameTable(oldName, newName); err != nil {- return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}return nil}// renameColumn handles RENAME COLUMN.-func (*pgCatalogListener) renameColumn(table *model.TableMetadata, oldName string, newName string) *WalkThroughError {+func (*pgCatalogListener) renameColumn(table *model.TableMetadata, oldName string, newName string) *catalogutil.WalkThroughError {if oldName == newName {return nil}// Validate old column existsif table.GetColumn(oldName) == nil {- return NewColumnNotExistsError(table.GetProto().Name, oldName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, oldName)}// Validate new column doesn't already existif table.GetColumn(newName) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("Column `%s` already exists in table `%s`", newName, table.GetProto().Name),}}// Use the RenameColumn methodif err := table.RenameColumn(oldName, newName); err != nil {- return &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}}// Rename column in all indexes that reference itfor _, index := range table.GetProto().Indexes {@@ -882,7 +893,7 @@ func (*pgCatalogListener) renameColumn(table *model.TableMetadata, oldName strin}// renameConstraint handles RENAME CONSTRAINT.-func (*pgCatalogListener) renameConstraint(schema *model.SchemaMetadata, table *model.TableMetadata, oldName string, newName string) *WalkThroughError {+func (*pgCatalogListener) renameConstraint(schema *model.SchemaMetadata, table *model.TableMetadata, oldName string, newName string) *catalogutil.WalkThroughError {index := table.GetIndex(oldName)if index == nil {// We haven't dealt with foreign and check constraints, so skip if not exists@@ -890,11 +901,11 @@ func (*pgCatalogListener) renameConstraint(schema *model.SchemaMetadata, table *}// Check if new name already existsif table.GetIndex(newName) != nil {- return NewRelationExistsError(newName, schema.GetProto().Name)+ return catalogutil.NewRelationExistsError(newName, schema.GetProto().Name)}// Use the RenameIndex methodif err := table.RenameIndex(oldName, newName); err != nil {- return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}return nil}@@ -976,16 +987,16 @@ func (l *pgCatalogListener) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {// PostgreSQL does not allow dropping the currently open database.// This matches the real PostgreSQL behavior: "ERROR: cannot drop the currently open database"if isCurrentDatabase(l.databaseState, databaseName) {- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Cannot drop the currently open database %q", databaseName),})return}// DROP DATABASE for other databases is out of scope for single-database walk-through- l.setError(NewAccessOtherDatabaseError(l.databaseState.DatabaseName(), databaseName))+ l.setError(catalogutil.NewAccessOtherDatabaseError(l.databaseState.DatabaseName(), databaseName))}-func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExists bool) *WalkThroughError {+func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExists bool) *catalogutil.WalkThroughError {parts := pgparser.NormalizePostgreSQLAnyName(anyName)if len(parts) == 0 {return nil@@ -1010,7 +1021,7 @@ func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExistsif ifExists {return nil}- return NewTableNotExistsError(tableName)+ return catalogutil.NewTableNotExistsError(tableName)}// Check if any views depend on this tabledependentViews := schema.GetDependentViews(tableName, "")@@ -1020,18 +1031,18 @@ func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExistsfor _, v := range dependentViews {viewNames = append(viewNames, fmt.Sprintf("%q.%q", schema.GetProto().Name, v))}- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.TableIsReferencedByView,Content: fmt.Sprintf("Cannot drop table %q.%q, it's referenced by view: %s", schema.GetProto().Name, tableName, strings.Join(viewNames, ", ")),}}// Drop the table using the schema methodif err := schema.DropTable(tableName); err != nil {- return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}return nil}-func (l *pgCatalogListener) dropView(anyName parser.IAny_nameContext, ifExists bool) *WalkThroughError {+func (l *pgCatalogListener) dropView(anyName parser.IAny_nameContext, ifExists bool) *catalogutil.WalkThroughError {parts := pgparser.NormalizePostgreSQLAnyName(anyName)if len(parts) == 0 {return nil@@ -1053,12 +1064,12 @@ func (l *pgCatalogListener) dropView(anyName parser.IAny_nameContext, ifExists b// Try to drop the viewif dropErr := schema.DropView(viewName); dropErr != nil {if !ifExists {- return &WalkThroughError{Code: code.ViewNotExists, Content: dropErr.Error()}+ return &catalogutil.WalkThroughError{Code: code.ViewNotExists, Content: dropErr.Error()}}}return nil}-func (l *pgCatalogListener) dropIndex(anyName parser.IAny_nameContext, ifExists bool) *WalkThroughError {+func (l *pgCatalogListener) dropIndex(anyName parser.IAny_nameContext, ifExists bool) *catalogutil.WalkThroughError {parts := pgparser.NormalizePostgreSQLAnyName(anyName)if len(parts) == 0 {return nil@@ -1087,18 +1098,18 @@ func (l *pgCatalogListener) dropIndex(anyName parser.IAny_nameContext, ifExists}// Drop the index from the tableif err := table.DropIndex(index.GetProto().Name); err != nil {- return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}return nil}-func (l *pgCatalogListener) dropSchema(schemaNameCtx parser.INameContext, ifExists bool) *WalkThroughError {+func (l *pgCatalogListener) dropSchema(schemaNameCtx parser.INameContext, ifExists bool) *catalogutil.WalkThroughError {schemaName := pgparser.NormalizePostgreSQLName(schemaNameCtx)schema := l.databaseState.GetSchema(schemaName)if schema == nil {if ifExists {return nil}- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: fmt.Sprintf("Schema %q does not exist", schemaName),}@@ -1107,7 +1118,7 @@ func (l *pgCatalogListener) dropSchema(schemaNameCtx parser.INameContext, ifExis// Note: We don't check for objects in the schema to match the old behavior// In real PostgreSQL, this would require CASCADE if the schema is not emptyif err := l.databaseState.DropSchema(schemaName); err != nil {- return &WalkThroughError{Code: code.SchemaNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.SchemaNotExists, Content: err.Error()}}return nil}@@ -1194,7 +1205,7 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {// Check if it's a viewif schema.GetView(viewName) != nil {if err := schema.RenameView(viewName, newName); err != nil {- l.setError(&WalkThroughError{Code: code.ViewNotExists, Content: err.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.ViewNotExists, Content: err.Error()})}return}@@ -1220,7 +1231,7 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {newName := pgparser.NormalizePostgreSQLName(allNames[1])table := schema.GetTable(tableName)if table == nil {- l.setError(NewTableNotExistsError(tableName))+ l.setError(catalogutil.NewTableNotExistsError(tableName))return}if err := l.renameColumn(table, oldName, newName); err != nil {@@ -1238,7 +1249,7 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {newName := pgparser.NormalizePostgreSQLName(allNames[1])table := schema.GetTable(tableName)if table == nil {- l.setError(NewTableNotExistsError(tableName))+ l.setError(catalogutil.NewTableNotExistsError(tableName))return}if err := l.renameConstraint(schema, table, oldName, newName); err != nil {@@ -1252,7 +1263,7 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {newName := pgparser.NormalizePostgreSQLName(ctx.AllName()[0])table := schema.GetTable(tableName)if table == nil {- l.setError(NewTableNotExistsError(tableName))+ l.setError(catalogutil.NewTableNotExistsError(tableName))return}if err := l.pgRenameTable(schema, table, newName); err != nil {@@ -1280,7 +1291,7 @@ func (l *pgCatalogListener) EnterViewstmt(ctx *parser.ViewstmtContext) {databaseName := extractDatabaseName(ctx.Qualified_name())// Check if accessing other databaseif databaseName != "" && l.databaseState.DatabaseName() != databaseName {- l.setError(&WalkThroughError{+ l.setError(&catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.DatabaseName()),})@@ -1306,7 +1317,7 @@ func (l *pgCatalogListener) EnterViewstmt(ctx *parser.ViewstmtContext) {// Create the view_, createErr := schema.CreateView(viewName, definition, nil)if createErr != nil {- l.setError(&WalkThroughError{Code: code.ViewExists, Content: createErr.Error()})+ l.setError(&catalogutil.WalkThroughError{Code: code.ViewExists, Content: createErr.Error()})}}@@ -1328,11 +1339,11 @@ func isTopLevel(ctx antlr.Tree) bool {}}-// extractTypeName extracts the type name from a Typename context.+// extractTypeNameFromContext extracts the type name from a Typename context.// Simply uses GetText() to get the full type representation.// PostgreSQL normalizes some type names (e.g., int -> integer),// which will be handled by the parser's type normalization.-func extractTypeName(typename parser.ITypenameContext) string {+func extractTypeNameFromContext(typename parser.ITypenameContext) string {if typename == nil {return ""}@@ -1469,31 +1480,31 @@ func pgGeneratePrimaryKeyName(schema *model.SchemaMetadata, tableName string) st// getOrCreatePublicSchema gets a schema by name, or creates the "public" schema if it doesn't exist.// For PostgreSQL, the "public" schema is auto-created, but other schemas must exist.-func getOrCreatePublicSchema(d *model.DatabaseMetadata, schemaName string) (*model.SchemaMetadata, *WalkThroughError) {+func getOrCreatePublicSchema(d *model.DatabaseMetadata, schemaName string) (*model.SchemaMetadata, *catalogutil.WalkThroughError) {if schemaName == "" {- schemaName = publicSchemaName+ schemaName = PublicSchemaName}schema := d.GetSchema(schemaName)if schema != nil {return schema, nil}// Only auto-create the "public" schema- if schemaName != publicSchemaName {- return nil, &WalkThroughError{+ if schemaName != PublicSchemaName {+ return nil, &catalogutil.WalkThroughError{Code: code.SchemaNotExists,Content: fmt.Sprintf("The schema %q doesn't exist", schemaName),}}- return d.CreateSchema(publicSchemaName), nil+ return d.CreateSchema(PublicSchemaName), nil}// getIndexFromSchema finds an index by name within a schema and returns the table and index.// For PostgreSQL, index names are unique within a schema (not just within a table).-func getIndexFromSchema(s *model.SchemaMetadata, indexName string) (*model.TableMetadata, *model.IndexMetadata, *WalkThroughError) {+func getIndexFromSchema(s *model.SchemaMetadata, indexName string) (*model.TableMetadata, *model.IndexMetadata, *catalogutil.WalkThroughError) {// For PostgreSQL, index names are unique within a schemaindex := s.GetIndex(indexName)if index == nil {- return nil, nil, &WalkThroughError{+ return nil, nil, &catalogutil.WalkThroughError{Code: code.IndexNotExists,Content: fmt.Sprintf("Index %q does not exist in schema %q", indexName, s.GetProto().Name),}@@ -1501,10 +1512,15 @@ func getIndexFromSchema(s *model.SchemaMetadata, indexName string) (*model.Table// Find the table that owns this indextable := s.GetTable(index.GetTableProto().Name)if table == nil {- return nil, nil, &WalkThroughError{+ return nil, nil, &catalogutil.WalkThroughError{Code: code.TableNotExists,Content: fmt.Sprintf("Table %q does not exist in schema %q", index.GetTableProto().Name, s.GetProto().Name),}}return table, index, nil}++// isCurrentDatabase returns true if the given database is the current database.+func isCurrentDatabase(d *model.DatabaseMetadata, database string) bool {+ return catalogutil.CompareIdentifier(d.DatabaseName(), database, !d.GetIsObjectCaseSensitive())+}diff --git a/backend/plugin/schema/pg/walk_through_test.go b/backend/plugin/schema/pg/walk_through_test.gonew file mode 100644index 0000000000..e4115dcab8--- /dev/null+++ b/backend/plugin/schema/pg/walk_through_test.go@@ -0,0 +1,220 @@+package pg++import (+ "io"+ "os"+ "path/filepath"+ "testing"++ "github.com/google/go-cmp/cmp"+ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto"+ "google.golang.org/protobuf/testing/protocmp"+ "gopkg.in/yaml.v3"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/component/sheet"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/schema/catalogutil"+ "github.com/bytebase/bytebase/backend/store/model"+)++type testData struct {+ Statement string+ // Use custom yaml tag to avoid generate field name `ignorecasesensitive`.+ IgnoreCaseSensitive bool `yaml:"ignore_case_sensitive"`+ Want string+ Err *catalogutil.WalkThroughError+}++func TestWalkThrough(t *testing.T) {+ originDatabase := &storepb.DatabaseSchemaMetadata{+ Name: "postgres",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "test",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "int",+ Nullable: false,+ Position: 1,+ },+ {+ Name: "name",+ Type: "varchar(20)",+ Nullable: true,+ Position: 2,+ },+ },+ },+ },+ Views: []*storepb.ViewMetadata{+ {+ Name: "v1",+ Definition: "SELECT id, name FROM test",+ DependencyColumns: []*storepb.DependencyColumn{+ {+ Schema: "public",+ Table: "test",+ Column: "id",+ },+ {+ Schema: "public",+ Table: "test",+ Column: "name",+ },+ },+ },+ },+ },+ },+ }++ tests := []testData{}+ filepath := filepath.Join("testdata", "walk_through.yaml")+ yamlFile, err := os.Open(filepath)+ require.NoError(t, err)+ defer yamlFile.Close()++ byteValue, err := io.ReadAll(yamlFile)+ require.NoError(t, err)+ err = yaml.Unmarshal(byteValue, &tests)+ require.NoError(t, err)+ sm := sheet.NewManager(nil)++ for _, test := range tests {+ // Make a deep copy to avoid mutation across tests+ protoData, ok := proto.Clone(originDatabase).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok)++ // Create DatabaseMetadata for walk-through+ state := model.NewDatabaseMetadata(protoData, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)++ asts, _ := sm.GetASTsForChecks(storepb.Engine_POSTGRES, test.Statement)+ err := WalkThrough(state, asts)+ if err != nil {+ walkErr, yes := err.(*catalogutil.WalkThroughError)+ require.True(t, yes)+ require.Equal(t, test.Err, walkErr)+ continue+ }+ require.NoError(t, err, test.Statement)++ // Skip comparison if want is empty (error cases)+ if test.Want == "" {+ continue+ }++ want := &storepb.DatabaseSchemaMetadata{}+ err = common.ProtojsonUnmarshaler.Unmarshal([]byte(test.Want), want)+ require.NoError(t, err)+ // Sort proto for deterministic comparison+ state.SortProto()+ result := state.GetProto()+ diff := cmp.Diff(want, result, protocmp.Transform())+ require.Empty(t, diff)+ }+}++func TestWalkThroughANTLR(t *testing.T) {+ originDatabase := &storepb.DatabaseSchemaMetadata{+ Name: "postgres",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "test",+ Columns: []*storepb.ColumnMetadata{+ {+ Name: "id",+ Type: "int",+ Nullable: false,+ Position: 1,+ },+ {+ Name: "name",+ Type: "varchar(20)",+ Nullable: true,+ Position: 2,+ },+ },+ },+ },+ Views: []*storepb.ViewMetadata{+ {+ Name: "v1",+ Definition: "SELECT id, name FROM test",+ DependencyColumns: []*storepb.DependencyColumn{+ {+ Schema: "public",+ Table: "test",+ Column: "id",+ },+ {+ Schema: "public",+ Table: "test",+ Column: "name",+ },+ },+ },+ },+ },+ },+ }++ tests := []testData{}+ filepath := filepath.Join("testdata", "walk_through.yaml")+ yamlFile, err := os.Open(filepath)+ require.NoError(t, err)+ defer yamlFile.Close()++ byteValue, err := io.ReadAll(yamlFile)+ require.NoError(t, err)+ err = yaml.Unmarshal(byteValue, &tests)+ require.NoError(t, err)++ for _, test := range tests {+ // Make a deep copy to avoid mutation across tests+ protoData, ok := proto.Clone(originDatabase).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok)++ // Create DatabaseMetadata for walk-through+ state := model.NewDatabaseMetadata(protoData, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)++ // Parse using ANTLR parser instead of legacy parser+ parseResult, parseErr := pgparser.ParsePostgreSQL(test.Statement)+ if parseErr != nil {+ t.Fatalf("Failed to parse SQL with ANTLR: %v\nSQL: %s", parseErr, test.Statement)+ }++ // Call WalkThrough with ANTLR tree+ err := WalkThrough(state, parseResult)+ if err != nil {+ walkErr, yes := err.(*catalogutil.WalkThroughError)+ require.True(t, yes)+ require.Equal(t, test.Err, walkErr)+ continue+ }+ require.NoError(t, err, test.Statement)++ // Skip comparison if want is empty (error cases)+ if test.Want == "" {+ continue+ }++ want := &storepb.DatabaseSchemaMetadata{}+ err = common.ProtojsonUnmarshaler.Unmarshal([]byte(test.Want), want)+ require.NoError(t, err)+ // Sort proto for deterministic comparison+ state.SortProto()+ result := state.GetProto()+ diff := cmp.Diff(want, result, protocmp.Transform())+ require.Empty(t, diff)+ }+}diff --git a/backend/plugin/schema/schema.go b/backend/plugin/schema/schema.goindex bcb472d11d..57e5e06560 100644--- a/backend/plugin/schema/schema.go+++ b/backend/plugin/schema/schema.go@@ -24,6 +24,7 @@ var (generateMigrations = make(map[storepb.Engine]generateMigration)getSDLDiffs = make(map[storepb.Engine]getSDLDiff)getMultiFileDatabaseDefinitions = make(map[storepb.Engine]getMultiFileDatabaseDefinition)+ walkThroughs = make(map[storepb.Engine]walkThrough))type getDatabaseDefinition func(GetDefinitionContext, *storepb.DatabaseSchemaMetadata) (string, error)@@ -38,6 +39,7 @@ type getSequenceDefinition func(string, *storepb.SequenceMetadata) (string, errotype getDatabaseMetadata func(string) (*storepb.DatabaseSchemaMetadata, error)type generateMigration func(*MetadataDiff) (string, error)type getSDLDiff func(currentSDLText, previousUserSDLText string, currentSchema, previousSchema *model.DatabaseSchema) (*MetadataDiff, error)+type walkThrough func(*model.DatabaseMetadata, any) errortype GetDefinitionContext struct {SkipBackupSchema bool@@ -265,3 +267,20 @@ func GetMultiFileDatabaseDefinition(engine storepb.Engine, ctx GetDefinitionCont}return f(ctx, metadata)}++func RegisterWalkThrough(engine storepb.Engine, f walkThrough) {+ mux.Lock()+ defer mux.Unlock()+ if _, dup := walkThroughs[engine]; dup {+ panic(fmt.Sprintf("Register called twice %s", engine))+ }+ walkThroughs[engine] = f+}++func WalkThrough(engine storepb.Engine, d *model.DatabaseMetadata, ast any) error {+ f, ok := walkThroughs[engine]+ if !ok {+ return errors.Errorf("Walk-through doesn't support engine type: %s", engine)+ }+ return f(d, ast)+}diff --git a/backend/plugin/advisor/catalog/test/tidb_walk_through.yaml b/backend/plugin/schema/tidb/testdata/walk_through.yamlsimilarity index 100%rename from backend/plugin/advisor/catalog/test/tidb_walk_through.yamlrename to backend/plugin/schema/tidb/testdata/walk_through.yamldiff --git a/backend/plugin/advisor/catalog/walk_through_for_tidb.go b/backend/plugin/schema/tidb/walk_through.gosimilarity index 80%rename from backend/plugin/advisor/catalog/walk_through_for_tidb.gorename to backend/plugin/schema/tidb/walk_through.goindex b8f261edd6..c34ff2a533 100644--- a/backend/plugin/advisor/catalog/walk_through_for_tidb.go+++ b/backend/plugin/schema/tidb/walk_through.go@@ -1,4 +1,4 @@-package catalog+package tidbimport ("fmt"@@ -14,11 +14,26 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/plugin/schema"+ "github.com/bytebase/bytebase/backend/plugin/schema/catalogutil""github.com/bytebase/bytebase/backend/store/model")-// TiDBWalkThrough walks through TiDB AST and updates the database state.-func TiDBWalkThrough(d *model.DatabaseMetadata, ast any) error {+const (+ // PrimaryKeyName is the string for PK.+ PrimaryKeyName string = "PRIMARY"+ // FullTextName is the string for FULLTEXT.+ FullTextName string = "FULLTEXT"+ // SpatialName is the string for SPATIAL.+ SpatialName string = "SPATIAL"+)++func init() {+ schema.RegisterWalkThrough(storepb.Engine_TIDB, WalkThrough)+}++// WalkThrough walks through TiDB AST and updates the database state.+func WalkThrough(d *model.DatabaseMetadata, ast any) error {// We define the Catalog as Database -> Schema -> Table. The Schema is only for PostgreSQL.// So we use a Schema whose name is empty for other engines, such as MySQL.// If there is no empty-string-name schema, create it to avoid corner cases.@@ -40,7 +55,7 @@ func TiDBWalkThrough(d *model.DatabaseMetadata, ast any) error {return nil}-func changeStateTiDB(d *model.DatabaseMetadata, in tidbast.StmtNode) (err *WalkThroughError) {+func changeStateTiDB(d *model.DatabaseMetadata, in tidbast.StmtNode) (err *catalogutil.WalkThroughError) {defer func() {if err == nil {return@@ -66,7 +81,7 @@ func changeStateTiDB(d *model.DatabaseMetadata, in tidbast.StmtNode) (err *WalkTcase *tidbast.DropDatabaseStmt:return tidbDropDatabase(d, node)case *tidbast.CreateDatabaseStmt:- return NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)+ return catalogutil.NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)case *tidbast.RenameTableStmt:return tidbRenameTable(d, node)default:@@ -74,7 +89,7 @@ func changeStateTiDB(d *model.DatabaseMetadata, in tidbast.StmtNode) (err *WalkT}}-func tidbRenameTable(d *model.DatabaseMetadata, node *tidbast.RenameTableStmt) *WalkThroughError {+func tidbRenameTable(d *model.DatabaseMetadata, node *tidbast.RenameTableStmt) *catalogutil.WalkThroughError {for _, tableToTable := range node.TableToTables {schema := d.GetSchema("")if schema == nil {@@ -88,23 +103,23 @@ func tidbRenameTable(d *model.DatabaseMetadata, node *tidbast.RenameTableStmt) *}table := schema.GetTable(oldTableName)if table == nil {- return NewTableNotExistsError(oldTableName)+ return catalogutil.NewTableNotExistsError(oldTableName)}if schema.GetTable(newTableName) != nil {- return NewTableExistsError(newTableName)+ return catalogutil.NewTableExistsError(newTableName)}if err := schema.RenameTable(table.GetProto().Name, newTableName); err != nil {- return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}} else if tidbMoveToOtherDatabase(d, tableToTable) {if schema.GetTable(tableToTable.OldTable.Name.O) == nil {- return NewTableNotExistsError(tableToTable.OldTable.Name.O)+ return catalogutil.NewTableNotExistsError(tableToTable.OldTable.Name.O)}if err := schema.DropTable(tableToTable.OldTable.Name.O); err != nil {- return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}} else {- return NewAccessOtherDatabaseError(d.GetProto().Name, tidbTargetDatabase(d, tableToTable))+ return catalogutil.NewAccessOtherDatabaseError(d.GetProto().Name, tidbTargetDatabase(d, tableToTable))}}return nil@@ -134,9 +149,9 @@ func tidbTheCurrentDatabase(d *model.DatabaseMetadata, node *tidbast.TableToTablreturn true}-func tidbDropDatabase(d *model.DatabaseMetadata, node *tidbast.DropDatabaseStmt) *WalkThroughError {+func tidbDropDatabase(d *model.DatabaseMetadata, node *tidbast.DropDatabaseStmt) *catalogutil.WalkThroughError {if !isCurrentDatabase(d, node.Name.O) {- return NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)+ return catalogutil.NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)}// Note: In walk-through, we don't need to actually delete the database metadata@@ -144,9 +159,9 @@ func tidbDropDatabase(d *model.DatabaseMetadata, node *tidbast.DropDatabaseStmt)return nil}-func tidbAlterDatabase(d *model.DatabaseMetadata, node *tidbast.AlterDatabaseStmt) *WalkThroughError {+func tidbAlterDatabase(d *model.DatabaseMetadata, node *tidbast.AlterDatabaseStmt) *catalogutil.WalkThroughError {if !node.AlterDefaultDatabase && !isCurrentDatabase(d, node.Name.O) {- return NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)+ return catalogutil.NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)}for _, option := range node.Options {@@ -162,9 +177,9 @@ func tidbAlterDatabase(d *model.DatabaseMetadata, node *tidbast.AlterDatabaseStmreturn nil}-func tidbFindTableState(d *model.DatabaseMetadata, tableName *tidbast.TableName) (*model.TableMetadata, *WalkThroughError) {+func tidbFindTableState(d *model.DatabaseMetadata, tableName *tidbast.TableName) (*model.TableMetadata, *catalogutil.WalkThroughError) {if tableName.Schema.O != "" && !isCurrentDatabase(d, tableName.Schema.O) {- return nil, NewAccessOtherDatabaseError(d.GetProto().Name, tableName.Schema.O)+ return nil, catalogutil.NewAccessOtherDatabaseError(d.GetProto().Name, tableName.Schema.O)}schema := d.GetSchema("")@@ -174,25 +189,25 @@ func tidbFindTableState(d *model.DatabaseMetadata, tableName *tidbast.TableName)table := schema.GetTable(tableName.Name.O)if table == nil {- return nil, NewTableNotExistsError(tableName.Name.O)+ return nil, catalogutil.NewTableNotExistsError(tableName.Name.O)}return table, nil}-func tidbDropIndex(d *model.DatabaseMetadata, node *tidbast.DropIndexStmt) *WalkThroughError {+func tidbDropIndex(d *model.DatabaseMetadata, node *tidbast.DropIndexStmt) *catalogutil.WalkThroughError {table, err := tidbFindTableState(d, node.Table)if err != nil {return err}if err := table.DropIndex(node.IndexName); err != nil {- return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}return nil}-func tidbHandleCreateIndex(d *model.DatabaseMetadata, node *tidbast.CreateIndexStmt) *WalkThroughError {+func tidbHandleCreateIndex(d *model.DatabaseMetadata, node *tidbast.CreateIndexStmt) *catalogutil.WalkThroughError {table, err := tidbFindTableState(d, node.Table)if err != nil {return err@@ -223,7 +238,7 @@ func tidbHandleCreateIndex(d *model.DatabaseMetadata, node *tidbast.CreateIndexSreturn tidbCreateIndexHelper(table, node.IndexName, keyList, unique, tp, node.IndexOption)}-func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *WalkThroughError {+func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *catalogutil.WalkThroughError {table, err := tidbFindTableState(d, node.Table)if err != nil {return err@@ -282,18 +297,18 @@ func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *WacolumnName := spec.OldColumnName.Name.O// Validate column existsif table.GetColumn(columnName) == nil {- return NewColumnNotExistsError(table.GetProto().Name, columnName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, columnName)}if err := table.DropColumn(columnName); err != nil {- return &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)}}case tidbast.AlterTableDropPrimaryKey:if err := table.DropIndex(PrimaryKeyName); err != nil {- return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}case tidbast.AlterTableDropIndex:if err := table.DropIndex(spec.Name); err != nil {- return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}case tidbast.AlterTableDropForeignKey:// we do not deal with DROP FOREIGN KEY statements.@@ -310,22 +325,22 @@ func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *WanewColumnName := spec.NewColumnName.Name.O// Validate old column existsif table.GetColumn(oldColumnName) == nil {- return NewColumnNotExistsError(table.GetProto().Name, oldColumnName)+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, oldColumnName)}// Validate new column doesn't already existif table.GetColumn(newColumnName) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("Column `%s` already exists in table `%s`", newColumnName, table.GetProto().Name),}}if err := table.RenameColumn(oldColumnName, newColumnName); err != nil {- return &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}}case tidbast.AlterTableRenameTable:schema := d.GetSchema("")if err := schema.RenameTable(table.GetProto().Name, spec.NewTable.Name.O); err != nil {- return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}case tidbast.AlterTableAlterColumn:if err := tidbChangeColumnDefault(table, spec.NewColumns[0]); err != nil {@@ -334,14 +349,14 @@ func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *Wacase tidbast.AlterTableRenameIndex:// Validate old index existsif table.GetIndex(spec.FromKey.O) == nil {- return &WalkThroughError{Code: code.IndexNotExists, Content: fmt.Sprintf("index %q does not exist in table %q", spec.FromKey.O, table.GetProto().Name)}+ return &catalogutil.WalkThroughError{Code: code.IndexNotExists, Content: fmt.Sprintf("index %q does not exist in table %q", spec.FromKey.O, table.GetProto().Name)}}// Validate new index doesn't already existif table.GetIndex(spec.ToKey.O) != nil {- return &WalkThroughError{Code: code.IndexExists, Content: fmt.Sprintf("index %q already exists in table %q", spec.ToKey.O, table.GetProto().Name)}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: fmt.Sprintf("index %q already exists in table %q", spec.ToKey.O, table.GetProto().Name)}}if err := table.RenameIndex(spec.FromKey.O, spec.ToKey.O); err != nil {- return &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename index: %v", err)}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename index: %v", err)}}case tidbast.AlterTableIndexInvisible:if err := tidbChangeIndexVisibility(table, spec.IndexName.O, spec.Visibility); err != nil {@@ -355,10 +370,10 @@ func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *Wareturn nil}-func tidbChangeIndexVisibility(t *model.TableMetadata, indexName string, visibility tidbast.IndexVisibility) *WalkThroughError {+func tidbChangeIndexVisibility(t *model.TableMetadata, indexName string, visibility tidbast.IndexVisibility) *catalogutil.WalkThroughError {index := t.GetIndex(indexName)if index == nil {- return NewIndexNotExistsError(t.GetProto().Name, indexName)+ return catalogutil.NewIndexNotExistsError(t.GetProto().Name, indexName)}switch visibility {case tidbast.IndexVisibilityVisible:@@ -371,11 +386,11 @@ func tidbChangeIndexVisibility(t *model.TableMetadata, indexName string, visibilreturn nil}-func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef) *WalkThroughError {+func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef) *catalogutil.WalkThroughError {columnName := column.Name.Name.Lcol := t.GetColumn(columnName)if col == nil {- return NewColumnNotExistsError(t.GetProto().Name, columnName)+ return catalogutil.NewColumnNotExistsError(t.GetProto().Name, columnName)}if len(column.Options) == 1 {@@ -387,7 +402,7 @@ func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef)"text", "tinytext", "mediumtext", "longtext","json","geometry":- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.InvalidColumnDefault,// Content comes from MySQL Error content.Content: fmt.Sprintf("BLOB, TEXT, GEOMETRY or JSON column `%s` can't have a default value", columnName),@@ -399,7 +414,7 @@ func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef)defaultValue, err := restoreNode(column.Options[0].Expr, format.RestoreStringWithoutCharset)if err != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.Internal,Content: fmt.Sprintf("Failed to deparse default value: %v", err),}@@ -407,7 +422,7 @@ func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef)col.Default = defaultValue} else {if !col.Nullable {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.Content: fmt.Sprintf("Invalid default value for column `%s`", columnName),@@ -440,10 +455,10 @@ func tidbRenameColumnInIndexKey(t *model.TableMetadata, oldName string, newName// 1. Dropping the old column from the column list (but keeping it in index expressions)// 2. Renaming the column in index expressions// 3. Creating a new column with the new definition-func tidbCompleteTableChangeColumn(t *model.TableMetadata, oldName string, newColumn *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {+func tidbCompleteTableChangeColumn(t *model.TableMetadata, oldName string, newColumn *tidbast.ColumnDef, position *tidbast.ColumnPosition) *catalogutil.WalkThroughError {column := t.GetColumn(oldName)if column == nil {- return NewColumnNotExistsError(t.GetProto().Name, oldName)+ return catalogutil.NewColumnNotExistsError(t.GetProto().Name, oldName)}// Store the current position info if no position specified@@ -482,7 +497,7 @@ func tidbCompleteTableChangeColumn(t *model.TableMetadata, oldName string, newCo// We use DropColumnWithoutUpdatingIndexes to remove from internal map and proto// without affecting index expressionsif err := t.DropColumnWithoutUpdatingIndexes(oldName); err != nil {- return &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to drop column: %v", err)}}// Rename column in index expressions@@ -515,12 +530,12 @@ func tidbCompleteTableChangeColumn(t *model.TableMetadata, oldName string, newCoreturn nil}-func tidbChangeColumn(t *model.TableMetadata, oldName string, newColumn *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {+func tidbChangeColumn(t *model.TableMetadata, oldName string, newColumn *tidbast.ColumnDef, position *tidbast.ColumnPosition) *catalogutil.WalkThroughError {return tidbCompleteTableChangeColumn(t, oldName, newColumn, position)}// tidbReorderColumn reorders the columns for new column and returns the new column position.-func tidbReorderColumn(t *model.TableMetadata, position *tidbast.ColumnPosition) (int, *WalkThroughError) {+func tidbReorderColumn(t *model.TableMetadata, position *tidbast.ColumnPosition) (int, *catalogutil.WalkThroughError) {switch position.Tp {case tidbast.ColumnPositionNone:return len(t.GetColumns()) + 1, nil@@ -533,7 +548,7 @@ func tidbReorderColumn(t *model.TableMetadata, position *tidbast.ColumnPosition)columnName := position.RelativeColumn.Name.Lcolumn := t.GetColumn(columnName)if column == nil {- return 0, NewColumnNotExistsError(t.GetProto().Name, columnName)+ return 0, catalogutil.NewColumnNotExistsError(t.GetProto().Name, columnName)}for _, col := range t.GetColumns() {if col.Position > column.Position {@@ -542,19 +557,19 @@ func tidbReorderColumn(t *model.TableMetadata, position *tidbast.ColumnPosition)}return int(column.Position) + 1, nildefault:- return 0, &WalkThroughError{+ return 0, &catalogutil.WalkThroughError{Code: code.Unsupported,Content: fmt.Sprintf("Unsupported column position type: %d", position.Tp),}}}-func tidbDropTable(d *model.DatabaseMetadata, node *tidbast.DropTableStmt) *WalkThroughError {+func tidbDropTable(d *model.DatabaseMetadata, node *tidbast.DropTableStmt) *catalogutil.WalkThroughError {// TODO(rebelice): deal with DROP VIEW statement.if !node.IsView {for _, name := range node.Tables {if name.Schema.O != "" && !isCurrentDatabase(d, name.Schema.O) {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database `%s` is not the current database `%s`", name.Schema.O, d.GetProto().Name),}@@ -570,25 +585,25 @@ func tidbDropTable(d *model.DatabaseMetadata, node *tidbast.DropTableStmt) *Walkif node.IfExists {return nil}- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.TableNotExists,Content: fmt.Sprintf("Table `%s` does not exist", name.Name.O),}}if err := schema.DropTable(table.GetProto().Name); err != nil {- return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}}}return nil}-func tidbCopyTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *WalkThroughError {+func tidbCopyTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *catalogutil.WalkThroughError {targetTable, err := tidbFindTableState(d, node.ReferTable)if err != nil {if err.Code == code.NotCurrentDatabase {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.ReferenceOtherDatabase,Content: fmt.Sprintf("Reference table `%s` in other database `%s`, skip walkthrough", node.ReferTable.Name.O, node.ReferTable.Schema.O),}@@ -600,35 +615,35 @@ func tidbCopyTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *Wa// Create new tablenewTable, createErr := schema.CreateTable(node.Table.Name.O)if createErr != nil {- return &WalkThroughError{Code: code.TableExists, Content: createErr.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableExists, Content: createErr.Error()}}// Copy columns and indexes from the target tablefor _, col := range targetTable.GetColumns() {colCopy, ok := proto.Clone(col).(*storepb.ColumnMetadata)if !ok {- return &WalkThroughError{Code: code.Internal, Content: "failed to clone column metadata"}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: "failed to clone column metadata"}}if err := newTable.CreateColumn(colCopy); err != nil {- return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.ColumnExists, Content: err.Error()}}}for _, idx := range targetTable.GetProto().Indexes {idxCopy, ok := proto.Clone(idx).(*storepb.IndexMetadata)if !ok {- return &WalkThroughError{Code: code.Internal, Content: "failed to clone index metadata"}+ return &catalogutil.WalkThroughError{Code: code.Internal, Content: "failed to clone index metadata"}}if err := newTable.CreateIndex(idxCopy); err != nil {- return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()}}}return nil}-func tidbCreateTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *WalkThroughError {+func tidbCreateTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *catalogutil.WalkThroughError {if node.Table.Schema.O != "" && !isCurrentDatabase(d, node.Table.Schema.O) {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database `%s` is not the current database `%s`", node.Table.Schema.O, d.GetProto().Name),}@@ -643,14 +658,14 @@ func tidbCreateTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *if node.IfNotExists {return nil}- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.TableExists,Content: fmt.Sprintf("Table `%s` already exists", node.Table.Name.O),}}if node.Select != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.StatementCreateTableAs,Content: fmt.Sprintf("Disallow the CREATE TABLE AS statement but \"%s\" uses", node.Text()),}@@ -662,15 +677,15 @@ func tidbCreateTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *table, createErr := schema.CreateTable(node.Table.Name.O)if createErr != nil {- return &WalkThroughError{Code: code.TableExists, Content: createErr.Error()}+ return &catalogutil.WalkThroughError{Code: code.TableExists, Content: createErr.Error()}}hasAutoIncrement := falsefor _, column := range node.Cols {- if isAutoIncrement(column) {+ if isAutoIncrementColumn(column) {if hasAutoIncrement {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.AutoIncrementExists,// The content comes from MySQL error content.Content: fmt.Sprintf("There can be only one auto column for table `%s`", table.GetProto().Name),@@ -694,7 +709,7 @@ func tidbCreateTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *return nil}-func tidbCreateConstraint(t *model.TableMetadata, constraint *tidbast.Constraint) *WalkThroughError {+func tidbCreateConstraint(t *model.TableMetadata, constraint *tidbast.Constraint) *catalogutil.WalkThroughError {switch constraint.Tp {case tidbast.ConstraintPrimaryKey:keyList, err := tidbValidateAndGetKeyStringList(t, constraint.Keys, true /* primary */, false /* isSpatial */)@@ -739,13 +754,13 @@ func tidbCreateConstraint(t *model.TableMetadata, constraint *tidbast.Constraintreturn nil}-func tidbValidateAndGetKeyStringList(t *model.TableMetadata, keyList []*tidbast.IndexPartSpecification, primary bool, isSpatial bool) ([]string, *WalkThroughError) {+func tidbValidateAndGetKeyStringList(t *model.TableMetadata, keyList []*tidbast.IndexPartSpecification, primary bool, isSpatial bool) ([]string, *catalogutil.WalkThroughError) {var res []stringfor _, key := range keyList {if key.Expr != nil {str, err := restoreNode(key, format.DefaultRestoreFlags)if err != nil {- return nil, &WalkThroughError{+ return nil, &catalogutil.WalkThroughError{Code: code.Internal,Content: fmt.Sprintf("Failed to deparse index key: %v", err),}@@ -755,13 +770,13 @@ func tidbValidateAndGetKeyStringList(t *model.TableMetadata, keyList []*tidbast.columnName := key.Column.Name.Lcolumn := t.GetColumn(columnName)if column == nil {- return nil, NewColumnNotExistsError(t.GetProto().Name, columnName)+ return nil, catalogutil.NewColumnNotExistsError(t.GetProto().Name, columnName)}if primary {column.Nullable = false}if isSpatial && column.Nullable {- return nil, &WalkThroughError{+ return nil, &catalogutil.WalkThroughError{Code: code.SpatialIndexKeyNullable,// The error content comes from MySQL.Content: fmt.Sprintf("All parts of a SPATIAL index must be NOT NULL, but `%s` is nullable", column.Name),@@ -774,7 +789,7 @@ func tidbValidateAndGetKeyStringList(t *model.TableMetadata, keyList []*tidbast.return res, nil}-func isAutoIncrement(column *tidbast.ColumnDef) bool {+func isAutoIncrementColumn(column *tidbast.ColumnDef) bool {for _, option := range column.Options {if option.Tp == tidbast.ColumnOptionAutoIncrement {return true@@ -783,11 +798,11 @@ func isAutoIncrement(column *tidbast.ColumnDef) bool {return false}-func checkDefault(columnName string, columnType *types.FieldType, value tidbast.ExprNode) *WalkThroughError {+func checkDefault(columnName string, columnType *types.FieldType, value tidbast.ExprNode) *catalogutil.WalkThroughError {if value.GetType().GetType() != mysql.TypeNull {switch columnType.GetType() {case mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob, mysql.TypeJSON, mysql.TypeGeometry:- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.InvalidColumnDefault,// Content comes from MySQL Error content.Content: fmt.Sprintf("BLOB, TEXT, GEOMETRY or JSON column `%s` can't have a default value", columnName),@@ -800,7 +815,7 @@ func checkDefault(columnName string, columnType *types.FieldType, value tidbast.if valueExpr, yes := value.(tidbast.ValueExpr); yes {datum := types.NewDatum(valueExpr.GetValue())if _, err := datum.ConvertTo(types.Context{}, columnType); err != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.InvalidColumnDefault,Content: err.Error(),}@@ -809,9 +824,9 @@ func checkDefault(columnName string, columnType *types.FieldType, value tidbast.return nil}-func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {+func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, position *tidbast.ColumnPosition) *catalogutil.WalkThroughError {if t.GetColumn(column.Name.Name.L) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.ColumnExists,Content: fmt.Sprintf("Column `%s` already exists in table `%s`", column.Name.Name.O, t.GetProto().Name),}@@ -819,7 +834,7 @@ func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, ppos := len(t.GetColumns()) + 1if position != nil {- var err *WalkThroughError+ var err *catalogutil.WalkThroughErrorpos, err = tidbReorderColumn(t, position)if err != nil {return err@@ -855,7 +870,7 @@ func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, pif option.Expr.GetType().GetType() != mysql.TypeNull {defaultValue, err := restoreNode(option.Expr, format.RestoreStringWithoutCharset)if err != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.Internal,Content: fmt.Sprintf("Failed to deparse default value: %v", err),}@@ -873,7 +888,7 @@ func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, pcase tidbast.ColumnOptionOnUpdate:// we do not deal with ON UPDATEif column.Tp.GetType() != mysql.TypeDatetime && column.Tp.GetType() != mysql.TypeTimestamp {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.OnUpdateColumnNotDatetimeOrTimestamp,Content: fmt.Sprintf("Column `%s` use ON UPDATE but is not DATETIME or TIMESTAMP", col.Name),}@@ -881,7 +896,7 @@ func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, pcase tidbast.ColumnOptionComment:comment, err := restoreNode(option.Expr, format.RestoreStringWithoutCharset)if err != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.Internal,Content: fmt.Sprintf("Failed to deparse comment: %v", err),}@@ -908,7 +923,7 @@ func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, p}if !col.Nullable && setNullDefault {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.Content: fmt.Sprintf("Invalid default value for column `%s`", col.Name),@@ -916,21 +931,21 @@ func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, p}if err := t.CreateColumn(col); err != nil {- return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.ColumnExists, Content: err.Error()}}return nil}-func tidbCreateIndexHelper(t *model.TableMetadata, name string, keyList []string, unique bool, tp string, option *tidbast.IndexOption) *WalkThroughError {+func tidbCreateIndexHelper(t *model.TableMetadata, name string, keyList []string, unique bool, tp string, option *tidbast.IndexOption) *catalogutil.WalkThroughError {if len(keyList) == 0 {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.IndexEmptyKeys,Content: fmt.Sprintf("Index `%s` in table `%s` has empty key", name, t.GetProto().Name),}}if name != "" {if t.GetIndex(name) != nil {- return NewIndexExistsError(t.GetProto().Name, name)+ return catalogutil.NewIndexExistsError(t.GetProto().Name, name)}} else {suffix := 1@@ -958,14 +973,14 @@ func tidbCreateIndexHelper(t *model.TableMetadata, name string, keyList []string}if err := t.CreateIndex(index); err != nil {- return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()}}return nil}-func tidbCreatePrimaryKeyHelper(t *model.TableMetadata, keys []string, tp string) *WalkThroughError {+func tidbCreatePrimaryKeyHelper(t *model.TableMetadata, keys []string, tp string) *catalogutil.WalkThroughError {if t.GetIndex(PrimaryKeyName) != nil {- return &WalkThroughError{+ return &catalogutil.WalkThroughError{Code: code.PrimaryKeyExists,Content: fmt.Sprintf("Primary key exists in table `%s`", t.GetProto().Name),}@@ -980,7 +995,7 @@ func tidbCreatePrimaryKeyHelper(t *model.TableMetadata, keys []string, tp stringVisible: true,}if err := t.CreateIndex(pk); err != nil {- return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ return &catalogutil.WalkThroughError{Code: code.IndexExists, Content: err.Error()}}return nil}@@ -1007,3 +1022,8 @@ func getIndexType(option *tidbast.IndexOption) string {}return tidbast.IndexTypeBtree.String()}++// isCurrentDatabase returns true if the given database is the current database.+func isCurrentDatabase(d *model.DatabaseMetadata, database string) bool {+ return catalogutil.CompareIdentifier(d.DatabaseName(), database, !d.GetIsObjectCaseSensitive())+}diff --git a/backend/plugin/schema/tidb/walk_through_test.go b/backend/plugin/schema/tidb/walk_through_test.gonew file mode 100644index 0000000000..ccfd066cb1--- /dev/null+++ b/backend/plugin/schema/tidb/walk_through_test.go@@ -0,0 +1,79 @@+package tidb++import (+ "io"+ "os"+ "path/filepath"+ "testing"++ "github.com/google/go-cmp/cmp"+ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto"+ "google.golang.org/protobuf/testing/protocmp"+ "gopkg.in/yaml.v3"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/component/sheet"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema/catalogutil"+ "github.com/bytebase/bytebase/backend/store/model"+)++type testData struct {+ Statement string+ // Use custom yaml tag to avoid generate field name `ignorecasesensitive`.+ IgnoreCaseSensitive bool `yaml:"ignore_case_sensitive"`+ Want string+ Err *catalogutil.WalkThroughError+}++func TestWalkThrough(t *testing.T) {+ originDatabase := &storepb.DatabaseSchemaMetadata{+ Name: "test",+ }++ tests := []testData{}+ filepath := filepath.Join("testdata", "walk_through.yaml")+ yamlFile, err := os.Open(filepath)+ require.NoError(t, err)+ defer yamlFile.Close()++ byteValue, err := io.ReadAll(yamlFile)+ require.NoError(t, err)+ err = yaml.Unmarshal(byteValue, &tests)+ require.NoError(t, err)+ sm := sheet.NewManager(nil)++ for _, test := range tests {+ // Make a deep copy to avoid mutation across tests+ protoData, ok := proto.Clone(originDatabase).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok)++ // Create DatabaseMetadata for walk-through+ state := model.NewDatabaseMetadata(protoData, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)++ asts, _ := sm.GetASTsForChecks(storepb.Engine_TIDB, test.Statement)+ err := WalkThrough(state, asts)+ if err != nil {+ walkErr, yes := err.(*catalogutil.WalkThroughError)+ require.True(t, yes)+ require.Equal(t, test.Err, walkErr)+ continue+ }+ require.NoError(t, err, test.Statement)++ // Skip comparison if want is empty (error cases)+ if test.Want == "" {+ continue+ }++ want := &storepb.DatabaseSchemaMetadata{}+ err = common.ProtojsonUnmarshaler.Unmarshal([]byte(test.Want), want)+ require.NoError(t, err)+ // Sort proto for deterministic comparison+ state.SortProto()+ result := state.GetProto()+ diff := cmp.Diff(want, result, protocmp.Transform())+ require.Empty(t, diff)+ }+}