Skip to content

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

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.go
deleted file mode 100644
index 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.go
index 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, dbTyp
require.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.go
index 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.go
similarity index 65%
rename from backend/plugin/advisor/catalog/walk_through.go
rename to backend/plugin/schema/catalogutil/types.go
index 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 catalogutil
import (
"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.yaml
similarity index 100%
rename from backend/plugin/advisor/catalog/test/mysql_walk_through.yaml
rename to backend/plugin/schema/mysql/testdata/walk_through.yaml
diff --git a/backend/plugin/advisor/catalog/walk_through_for_mysql.go b/backend/plugin/schema/mysql/walk_through.go
similarity index 85%
rename from backend/plugin/advisor/catalog/walk_through_for_mysql.go
rename to backend/plugin/schema/mysql/walk_through.go
index 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 mysql
import (
"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 int
text string
databaseMetadata *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 TABLE
if 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 exists
if 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 exists
if 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 exist
if 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.RenameTableStatemen
for _, 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.RenameTableStatemen
return
}
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.IRename
return 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, vi
return 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.IAlterListItemCo
columnName := 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.IAlterListItemCo
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),
@@ -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 RenameColumn
if oldColumnName != newColumnName {
// Validate new column doesn't already exist
if 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 column
column = 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, referTab
schema := 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 table
newTable, 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, referTab
for _, 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, referTab
for _, 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 stri
table := 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.IKey
return 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 []st
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),
@@ -1169,9 +1188,9 @@ func mysqlGetIndexType(tableConstraint mysql.ITableConstraintDefContext) string
return "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 m
continue
}
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 m
return 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, fieldDefinitio
mysql.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, fieldDefinitio
return 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.IFieldDefiniti
return 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.go
new file mode 100644
index 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.yaml
similarity index 100%
rename from backend/plugin/advisor/catalog/test/pg_walk_through.yaml
rename to backend/plugin/schema/pg/testdata/walk_through.yaml
diff --git a/backend/plugin/advisor/catalog/walk_through_for_pg.go b/backend/plugin/schema/pg/walk_through.go
similarity index 87%
rename from backend/plugin/advisor/catalog/walk_through_for_pg.go
rename to backend/plugin/schema/pg/walk_through.go
index 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 pg
import (
"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 walkthrough
parseResult, ok := ast.(*pgparser.ParseResult)
if !ok {
@@ -43,12 +54,12 @@ func PgWalkThrough(d *model.DatabaseMetadata, ast any) error {
type pgCatalogListener struct {
*parser.BasePostgreSQLParserListener
databaseState *model.DatabaseMetadata
- err *WalkThroughError
+ err *catalogutil.WalkThroughError
currentLine 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 specified
databaseName := 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 table
table, 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 exists
if 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 type
var columnType string
if columnDef.Typename() != nil {
- columnType = extractTypeName(columnDef.Typename())
+ columnType = extractTypeNameFromContext(columnDef.Typename())
}
// Create column metadata
col := &storepb.ColumnMetadata{
@@ -207,7 +218,7 @@ func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, co
IsConstraint: 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, co
IsConstraint: 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 column
if 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.TableMetad
if 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 exists
if 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.TableMetad
IsConstraint: 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 exists
if 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 exist
for _, 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.TableMetad
IsConstraint: 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.AltertablestmtContex
databaseName := extractDatabaseName(ctx.Relation_expr().Qualified_name())
// Check database access
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()),
})
@@ -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, t
columnName := pgparser.NormalizePostgreSQLColid(allColids[0])
// Check for SET DATA TYPE
if 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, t
if 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, t
for _, 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 dropping
if 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 columns
if 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, t
func (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.SchemaMetada
for _, 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, ta
if 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 type
var typeString string
if columndef.Typename() != nil {
- typeString = extractTypeName(columndef.Typename())
+ typeString = extractTypeNameFromContext(columndef.Typename())
}
// Create column metadata
col := &storepb.ColumnMetadata{
@@ -736,7 +747,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, ta
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()})
return
}
}
@@ -751,7 +762,7 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, ta
}
// Check for collision
if 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, ta
IsConstraint: 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 column
if 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 index
if 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, ta
func (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, col
func (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, co
func (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 exists
if schema.GetTable(newName) != nil {
- return NewRelationExistsError(newName, schema.GetProto().Name)
+ return catalogutil.NewRelationExistsError(newName, schema.GetProto().Name)
}
// Use the RenameTable method from schema
oldName := table.GetProto().Name
if 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 exists
if table.GetColumn(oldName) == nil {
- return NewColumnNotExistsError(table.GetProto().Name, oldName)
+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, oldName)
}
// Validate new column doesn't already exist
if 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 method
if 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 it
for _, 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 exists
if table.GetIndex(newName) != nil {
- return NewRelationExistsError(newName, schema.GetProto().Name)
+ return catalogutil.NewRelationExistsError(newName, schema.GetProto().Name)
}
// Use the RenameIndex method
if 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, ifExists
if ifExists {
return nil
}
- return NewTableNotExistsError(tableName)
+ return catalogutil.NewTableNotExistsError(tableName)
}
// Check if any views depend on this table
dependentViews := schema.GetDependentViews(tableName, "")
@@ -1020,18 +1031,18 @@ func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExists
for _, 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 method
if 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 view
if 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 table
if 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 empty
if 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 view
if 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 database
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()),
})
@@ -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 schema
index := 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 index
table := 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.go
new file mode 100644
index 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.go
index 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, erro
type 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) error
type 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.yaml
similarity index 100%
rename from backend/plugin/advisor/catalog/test/tidb_walk_through.yaml
rename to backend/plugin/schema/tidb/testdata/walk_through.yaml
diff --git a/backend/plugin/advisor/catalog/walk_through_for_tidb.go b/backend/plugin/schema/tidb/walk_through.go
similarity index 80%
rename from backend/plugin/advisor/catalog/walk_through_for_tidb.go
rename to backend/plugin/schema/tidb/walk_through.go
index 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 tidb
import (
"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 *WalkT
case *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.TableToTabl
return 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.AlterDatabaseStm
return 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.CreateIndexS
return 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) *Wa
columnName := spec.OldColumnName.Name.O
// Validate column exists
if 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) *Wa
newColumnName := spec.NewColumnName.Name.O
// Validate old column exists
if table.GetColumn(oldColumnName) == nil {
- return NewColumnNotExistsError(table.GetProto().Name, oldColumnName)
+ return catalogutil.NewColumnNotExistsError(table.GetProto().Name, oldColumnName)
}
// Validate new column doesn't already exist
if 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) *Wa
case tidbast.AlterTableRenameIndex:
// Validate old index exists
if 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 exist
if 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) *Wa
return 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, visibil
return nil
}
-func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef) *WalkThroughError {
+func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef) *catalogutil.WalkThroughError {
columnName := column.Name.Name.L
col := 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 expressions
if 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, newCo
return 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.L
column := 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, nil
default:
- 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) *Walk
if 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 table
newTable, 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 table
for _, 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 := false
for _, 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.Constraint
return 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 []string
for _, 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.L
column := 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, p
pos := len(t.GetColumns()) + 1
if position != nil {
- var err *WalkThroughError
+ var err *catalogutil.WalkThroughError
pos, err = tidbReorderColumn(t, position)
if err != nil {
return err
@@ -855,7 +870,7 @@ func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, p
if 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, p
case tidbast.ColumnOptionOnUpdate:
// we do not deal with ON UPDATE
if 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, p
case 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 string
Visible: 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.go
new file mode 100644
index 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)
+ }
+}