Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: simplify catalog API and remove unnecessary helper methods (#18124)
Danny Xu87df76b6283f
diff --git a/backend/api/v1/release_service_check.go b/backend/api/v1/release_service_check.goindex 4b13e8b575..7ed45e44ce 100644--- a/backend/api/v1/release_service_check.go+++ b/backend/api/v1/release_service_check.go@@ -172,7 +172,7 @@ loop:if dbSchema == nil {return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database schema not found for %s", database.DatabaseName))}- originCatalog, finalCatalog, err := catalog.NewCatalogWithMetadata(dbSchema.GetMetadata(), engine, store.IsObjectCaseSensitive(instance))+ originMetadata, finalMetadata, err := catalog.NewCatalogWithMetadata(dbSchema.GetMetadata(), engine, store.IsObjectCaseSensitive(instance))if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create catalog"))}@@ -308,7 +308,7 @@ loop:checkResult.RiskLevel = riskLevelEnum}if common.EngineSupportSQLReview(engine) {- adviceStatus, sqlReviewAdvices, err := s.runSQLReviewCheckForFile(ctx, originCatalog, finalCatalog, instance, database, changeType, statement)+ adviceStatus, sqlReviewAdvices, err := s.runSQLReviewCheckForFile(ctx, originMetadata, finalMetadata, instance, database, changeType, statement)if err != nil {return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check SQL review"))}@@ -614,8 +614,8 @@ func (s *ReleaseService) checkReleaseDeclarative(ctx context.Context, files []*vfunc (s *ReleaseService) runSQLReviewCheckForFile(ctx context.Context,- originCatalog *model.DatabaseMetadata,- finalCatalog *catalog.DatabaseState,+ originMetadata *model.DatabaseMetadata,+ finalMetadata *model.DatabaseMetadata,instance *store.InstanceMessage,database *store.DatabaseMessage,changeType storepb.PlanCheckRunConfig_ChangeDatabaseType,@@ -663,8 +663,8 @@ func (s *ReleaseService) runSQLReviewCheckForFile(ChangeType: changeType,DBSchema: dbMetadata,DBType: instance.Metadata.GetEngine(),- OriginalMetadata: originCatalog,- FinalCatalog: finalCatalog,+ OriginalMetadata: originMetadata,+ FinalMetadata: finalMetadata,Driver: connection,CurrentDatabase: database.DatabaseName,ClassificationConfig: classificationConfig,diff --git a/backend/plugin/advisor/advisor.go b/backend/plugin/advisor/advisor.goindex 8b23571d4f..903be0efa0 100644--- a/backend/plugin/advisor/advisor.go+++ b/backend/plugin/advisor/advisor.go@@ -13,7 +13,6 @@ import ("github.com/bytebase/bytebase/backend/common/log"storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/advisor/catalog""github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/store/model")@@ -49,7 +48,7 @@ type Context struct {AST anyRule *storepb.SQLReviewRuleOriginalMetadata *model.DatabaseMetadata- FinalCatalog *catalog.DatabaseState+ FinalMetadata *model.DatabaseMetadataDriver *sql.DB// CurrentDatabase is the current database.diff --git a/backend/plugin/advisor/catalog/catalog.go b/backend/plugin/advisor/catalog/catalog.goindex 4c0a9a4593..67d52b0a78 100644--- a/backend/plugin/advisor/catalog/catalog.go+++ b/backend/plugin/advisor/catalog/catalog.go@@ -2,6 +2,8 @@package catalogimport (+ "errors"+"google.golang.org/protobuf/proto"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -9,17 +11,34 @@ import ()// NewCatalogWithMetadata creates original and final database catalogs from schema metadata.-// OriginalMetadata is DatabaseMetadata (read-only), FinalCatalog is DatabaseState (mutable for walk-through).-func NewCatalogWithMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType storepb.Engine, isCaseSensitive bool) (originalMetadata *model.DatabaseMetadata, final *DatabaseState, err error) {- // Create original metadata from original metadata as DatabaseMetadata (read-only)- originalSchema := model.NewDatabaseSchema(metadata, nil, nil, engineType, isCaseSensitive)- originalMetadata = originalSchema.GetDatabaseMetadata()+// Both are DatabaseMetadata - original is the starting state, final is mutable for walk-through.+func NewCatalogWithMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType storepb.Engine, isObjectCaseSensitive bool) (originalMetadata *model.DatabaseMetadata, final *model.DatabaseMetadata, err error) {+ // Determine detail case sensitivity based on engine type+ isDetailCaseSensitive := getIsDetailCaseSensitive(engineType)++ // Create original metadata as read-only+ originalMetadata = model.NewDatabaseMetadata(metadata, isObjectCaseSensitive, isDetailCaseSensitive)// Clone metadata for final to avoid modifying the original- clonedMetadata := proto.CloneOf(metadata)+ cloned := proto.Clone(metadata)+ clonedMetadata, ok := cloned.(*storepb.DatabaseSchemaMetadata)+ if !ok {+ return nil, nil, errors.New("failed to clone database schema metadata")+ }- // Create final as DatabaseState (mutable for walk-through)- final = NewDatabaseState(clonedMetadata, !isCaseSensitive, engineType)+ // Create final as mutable for walk-through+ final = model.NewDatabaseMetadata(clonedMetadata, isObjectCaseSensitive, isDetailCaseSensitive)return originalMetadata, final, nil}++// getIsDetailCaseSensitive determines if detail names (columns, indexes) are case-sensitive+// based on the database engine type.+func getIsDetailCaseSensitive(engine storepb.Engine) bool {+ switch engine {+ case storepb.Engine_MYSQL, storepb.Engine_MARIADB, storepb.Engine_TIDB, storepb.Engine_MSSQL, storepb.Engine_OCEANBASE:+ return false+ default:+ return true+ }+}diff --git a/backend/plugin/advisor/catalog/catalog_test.go b/backend/plugin/advisor/catalog/catalog_test.godeleted file mode 100644index 5923cf190c..0000000000--- a/backend/plugin/advisor/catalog/catalog_test.go+++ /dev/null@@ -1,49 +0,0 @@-package catalog--import (- "testing"-- "github.com/stretchr/testify/require"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"-)--func TestNewCatalogWithMetadata(t *testing.T) {- metadata := &storepb.DatabaseSchemaMetadata{- Name: "testdb",- Schemas: []*storepb.SchemaMetadata{- {- Name: "public",- Tables: []*storepb.TableMetadata{- {Name: "users"},- },- },- },- }-- origin, final, err := NewCatalogWithMetadata(metadata, storepb.Engine_POSTGRES, true)-- require.Nil(t, err)- require.NotNil(t, origin)- require.NotNil(t, final)-- // Verify both have the table initially- require.NotNil(t, origin.GetSchema("public").GetTable("users"))- finalSchema, err := final.GetSchema("public")- require.Nil(t, err)- finalTable, err := finalSchema.GetTable("users")- require.Nil(t, err)- require.NotNil(t, finalTable)-- // Mutate final - DatabaseState CreateTable returns (*TableState, *WalkThroughError)- _, walkErr := finalSchema.CreateTable("products")- require.Nil(t, walkErr)-- // Verify origin is unchanged (DatabaseMetadata)- require.Nil(t, origin.GetSchema("public").GetTable("products"))-- // Verify final has the new table (DatabaseState)- newTable, walkErr := finalSchema.GetTable("products")- require.Nil(t, walkErr)- require.NotNil(t, newTable)-}diff --git a/backend/plugin/advisor/catalog/state.go b/backend/plugin/advisor/catalog/state.godeleted file mode 100644index b597f78e27..0000000000--- a/backend/plugin/advisor/catalog/state.go+++ /dev/null@@ -1,1066 +0,0 @@-package catalog--// This file defines the internal database state used during walk-through.-//-// INTERNAL USE ONLY: DatabaseState is an internal implementation detail of the catalog package.-// External code should use model.DatabaseMetadata instead.-//-// DatabaseState is used internally for:-// 1. Walk-through implementations (MySQLWalkThrough, PgWalkThrough, TiDBWalkThrough)-// 2. Advisor rules that need mutable catalog operations-//-// The public API uses model.DatabaseMetadata, which provides a cleaner interface-// and better integration with the rest of the codebase.--import (- "fmt"- "strings"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-)--// NewDatabaseState creates a new database state from schema metadata and context.-func NewDatabaseState(d *storepb.DatabaseSchemaMetadata, ignoreCaseSensitive bool, engineType storepb.Engine) *DatabaseState {- database := &DatabaseState{- ignoreCaseSensitive: ignoreCaseSensitive,- name: d.Name,- characterSet: d.CharacterSet,- collation: d.Collation,- dbType: engineType,- schemaSet: make(schemaStateMap),- }-- for _, schema := range d.Schemas {- database.schemaSet[schema.Name] = newSchemaState(schema, database.ignoreCaseSensitive, database.dbType)- }-- for _, schema := range d.Schemas {- for _, view := range schema.Views {- for _, dependencyColumn := range view.DependencyColumns {- if schemaState, exist := database.schemaSet[dependencyColumn.Schema]; exist {- if tableState, exist := mysqlGetTable(schemaState, dependencyColumn.Table); exist {- tableState.dependencyView[fmt.Sprintf("%q.%q", schema.Name, view.Name)] = true- if columnState, exist := tableState.columnSet[dependencyColumn.Column]; exist {- columnState.dependencyView[fmt.Sprintf("%q.%q", schema.Name, view.Name)] = true- }- }- }- }- }- }-- return database-}--func newSchemaState(s *storepb.SchemaMetadata, ignoreCaseSensitive bool, engineType storepb.Engine) *SchemaState {- schema := &SchemaState{- ignoreCaseSensitive: ignoreCaseSensitive,- name: s.Name,- tableSet: make(tableStateMap),- viewSet: make(viewStateMap),- identifierMap: make(identifierMap),- }-- for _, table := range s.Tables {- tableState := newTableState(table, engineType)- schema.tableSet[table.Name] = tableState-- schema.identifierMap[table.Name] = true- for indexName := range tableState.indexSet {- schema.identifierMap[indexName] = true- }- }-- for _, view := range s.Views {- schema.viewSet[view.Name] = newViewState(view)-- schema.identifierMap[view.Name] = true- }-- return schema-}--func newViewState(v *storepb.ViewMetadata) *ViewState {- return &ViewState{- name: v.Name,- definition: v.Definition,- comment: v.Comment,- }-}--func newTableState(t *storepb.TableMetadata, engineType storepb.Engine) *TableState {- table := &TableState{- name: t.Name,- engine: t.Engine,- collation: t.Collation,- comment: t.Comment,- columnSet: make(columnStateMap),- indexSet: make(IndexStateMap),- dependencyView: make(map[string]bool),- }-- for i, column := range t.Columns {- columnName := column.Name- switch engineType {- case storepb.Engine_MYSQL, storepb.Engine_TIDB, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:- columnName = strings.ToLower(columnName)- default:- // For other engine types, keep the original column name without normalization- }- table.columnSet[columnName] = newColumnState(column, i+1)- }-- for _, index := range t.Indexes {- indexName := index.Name- switch engineType {- case storepb.Engine_MYSQL, storepb.Engine_TIDB, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:- indexName = strings.ToLower(indexName)- default:- // For other engine types, keep the original index name without normalization- }- table.indexSet[indexName] = newIndexState(index)- }-- return table-}--func newColumnState(c *storepb.ColumnMetadata, position int) *ColumnState {- return &ColumnState{- name: c.Name,- position: position,- defaultValue: c.Default,- nullable: c.Nullable,- columnType: c.Type,- characterSet: c.CharacterSet,- collation: c.Collation,- comment: c.Comment,- dependencyView: make(map[string]bool),- }-}--func newIndexState(i *storepb.IndexMetadata) *IndexState {- index := &IndexState{- name: i.Name,- indexType: i.Type,- unique: i.Unique,- primary: i.Primary,- visible: i.Visible,- comment: i.Comment,- expressionList: copyStringSlice(i.Expressions),- // We rudely think that pk and uk are constraints here.- // But in fact, we can create uk by CREATE UNIQUE INDEX statements.- isConstraint: i.Primary || i.Unique,- }- return index-}--// DatabaseState is the state for walk-through.-type DatabaseState struct {- ignoreCaseSensitive bool- name string- characterSet string- collation string- dbType storepb.Engine- schemaSet schemaStateMap- deleted bool-}--// Index returns the index map of the table.-func (d *DatabaseState) Index(schemaName string, tableName string) *IndexStateMap {- schema, exists := d.schemaSet[schemaName]- if !exists {- return nil- }- return schema.Index(tableName)-}--// HasNoTable returns true if the current database has no table.-func (d *DatabaseState) HasNoTable() bool {- for _, schema := range d.schemaSet {- if len(schema.tableSet) != 0 {- return false- }- }-- return true-}--func (d *DatabaseState) HasSchema(name string) bool {- _, exists := d.schemaSet[name]- return exists-}--// DatabaseName returns the database name.-func (d *DatabaseState) DatabaseName() string {- return d.name-}--// GetIndex gets the index.-func (d *DatabaseState) GetIndex(schemaName string, tableName string, indexName string) (string, *IndexState) {- switch d.dbType {- case storepb.Engine_MYSQL, storepb.Engine_TIDB, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:- indexName = strings.ToLower(indexName)- default:- // For other engine types, keep the original index name without normalization- }- // There are two cases to find a index:- // 1. find an index in specific table. e.g. MySQL and TiDB.- // 2. find an index in the schema. e.g. PostgreSQL.- // In PostgreSQL, the index name is unique in a schema, not a table.- // In MySQL and TiDB, the index name is unique in a table.- // So for case one, we need match table name, but for case two, we don't need.- needMatchTable := (d.dbType != storepb.Engine_POSTGRES || schemaName == "" || tableName != "")- if needMatchTable {- schema, exists := d.schemaSet[schemaName]- if !exists {- return "", nil- }- table, exists := mysqlGetTable(schema, tableName)- if !exists {- return "", nil- }- index, exists := table.indexSet[indexName]- if !exists {- return "", nil- }- return table.name, index- }- for _, schema := range d.schemaSet {- if schema.name != schemaName {- continue- }- for _, table := range schema.tableSet {- // no need to further match table name because index is already unique in the schema- index, exists := table.indexSet[indexName]- if !exists {- return "", nil- }- return table.name, index- }- }- return "", nil-}--// GetPrimaryKey gets the primary key.-func (d *DatabaseState) GetPrimaryKey(schemaName string, tableName string) *IndexState {- for _, schema := range d.schemaSet {- if schema.name != schemaName {- continue- }- for _, table := range schema.tableSet {- if !compareIdentifier(table.name, tableName, schema.ignoreCaseSensitive) {- continue- }- for _, index := range table.indexSet {- if index.primary {- return index- }- }- }- }- return nil-}--// HasPrimaryKey checks if a table has a primary key.-func (d *DatabaseState) HasPrimaryKey(schemaName string, tableName string) bool {- return d.GetPrimaryKey(schemaName, tableName) != nil-}--// CountColumn counts columns.-func (d *DatabaseState) CountColumn(schemaName string, tableName string, columnType string) int {- schema, exists := d.schemaSet[schemaName]- if !exists {- return 0- }- table, exists := mysqlGetTable(schema, tableName)- if !exists {- return 0- }- res := 0- for _, column := range table.columnSet {- if strings.EqualFold(column.columnType, columnType) {- res++- }- }- return res-}--// GetColumn gets the column.-func (d *DatabaseState) GetColumn(schemaName string, tableName string, columnName string) *ColumnState {- switch d.dbType {- case storepb.Engine_MYSQL, storepb.Engine_TIDB, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:- columnName = strings.ToLower(columnName)- default:- // For other engine types, keep the original column name without normalization- }- schema, exists := d.schemaSet[schemaName]- if !exists {- return nil- }- table, exists := mysqlGetTable(schema, tableName)- if !exists {- return nil- }- column, exists := table.columnSet[columnName]- if !exists {- return nil- }- return column-}--// GetTable gets the table.-func (d *DatabaseState) GetTable(schemaName string, tableName string) *TableState {- schema, exists := d.schemaSet[schemaName]- if !exists {- return nil- }- table, exists := mysqlGetTable(schema, tableName)- if !exists {- return nil- }- return table-}--type identifierMap map[string]bool--// SchemaState is the state for walk-through.-type SchemaState struct {- ignoreCaseSensitive bool- name string- tableSet tableStateMap- viewSet viewStateMap-- // PostgreSQL specific fields- // All relation names in PostgreSQL must be distinct in schema level.- identifierMap identifierMap-}--func (s *SchemaState) Index(tableName string) *IndexStateMap {- table, exists := mysqlGetTable(s, tableName)- if !exists {- return nil- }- return table.Index()-}--type schemaStateMap map[string]*SchemaState--// TableState is the state for walk-through.-type TableState struct {- name string- // engine isn't supported for Postgres, Snowflake, SQLite.- engine string- // collation isn't supported for Postgres, ClickHouse, Snowflake, SQLite.- collation string- // comment isn't supported for SQLite.- comment string- columnSet columnStateMap- // indexSet isn't supported for ClickHouse, Snowflake.- indexSet IndexStateMap-- // dependencyView is used to record the dependency view for the table.- // Used to check if the table is used by any view.- dependencyView map[string]bool-}--// ListColumns return the list of columns.-func (t *TableState) ListColumns() []*ColumnState {- var columns []*ColumnState- for _, v := range t.columnSet {- columns = append(columns, v)- }- return columns-}--// CountIndex return the index total number.-func (t *TableState) CountIndex() int {- return len(t.indexSet)-}--// Index return the index map of table.-func (t *TableState) Index() *IndexStateMap {- return &t.indexSet-}--func (t *TableState) copy() *TableState {- return &TableState{- name: t.name,- engine: t.engine,- collation: t.collation,- comment: t.comment,- columnSet: t.columnSet.copy(),- indexSet: t.indexSet.copy(),- }-}--type tableStateMap map[string]*TableState--// IndexState is the state for walk-through.-type IndexState struct {- name string- // This could refer to a column or an expression.- expressionList []string- // Type isn't supported for SQLite.- indexType string- unique bool- primary bool- // Visible isn't supported for Postgres, SQLite.- visible bool- // Comment isn't supported for SQLite.- comment string-- // PostgreSQL specific fields.-- // PostgreSQL treats INDEX and CONSTRAINT differently.- isConstraint bool-}--func (idx *IndexState) copy() *IndexState {- return &IndexState{- name: idx.name,- expressionList: copyStringSlice(idx.expressionList),- indexType: idx.indexType,- unique: idx.unique,- primary: idx.primary,- visible: idx.visible,- comment: idx.comment,- isConstraint: idx.isConstraint,- }-}--// Unique returns the unique for the index.-func (idx *IndexState) Unique() bool {- return idx.unique-}--// Primary returns the primary for the index.-func (idx *IndexState) Primary() bool {- return idx.primary-}--// ExpressionList returns the expression list for the index.-func (idx *IndexState) ExpressionList() []string {- return idx.expressionList-}--type IndexStateMap map[string]*IndexState--func (m IndexStateMap) copy() IndexStateMap {- res := make(IndexStateMap)- for k, v := range m {- res[k] = v.copy()- }- return res-}--// ColumnState is the state for walk-through.-type ColumnState struct {- name string- position int- defaultValue string- // nullable isn't supported for ClickHouse.- nullable bool- columnType string- // characterSet isn't supported for Postgres, ClickHouse, SQLite.- characterSet string- // collation isn't supported for ClickHouse, SQLite.- collation string- // comment isn't supported for SQLite.- comment string-- // dependencyView is used to record the dependency view for the column.- // Used to check if the column is used by any view.- dependencyView map[string]bool-}--func (col *ColumnState) copy() *ColumnState {- return &ColumnState{- name: col.name,- position: col.position,- defaultValue: col.defaultValue,- nullable: col.nullable,- columnType: col.columnType,- characterSet: col.characterSet,- collation: col.collation,- comment: col.comment,- }-}--// Nullable returns nullable for the column.-func (col *ColumnState) Nullable() bool {- return col.nullable-}--// Type returns type for the column.-func (col *ColumnState) Type() string {- return col.columnType-}--// HasDefault returns if column has default value.-func (col *ColumnState) HasDefault() bool {- switch strings.ToLower(col.Type()) {- case "serial", "smallserial", "bigserial":- return true- default:- // For other column types, check if defaultValue is not empty- }- return col.defaultValue != ""-}--type columnStateMap map[string]*ColumnState--func (m columnStateMap) copy() columnStateMap {- res := make(columnStateMap)- for k, v := range m {- res[k] = v.copy()- }- return res-}--// ViewState is the state for walk-through.-type ViewState struct {- name string- definition string- comment string-}-type viewStateMap map[string]*ViewState--func copyStringSlice(in []string) []string {- var res []string- res = append(res, in...)- return res-}--// Schema-level operations.--// CreateSchema creates a new schema state with the given name.-func (d *DatabaseState) CreateSchema(schemaName string) *SchemaState {- schema := &SchemaState{- ignoreCaseSensitive: d.ignoreCaseSensitive,- name: schemaName,- tableSet: make(tableStateMap),- viewSet: make(viewStateMap),- identifierMap: make(identifierMap),- }- d.schemaSet[schemaName] = schema- return schema-}--// GetSchema gets an existing schema.-func (d *DatabaseState) GetSchema(schemaName string) (*SchemaState, *WalkThroughError) {- if schema, exists := d.schemaSet[schemaName]; exists {- return schema, nil- }- return nil, &WalkThroughError{- Code: code.SchemaNotExists,- Content: fmt.Sprintf("The schema %q doesn't exist", schemaName),- }-}--// DropSchema drops a schema.-func (d *DatabaseState) DropSchema(schemaName string) *WalkThroughError {- schema, exists := d.schemaSet[schemaName]- if !exists {- return &WalkThroughError{- Code: code.SchemaNotExists,- Content: fmt.Sprintf("Schema %q does not exist", schemaName),- }- }-- // Delete all identifiers in this schema- for tableName := range schema.tableSet {- delete(schema.identifierMap, tableName)- }- for viewName := range schema.viewSet {- delete(schema.identifierMap, viewName)- }-- // Delete the schema- delete(d.schemaSet, schemaName)- return nil-}--// Table-level operations.--// CreateTable creates a new table in the schema.-func (s *SchemaState) CreateTable(tableName string) (*TableState, *WalkThroughError) {- if _, exists := mysqlGetTable(s, tableName); exists {- return nil, NewTableExistsError(tableName)- }-- table := &TableState{- name: tableName,- engine: "",- collation: "",- comment: "",- columnSet: make(columnStateMap),- indexSet: make(IndexStateMap),- dependencyView: make(map[string]bool),- }- s.tableSet[tableName] = table-- // For PostgreSQL, track in identifier map- if s.identifierMap != nil {- s.identifierMap[tableName] = true- }-- return table, nil-}--// GetTable gets a table from the schema.-func (s *SchemaState) GetTable(tableName string) (*TableState, *WalkThroughError) {- table, exists := s.tableSet[tableName]- if !exists {- return nil, &WalkThroughError{- Code: code.TableNotExists,- Content: fmt.Sprintf("The table %q does not exist in schema %q", tableName, s.name),- }- }- return table, nil-}--// DropTable drops a table from the schema.-func (s *SchemaState) DropTable(tableName string, checkViewDependency func(*TableState) ([]string, *WalkThroughError)) *WalkThroughError {- table, err := s.GetTable(tableName)- if err != nil {- return err- }-- // Check for view dependencies if checker is provided- if checkViewDependency != nil {- viewList, err := checkViewDependency(table)- if err != nil {- return err- }- if len(viewList) > 0 {- return &WalkThroughError{- Code: code.TableIsReferencedByView,- Content: fmt.Sprintf("Cannot drop table %q.%q, it's referenced by view: %s", s.name, table.name, strings.Join(viewList, ", ")),- }- }- }-- // Delete all indexes associated with the table (for PostgreSQL identifier map)- if s.identifierMap != nil {- for indexName := range table.indexSet {- delete(s.identifierMap, indexName)- }- delete(s.identifierMap, table.name)- }-- delete(s.tableSet, tableName)- return nil-}--// RenameTable renames a table in the schema.-func (s *SchemaState) RenameTable(oldName string, newName string) *WalkThroughError {- if oldName == newName {- return nil- }-- table, exists := mysqlGetTable(s, oldName)- if !exists {- return NewTableNotExistsError(oldName)- }-- if _, exists := mysqlGetTable(s, newName); exists {- return NewTableExistsError(newName)- }-- // For PostgreSQL, update identifier map- if s.identifierMap != nil {- if _, exists := s.identifierMap[newName]; exists {- return NewRelationExistsError(newName, s.name)- }- delete(s.identifierMap, table.name)- s.identifierMap[newName] = true- }-- table.name = newName- delete(s.tableSet, oldName)- s.tableSet[newName] = table- return nil-}--// Column-level operations.--// CreateColumn creates a new column in the table.-func (t *TableState) CreateColumn(columnName string, columnType string, nullable bool, defaultValue string, position int, characterSet string, collation string, comment string) *WalkThroughError {- if _, exists := t.columnSet[strings.ToLower(columnName)]; exists {- return &WalkThroughError{- Code: code.ColumnExists,- Content: fmt.Sprintf("Column `%s` already exists in table `%s`", columnName, t.name),- }- }-- pos := len(t.columnSet) + 1- if position != 0 {- pos = position- }-- col := &ColumnState{- name: columnName,- position: pos,- defaultValue: defaultValue,- nullable: nullable,- columnType: columnType,- characterSet: characterSet,- collation: collation,- comment: comment,- dependencyView: make(map[string]bool),- }- t.columnSet[strings.ToLower(columnName)] = col- return nil-}--// GetColumn gets a column from the table.-func (t *TableState) GetColumn(columnName string) (*ColumnState, *WalkThroughError) {- column, exists := t.columnSet[strings.ToLower(columnName)]- if !exists {- return nil, NewColumnNotExistsError(t.name, columnName)- }- return column, nil-}--// DropColumn drops a column from the table.-func (t *TableState) DropColumn(columnName string, checkViewDependency func(*ColumnState) ([]string, *WalkThroughError)) *WalkThroughError {- column, exists := t.columnSet[strings.ToLower(columnName)]- if !exists {- return NewColumnNotExistsError(t.name, columnName)- }-- // Cannot drop all columns in a table using ALTER TABLE DROP COLUMN.- if len(t.columnSet) == 1 {- return &WalkThroughError{- Code: code.DropAllColumns,- Content: fmt.Sprintf("Can't delete all columns with ALTER TABLE; use DROP TABLE %s instead", t.name),- }- }-- // Check for view dependencies if checker is provided- if checkViewDependency != nil {- viewList, err := checkViewDependency(column)- if err != nil {- return err- }- if len(viewList) > 0 {- return &WalkThroughError{- Code: code.ColumnIsReferencedByView,- Content: fmt.Sprintf("Cannot drop column %q in table %q, it's referenced by view: %s", column.name, t.name, strings.Join(viewList, ", ")),- }- }- }-- // Modify the column position- for _, col := range t.columnSet {- if col.position > column.position {- col.position--- }- }-- // Remove column from indexes, and drop indexes that become empty- for _, index := range t.indexSet {- // Remove the column from the index key list- var newKeyList []string- for _, key := range index.expressionList {- if !strings.EqualFold(key, columnName) {- newKeyList = append(newKeyList, key)- }- }- index.expressionList = newKeyList-- // If all columns that make up an index are dropped, the index is dropped as well- if len(index.expressionList) == 0 {- delete(t.indexSet, strings.ToLower(index.name))- }- }-- delete(t.columnSet, strings.ToLower(columnName))- return nil-}--// RenameColumn renames a column in the table.-func (t *TableState) RenameColumn(oldName string, newName string) *WalkThroughError {- if strings.EqualFold(oldName, newName) {- return nil- }-- column, exists := t.columnSet[strings.ToLower(oldName)]- if !exists {- return NewColumnNotExistsError(t.name, oldName)- }-- if _, exists := t.columnSet[strings.ToLower(newName)]; exists {- return &WalkThroughError{- Code: code.ColumnExists,- Content: fmt.Sprintf("Column `%s` already exists in table `%s`", newName, t.name),- }- }-- // Rename column in all indexes that reference it- for _, index := range t.indexSet {- for i, key := range index.expressionList {- if strings.EqualFold(key, oldName) {- index.expressionList[i] = newName- }- }- }-- column.name = newName- delete(t.columnSet, strings.ToLower(oldName))- t.columnSet[strings.ToLower(newName)] = column- return nil-}--// Index-level operations.--// CreateIndex creates a new index in the table.-func (t *TableState) CreateIndex(indexName string, expressionList []string, unique bool, indexType string, primary bool, visible bool, comment string, isConstraint bool, identifierMap identifierMap) *WalkThroughError {- if len(expressionList) == 0 {- return &WalkThroughError{- Code: code.IndexEmptyKeys,- Content: fmt.Sprintf("Index `%s` in table `%s` has empty key", indexName, t.name),- }- }-- // Auto-generate name if empty- if indexName == "" {- suffix := 1- baseName := expressionList[0]- for {- indexName = baseName- if suffix > 1 {- indexName = fmt.Sprintf("%s_%d", baseName, suffix)- }- if _, exists := t.indexSet[strings.ToLower(indexName)]; !exists {- break- }- suffix++- }- } else {- // Check if index already exists- if _, exists := t.indexSet[strings.ToLower(indexName)]; exists {- return NewIndexExistsError(t.name, indexName)- }- }-- // For PostgreSQL, check identifier map- if identifierMap != nil {- if _, exists := identifierMap[indexName]; exists {- return NewRelationExistsError(indexName, "")- }- }-- index := &IndexState{- name: indexName,- expressionList: expressionList,- indexType: indexType,- unique: unique,- primary: primary,- visible: visible,- comment: comment,- isConstraint: isConstraint,- }- t.indexSet[strings.ToLower(indexName)] = index-- // For PostgreSQL, track in identifier map- if identifierMap != nil {- identifierMap[indexName] = true- }-- return nil-}--// CreatePrimaryKey creates a primary key index in the table.-func (t *TableState) CreatePrimaryKey(keyList []string, indexType string, identifierMap identifierMap) *WalkThroughError {- pkName := PrimaryKeyName-- if _, exists := t.indexSet[strings.ToLower(pkName)]; exists {- return &WalkThroughError{- Code: code.PrimaryKeyExists,- Content: fmt.Sprintf("Primary key exists in table `%s`", t.name),- }- }-- // For PostgreSQL, check identifier map- if identifierMap != nil {- if _, exists := identifierMap[pkName]; exists {- return NewRelationExistsError(pkName, "")- }- }-- pk := &IndexState{- name: pkName,- expressionList: keyList,- indexType: indexType,- unique: true,- primary: true,- visible: true,- comment: "",- isConstraint: true,- }- t.indexSet[strings.ToLower(pkName)] = pk-- // For PostgreSQL, track in identifier map- if identifierMap != nil {- identifierMap[pkName] = true- }-- return nil-}--// GetIndex gets an index from the table.-func (t *TableState) GetIndex(indexName string) (*IndexState, *WalkThroughError) {- index, exists := t.indexSet[strings.ToLower(indexName)]- if !exists {- return nil, NewIndexNotExistsError(t.name, indexName)- }- return index, nil-}--// DropIndex drops an index from the table.-func (t *TableState) DropIndex(indexName string, identifierMap identifierMap) *WalkThroughError {- if _, exists := t.indexSet[strings.ToLower(indexName)]; !exists {- if strings.EqualFold(indexName, PrimaryKeyName) {- return &WalkThroughError{- Code: code.PrimaryKeyNotExists,- Content: fmt.Sprintf("Primary key does not exist in table `%s`", t.name),- }- }- return NewIndexNotExistsError(t.name, indexName)- }-- // For PostgreSQL, remove from identifier map- if identifierMap != nil {- delete(identifierMap, indexName)- }-- delete(t.indexSet, strings.ToLower(indexName))- return nil-}--// RenameIndex renames an index in the table.-func (t *TableState) RenameIndex(oldName string, newName string, identifierMap identifierMap) *WalkThroughError {- // For MySQL, the primary key has a special name 'PRIMARY'.- if strings.ToUpper(oldName) == PrimaryKeyName || strings.ToUpper(newName) == PrimaryKeyName {- incorrectName := oldName- if strings.ToUpper(oldName) != PrimaryKeyName {- incorrectName = newName- }- return &WalkThroughError{- Code: code.IncorrectIndexName,- Content: fmt.Sprintf("Incorrect index name `%s`", incorrectName),- }- }-- index, exists := t.indexSet[strings.ToLower(oldName)]- if !exists {- return NewIndexNotExistsError(t.name, oldName)- }-- if _, exists := t.indexSet[strings.ToLower(newName)]; exists {- return NewIndexExistsError(t.name, newName)- }-- // For PostgreSQL, update identifier map- if identifierMap != nil {- if _, exists := identifierMap[newName]; exists {- return NewRelationExistsError(newName, "")- }- delete(identifierMap, oldName)- identifierMap[newName] = true- }-- index.name = newName- delete(t.indexSet, strings.ToLower(oldName))- t.indexSet[strings.ToLower(newName)] = index- return nil-}--// View-level operations.--// CreateView creates a new view in the schema.-func (s *SchemaState) CreateView(viewName string, definition string, comment string) (*ViewState, *WalkThroughError) {- view := &ViewState{- name: viewName,- definition: definition,- comment: comment,- }- s.viewSet[viewName] = view-- // For PostgreSQL, track in identifier map- if s.identifierMap != nil {- s.identifierMap[viewName] = true- }-- return view, nil-}--// DropView drops a view from the schema.-func (s *SchemaState) DropView(viewName string, identifierMap identifierMap) *WalkThroughError {- // For PostgreSQL, remove from identifier map- if identifierMap != nil {- delete(identifierMap, viewName)- }-- delete(s.viewSet, viewName)- return nil-}--// Database-level operations.--// MarkDeleted marks the database as deleted.-func (d *DatabaseState) MarkDeleted() {- d.deleted = true-}--// IsDeleted returns true if the database is marked as deleted.-func (d *DatabaseState) IsDeleted() bool {- return d.deleted-}--// SetCharacterSet sets the character set of the database.-func (d *DatabaseState) SetCharacterSet(characterSet string) {- d.characterSet = characterSet-}--// SetCollation sets the collation of the database.-func (d *DatabaseState) SetCollation(collation string) {- d.collation = collation-}--// SetTableEngine sets the engine of the table.-func (t *TableState) SetEngine(engine string) {- t.engine = engine-}--// SetTableCollation sets the collation of the table.-func (t *TableState) SetCollation(collation string) {- t.collation = collation-}--// SetTableComment sets the comment of the table.-func (t *TableState) SetComment(comment string) {- t.comment = comment-}--// SetColumnNullable sets the nullable property of the column.-func (col *ColumnState) SetNullable(nullable bool) {- col.nullable = nullable-}--// SetColumnDefault sets the default value of the column.-func (col *ColumnState) SetDefault(defaultValue string) {- col.defaultValue = defaultValue-}--// SetColumnType sets the type of the column.-func (col *ColumnState) SetType(columnType string) {- col.columnType = columnType-}--// SetIndexVisibility sets the visibility of the index.-func (idx *IndexState) SetVisibility(visible bool) {- idx.visible = visible-}diff --git a/backend/plugin/advisor/catalog/test/mysql_walk_through_for_incomplete.yaml b/backend/plugin/advisor/catalog/test/mysql_walk_through_for_incomplete.yamldeleted file mode 100644index 43372ba4a3..0000000000--- a/backend/plugin/advisor/catalog/test/mysql_walk_through_for_incomplete.yaml+++ /dev/null@@ -1,266 +0,0 @@-- statement: CREATE INDEX idx_a on t(a)- ignore_case_sensitive: false- want: |-- {- "schemas": [- {- "tables": [- {- "name": "t",- "indexes": [- {- "name": "idx_a",- "expressions": [- "a"- ],- "type": "BTREE",- "visible": true- }- ]- }- ]- }- ]- }- err: null-- statement: ALTER TABLE t RENAME COLUMN a TO a_copy- ignore_case_sensitive: false- want: |-- {- "schemas": [- {- "tables": [- {- "name": "t",- "columns": [- {- "name": "a_copy"- }- ]- }- ]- }- ]- }- err: null-- statement: ALTER TABLE t RENAME TO t1- ignore_case_sensitive: false- want: |-- {- "schemas": [- {- "tables": [- {- "name": "t1"- }- ]- }- ]- }- err: null-- statement: |-- ALTER TABLE t ADD PRIMARY KEY (a);- ALTER TABLE t ADD UNIQUE (b);- CREATE INDEX idx_a on t(a);- CREATE INDEX b_2 on t(b, a);- CREATE UNIQUE INDEX b_3 on t(b, c, d);- CREATE FULLTEXT INDEX b_4 on t(b, d) WITH PARSER ngram INVISIBLE;- ignore_case_sensitive: false- want: |-- {- "schemas": [- {- "tables": [- {- "name": "t",- "indexes": [- {- "name": "PRIMARY",- "expressions": [- "a"- ],- "type": "BTREE",- "unique": true,- "primary": true,- "visible": true- },- {- "name": "b",- "expressions": [- "b"- ],- "type": "BTREE",- "unique": true,- "visible": true- },- {- "name": "b_2",- "expressions": [- "b",- "a"- ],- "type": "BTREE",- "visible": true- },- {- "name": "b_3",- "expressions": [- "b",- "c",- "d"- ],- "type": "BTREE",- "unique": true,- "visible": true- },- {- "name": "b_4",- "expressions": [- "b",- "d"- ],- "type": "FULLTEXT"- },- {- "name": "idx_a",- "expressions": [- "a"- ],- "type": "BTREE",- "visible": true- }- ]- }- ]- }- ]- }- err: null-- statement: |-- CREATE TABLE t(- a int PRIMARY KEY DEFAULT 1,- b varchar(200) CHARACTER SET utf8mb4 NOT NULL UNIQUE,- c int auto_increment NULL COMMENT 'This is a comment',- d varchar(10) COLLATE utf8mb4_polish_ci,- KEY idx_a (a),- INDEX (b, a),- UNIQUE (b, c, d),- FULLTEXT (b, d) WITH PARSER ngram INVISIBLE- )- ignore_case_sensitive: false- want: |-- {- "schemas": [- {- "tables": [- {- "name": "t",- "columns": [- {- "name": "a",- "position": 1,- "default": "1",- "type": "int"- },- {- "name": "b",- "position": 2,- "type": "varchar",- "characterSet": "utf8mb4"- },- {- "name": "c",- "position": 3,- "nullable": true,- "type": "int",- "comment": "This is a comment"- },- {- "name": "d",- "position": 4,- "nullable": true,- "type": "varchar",- "collation": "utf8mb4_polish_ci"- }- ],- "indexes": [- {- "name": "PRIMARY",- "expressions": [- "a"- ],- "type": "BTREE",- "unique": true,- "primary": true,- "visible": true- },- {- "name": "b",- "expressions": [- "b"- ],- "type": "BTREE",- "unique": true,- "visible": true- },- {- "name": "b_2",- "expressions": [- "b",- "a"- ],- "type": "BTREE",- "visible": true- },- {- "name": "b_3",- "expressions": [- "b",- "c",- "d"- ],- "type": "BTREE",- "unique": true,- "visible": true- },- {- "name": "b_4",- "expressions": [- "b",- "d"- ],- "type": "FULLTEXT"- },- {- "name": "idx_a",- "expressions": [- "a"- ],- "type": "BTREE",- "visible": true- }- ]- }- ]- }- ]- }- err: null-- statement: DROP TABLE t1, t2- ignore_case_sensitive: false- want: |-- {- "schemas": [- {}- ]- }- err: null-- statement: INSERT INTO test values (1)- ignore_case_sensitive: false- want: |-- {- "schemas": [- {}- ]- }- err: nulldiff --git a/backend/plugin/advisor/catalog/test/pg_walk_through.yaml b/backend/plugin/advisor/catalog/test/pg_walk_through.yamlindex f619922b92..2c41122a3e 100644--- a/backend/plugin/advisor/catalog/test/pg_walk_through.yaml+++ b/backend/plugin/advisor/catalog/test/pg_walk_through.yaml@@ -12,7 +12,13 @@type\": \"int\"\n },\n {\n \"name\": \"name\"\,\n \"position\": 2,\n \"nullable\": true,\n \\ \"type\": \"varchar(20)\"\n }\n ]\n }\n \- \ ]\n }\n ]\n}"+ \ ],\n \"views\": [\n {\n \"name\": \"v1\",\n \+ \ \"definition\": \"SELECT id, name FROM test\",\n \"dependencyColumns\"\+ : [\n {\n \"schema\": \"public\",\n \"table\"\+ : \"test\",\n \"column\": \"id\"\n },\n {\n\+ \ \"schema\": \"public\",\n \"table\": \"test\",\n \+ \ \"column\": \"name\"\n }\n ]\n }\n \+ \ ]\n }\n ]\n}"err: null- statement: 'CREATE TABLE public.t(a int, "B" int);@@ -40,7 +46,13 @@\ \"type\": \"int\"\n },\n {\n \"name\":\\ \"name\",\n \"position\": 2,\n \"nullable\": true,\n\\ \"type\": \"varchar(20)\"\n }\n ]\n \- \ }\n ]\n }\n ]\n}"+ \ }\n ],\n \"views\": [\n {\n \"name\": \"v1\",\n \+ \ \"definition\": \"SELECT id, name FROM test\",\n \"dependencyColumns\"\+ : [\n {\n \"schema\": \"public\",\n \"table\"\+ : \"test\",\n \"column\": \"id\"\n },\n {\n\+ \ \"schema\": \"public\",\n \"table\": \"test\",\n \+ \ \"column\": \"name\"\n }\n ]\n }\n \+ \ ]\n }\n ]\n}"err: null- statement: "CREATE TABLE public.t(\n a int primary key,\n b int NOT NULL DEFAULT\\ 1,\n c int UNIQUE,\n UNIQUE (a, b, c),\n CONSTRAINT uk_a_b UNIQUE (a, b)\n\@@ -57,22 +69,30 @@\ }\n ],\n \"indexes\": [\n {\n \\ \"name\": \"t_a_b_c_idx\",\n \"expressions\": [\n \\ \"a\",\n \"b\",\n \"c\"\n \- \ ],\n \"type\": \"btree\",\n \"unique\": true\n \- \ },\n {\n \"name\": \"t_c_idx\",\n \- \ \"expressions\": [\n \"c\"\n ],\n \- \ \"type\": \"btree\",\n \"unique\": true\n },\n \- \ {\n \"name\": \"t_pkey\",\n \"expressions\"\+ \ ],\n \"type\": \"btree\",\n \"unique\": true,\n\+ \ \"isConstraint\": true\n },\n {\n \+ \ \"name\": \"t_c_idx\",\n \"expressions\": [\n \+ \ \"c\"\n ],\n \"type\": \"btree\",\n \+ \ \"unique\": true,\n \"isConstraint\": true\n },\n\+ \ {\n \"name\": \"t_pkey\",\n \"expressions\"\: [\n \"a\"\n ],\n \"type\": \"btree\"\- ,\n \"unique\": true,\n \"primary\": true\n \- \ },\n {\n \"name\": \"uk_a_b\",\n \"\- expressions\": [\n \"a\",\n \"b\"\n \- \ ],\n \"type\": \"btree\",\n \"unique\": true\n \- \ }\n ]\n },\n {\n \"name\": \"test\"\- ,\n \"columns\": [\n {\n \"name\": \"id\",\n\- \ \"position\": 1,\n \"type\": \"int\"\n \- \ },\n {\n \"name\": \"name\",\n \"position\"\+ ,\n \"unique\": true,\n \"primary\": true,\n \+ \ \"isConstraint\": true\n },\n {\n \"\+ name\": \"uk_a_b\",\n \"expressions\": [\n \"a\",\n\+ \ \"b\"\n ],\n \"type\": \"btree\",\n\+ \ \"unique\": true,\n \"isConstraint\": true\n \+ \ }\n ]\n },\n {\n \"name\": \"test\",\n\+ \ \"columns\": [\n {\n \"name\": \"id\",\n \+ \ \"position\": 1,\n \"type\": \"int\"\n },\n\+ \ {\n \"name\": \"name\",\n \"position\"\: 2,\n \"nullable\": true,\n \"type\": \"varchar(20)\"\- \n }\n ]\n }\n ]\n }\n ]\n}"+ \n }\n ]\n }\n ],\n \"views\": [\n \+ \ {\n \"name\": \"v1\",\n \"definition\": \"SELECT id, name\+ \ FROM test\",\n \"dependencyColumns\": [\n {\n \+ \ \"schema\": \"public\",\n \"table\": \"test\",\n \+ \ \"column\": \"id\"\n },\n {\n \"schema\"\+ : \"public\",\n \"table\": \"test\",\n \"column\": \"\+ name\"\n }\n ]\n }\n ]\n }\n ]\n}"err: null- statement: "CREATE TABLE public.t(\n a int primary key,\n b int NOT NULL DEFAULT\\ 1,\n c int UNIQUE,\n UNIQUE (a, b, c),\n CONSTRAINT uk_a_b UNIQUE (a, b)\n\@@ -95,19 +115,26 @@\ ],\n \"indexes\": [\n {\n \"name\": \"t_pkey\"\,\n \"expressions\": [\n \"a1\"\n ],\n\\ \"type\": \"btree\",\n \"unique\": true,\n \- \ \"primary\": true\n },\n {\n \"name\"\- : \"uk_d\",\n \"expressions\": [\n \"d\"\n \- \ ],\n \"type\": \"btree\",\n \"unique\": true\n\- \ },\n {\n \"name\": \"ukk_a_b\",\n \- \ \"expressions\": [\n \"a1\",\n \"b\"\n \- \ ],\n \"type\": \"btree\",\n \"unique\"\- : true\n }\n ]\n },\n {\n \"name\"\- : \"test\",\n \"columns\": [\n {\n \"name\":\- \ \"id\",\n \"position\": 1,\n \"type\": \"int\"\n \- \ },\n {\n \"name\": \"name\",\n \- \ \"position\": 2,\n \"nullable\": true,\n \"type\"\- : \"varchar(20)\"\n }\n ]\n }\n ]\n }\n ]\n\- }"+ \ \"primary\": true,\n \"isConstraint\": true\n \+ \ },\n {\n \"name\": \"uk_d\",\n \"expressions\"\+ : [\n \"d\"\n ],\n \"type\": \"btree\"\+ ,\n \"unique\": true,\n \"isConstraint\": true\n \+ \ },\n {\n \"name\": \"ukk_a_b\",\n \+ \ \"expressions\": [\n \"a1\",\n \"b\"\n \+ \ ],\n \"type\": \"btree\",\n \"unique\": true,\n\+ \ \"isConstraint\": true\n }\n ]\n },\n\+ \ {\n \"name\": \"test\",\n \"columns\": [\n \+ \ {\n \"name\": \"id\",\n \"position\": 1,\n \+ \ \"type\": \"int\"\n },\n {\n \"\+ name\": \"name\",\n \"position\": 2,\n \"nullable\"\+ : true,\n \"type\": \"varchar(20)\"\n }\n ]\n\+ \ }\n ],\n \"views\": [\n {\n \"name\": \"v1\"\+ ,\n \"definition\": \"SELECT id, name FROM test\",\n \"dependencyColumns\"\+ : [\n {\n \"schema\": \"public\",\n \"table\"\+ : \"test\",\n \"column\": \"id\"\n },\n {\n\+ \ \"schema\": \"public\",\n \"table\": \"test\",\n \+ \ \"column\": \"name\"\n }\n ]\n }\n \+ \ ]\n }\n ]\n}"err: null- statement: "CREATE TABLE public.t(\n a int primary key,\n b int NOT NULL DEFAULT\\ 1,\n c int UNIQUE,\n UNIQUE (a, b, c),\n CONSTRAINT uk_a_b UNIQUE (a, b)\n\@@ -124,22 +151,30 @@\ }\n ],\n \"indexes\": [\n {\n \\ \"name\": \"t_a_b_c_idx\",\n \"expressions\": [\n \\ \"a\",\n \"b\",\n \"c\"\n \- \ ],\n \"type\": \"btree\",\n \"unique\": true\n \- \ },\n {\n \"name\": \"t_c_idx\",\n \- \ \"expressions\": [\n \"c\"\n ],\n \- \ \"type\": \"btree\",\n \"unique\": true\n },\n \- \ {\n \"name\": \"t_pkey\",\n \"expressions\"\+ \ ],\n \"type\": \"btree\",\n \"unique\": true,\n\+ \ \"isConstraint\": true\n },\n {\n \+ \ \"name\": \"t_c_idx\",\n \"expressions\": [\n \+ \ \"c\"\n ],\n \"type\": \"btree\",\n \+ \ \"unique\": true,\n \"isConstraint\": true\n },\n\+ \ {\n \"name\": \"t_pkey\",\n \"expressions\"\: [\n \"a\"\n ],\n \"type\": \"btree\"\- ,\n \"unique\": true,\n \"primary\": true\n \- \ },\n {\n \"name\": \"ukk_a_b\",\n \"\- expressions\": [\n \"a\",\n \"b\"\n \- \ ],\n \"type\": \"btree\",\n \"unique\": true\n \- \ }\n ]\n },\n {\n \"name\": \"test\"\+ ,\n \"unique\": true,\n \"primary\": true,\n \+ \ \"isConstraint\": true\n },\n {\n \"\+ name\": \"ukk_a_b\",\n \"expressions\": [\n \"a\"\+ ,\n \"b\"\n ],\n \"type\": \"btree\"\+ ,\n \"unique\": true,\n \"isConstraint\": true\n \+ \ }\n ]\n },\n {\n \"name\": \"test\"\,\n \"columns\": [\n {\n \"name\": \"id\",\n\\ \"position\": 1,\n \"type\": \"int\"\n \\ },\n {\n \"name\": \"name\",\n \"position\"\: 2,\n \"nullable\": true,\n \"type\": \"varchar(20)\"\- \n }\n ]\n }\n ]\n }\n ]\n}"+ \n }\n ]\n }\n ],\n \"views\": [\n \+ \ {\n \"name\": \"v1\",\n \"definition\": \"SELECT id, name\+ \ FROM test\",\n \"dependencyColumns\": [\n {\n \+ \ \"schema\": \"public\",\n \"table\": \"test\",\n \+ \ \"column\": \"id\"\n },\n {\n \"schema\"\+ : \"public\",\n \"table\": \"test\",\n \"column\": \"\+ name\"\n }\n ]\n }\n ]\n }\n ]\n}"err: null- statement: "CREATE TABLE public.t(\n a int primary key,\n b int NOT NULL DEFAULT\\ 1,\n c int UNIQUE,\n UNIQUE (a, b, c),\n CONSTRAINT uk_a_b UNIQUE (a, b)\n\@@ -156,19 +191,27 @@\ }\n ],\n \"indexes\": [\n {\n \\ \"name\": \"t_a_b_c_idx\",\n \"expressions\": [\n \\ \"a\",\n \"b\",\n \"c\"\n \- \ ],\n \"type\": \"btree\",\n \"unique\": true\n \- \ },\n {\n \"name\": \"t_c_idx\",\n \- \ \"expressions\": [\n \"c\"\n ],\n \- \ \"type\": \"btree\",\n \"unique\": true\n },\n \- \ {\n \"name\": \"t_pkey\",\n \"expressions\"\+ \ ],\n \"type\": \"btree\",\n \"unique\": true,\n\+ \ \"isConstraint\": true\n },\n {\n \+ \ \"name\": \"t_c_idx\",\n \"expressions\": [\n \+ \ \"c\"\n ],\n \"type\": \"btree\",\n \+ \ \"unique\": true,\n \"isConstraint\": true\n },\n\+ \ {\n \"name\": \"t_pkey\",\n \"expressions\"\: [\n \"a\"\n ],\n \"type\": \"btree\"\- ,\n \"unique\": true,\n \"primary\": true\n \- \ }\n ]\n },\n {\n \"name\": \"test\",\n \- \ \"columns\": [\n {\n \"name\": \"id\",\n \- \ \"position\": 1,\n \"type\": \"int\"\n },\n\- \ {\n \"name\": \"name\",\n \"position\"\- : 2,\n \"nullable\": true,\n \"type\": \"varchar(20)\"\- \n }\n ]\n }\n ]\n }\n ]\n}"+ ,\n \"unique\": true,\n \"primary\": true,\n \+ \ \"isConstraint\": true\n }\n ]\n },\n \+ \ {\n \"name\": \"test\",\n \"columns\": [\n {\n\+ \ \"name\": \"id\",\n \"position\": 1,\n \+ \ \"type\": \"int\"\n },\n {\n \"name\":\+ \ \"name\",\n \"position\": 2,\n \"nullable\": true,\n\+ \ \"type\": \"varchar(20)\"\n }\n ]\n \+ \ }\n ],\n \"views\": [\n {\n \"name\": \"v1\",\n \+ \ \"definition\": \"SELECT id, name FROM test\",\n \"dependencyColumns\"\+ : [\n {\n \"schema\": \"public\",\n \"table\"\+ : \"test\",\n \"column\": \"id\"\n },\n {\n\+ \ \"schema\": \"public\",\n \"table\": \"test\",\n \+ \ \"column\": \"name\"\n }\n ]\n }\n \+ \ ]\n }\n ]\n}"err: null- statement: "CREATE TABLE public.t(\n a int primary key,\n b int NOT NULL DEFAULT\\ 1,\n c int UNIQUE,\n UNIQUE (a, b, c),\n CONSTRAINT uk_a_b UNIQUE (a, b)\n\@@ -180,7 +223,13 @@\ \"position\": 1,\n \"type\": \"int\"\n },\n\\ {\n \"name\": \"name\",\n \"position\"\: 2,\n \"nullable\": true,\n \"type\": \"varchar(20)\"\- \n }\n ]\n }\n ]\n }\n ]\n}"+ \n }\n ]\n }\n ],\n \"views\": [\n \+ \ {\n \"name\": \"v1\",\n \"definition\": \"SELECT id, name\+ \ FROM test\",\n \"dependencyColumns\": [\n {\n \+ \ \"schema\": \"public\",\n \"table\": \"test\",\n \+ \ \"column\": \"id\"\n },\n {\n \"schema\"\+ : \"public\",\n \"table\": \"test\",\n \"column\": \"\+ name\"\n }\n ]\n }\n ]\n }\n ]\n}"err: null- statement: "CREATE TABLE public.t(\n a int primary key,\n b int NOT NULL DEFAULT\\ 1,\n c int UNIQUE,\n UNIQUE (a, b, c),\n CONSTRAINT uk_a_b UNIQUE (a, b)\n\diff --git a/backend/plugin/advisor/catalog/walk_through.go b/backend/plugin/advisor/catalog/walk_through.goindex ade3687870..b9e696e201 100644--- a/backend/plugin/advisor/catalog/walk_through.go+++ b/backend/plugin/advisor/catalog/walk_through.go@@ -2,13 +2,13 @@ package catalogimport ("fmt"- "regexp""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 (@@ -92,9 +92,9 @@ func (e *WalkThroughError) Error() string {return e.Content}-// WalkThrough will collect the catalog schema in the database state as it walks through the stmt.-func WalkThrough(d *DatabaseState, ast any) error {- switch d.dbType {+// 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:@@ -102,7 +102,7 @@ func WalkThrough(d *DatabaseState, ast any) error {case storepb.Engine_POSTGRES:return PgWalkThrough(d, ast)default:- return errors.Errorf("Walk-through doesn't support engine type: %s", d.dbType)+ return errors.Errorf("Walk-through doesn't support engine type: %s", engineType)}}@@ -114,126 +114,7 @@ func compareIdentifier(a, b string, ignoreCaseSensitive bool) bool {return a == b}-// isCurrentDatabase returns true if the given database is the current database of the state.-func (d *DatabaseState) isCurrentDatabase(database string) bool {- return compareIdentifier(d.name, database, d.ignoreCaseSensitive)-}--// mysqlGetTable returns the table with the given name if it exists in the schema.-// It performs case-insensitive comparison for MySQL/TiDB.-func mysqlGetTable(s *SchemaState, table string) (*TableState, bool) {- for k, v := range s.tableSet {- if compareIdentifier(k, table, s.ignoreCaseSensitive) {- return v, true- }- }-- return nil, false-}--func mysqlRenameTable(s *SchemaState, oldName string, newName string) *WalkThroughError {- if oldName == newName {- return nil- }-- table, exists := mysqlGetTable(s, oldName)- if !exists {- return &WalkThroughError{- Code: code.TableNotExists,- Content: fmt.Sprintf("Table `%s` does not exist", oldName),- }- }-- if _, exists := mysqlGetTable(s, newName); exists {- return &WalkThroughError{- Code: code.TableExists,- Content: fmt.Sprintf("Table `%s` already exists", newName),- }- }-- table.name = newName- delete(s.tableSet, oldName)- s.tableSet[newName] = table- return nil-}--// PostgreSQL-specific helper methods.--func parseViewName(viewName string) (string, string, error) {- pattern := `^"(.+?)"\."(.+?)"$`-- re := regexp.MustCompile(pattern)-- match := re.FindStringSubmatch(viewName)-- if len(match) != 3 {- return "", "", errors.Errorf("invalid view name: %s", viewName)- }-- return match[1], match[2], nil-}--func (d *DatabaseState) existedViewList(viewMap map[string]bool) ([]string, error) {- var result []string- for viewName := range viewMap {- schemaName, viewName, err := parseViewName(viewName)- if err != nil {- return nil, errors.Wrapf(err, "failed to check view dependency")- }- schemaMeta, exists := d.schemaSet[schemaName]- if !exists {- continue- }- if _, exists := schemaMeta.viewSet[viewName]; !exists {- continue- }-- result = append(result, fmt.Sprintf("%q.%q", schemaName, viewName))- }- return result, nil-}--func (s *SchemaState) pgGeneratePrimaryKeyName(tableName string) string {- pkName := fmt.Sprintf("%s_pkey", tableName)- if _, exists := s.identifierMap[pkName]; !exists {- return pkName- }- suffix := 1- for {- if _, exists := s.identifierMap[fmt.Sprintf("%s%d", pkName, suffix)]; !exists {- return fmt.Sprintf("%s%d", pkName, suffix)- }- suffix++- }-}--func (d *DatabaseState) getOrCreatePublicSchema(schemaName string) (*SchemaState, *WalkThroughError) {- if schemaName == "" {- schemaName = publicSchemaName- }-- schema, err := d.GetSchema(schemaName)- if err == nil {- return schema, nil- }-- // Only auto-create the "public" schema- if schemaName != publicSchemaName {- return nil, err- }-- return d.CreateSchema(publicSchemaName), nil-}--func (s *SchemaState) getIndex(indexName string) (*TableState, *IndexState, *WalkThroughError) {- for _, table := range s.tableSet {- if index, exists := table.indexSet[indexName]; exists {- return table, index, nil- }- }-- return nil, nil, &WalkThroughError{- Code: code.IndexNotExists,- Content: fmt.Sprintf("Index %q does not exists in schema %q", indexName, s.name),- }+// 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/walk_through_for_mysql.go b/backend/plugin/advisor/catalog/walk_through_for_mysql.goindex 336427ab54..eff1866c23 100644--- a/backend/plugin/advisor/catalog/walk_through_for_mysql.go+++ b/backend/plugin/advisor/catalog/walk_through_for_mysql.go@@ -8,18 +8,21 @@ import ("github.com/bytebase/parser/mysql"tidbast "github.com/pingcap/tidb/pkg/parser/ast""github.com/pkg/errors"+ "google.golang.org/protobuf/proto"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store""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/store/model")-// MySQLWalkThrough walks through MySQL AST and updates the database state.-func MySQLWalkThrough(d *DatabaseState, ast any) error {+// MySQLWalkThrough walks through MySQL AST and updates the database metadata.+func MySQLWalkThrough(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.- if !d.HasSchema("") {+ if d.GetSchema("") == nil {d.CreateSchema("")}@@ -28,7 +31,7 @@ func MySQLWalkThrough(d *DatabaseState, ast any) error {return errors.Errorf("invalid ast type %T", ast)}for _, node := range nodeList {- if err := d.mysqlChangeState(node); err != nil {+ if err := mysqlChangeState(d, node); err != nil {return err}}@@ -39,11 +42,11 @@ func MySQLWalkThrough(d *DatabaseState, ast any) error {type mysqlListener struct {*mysql.BaseMySQLParserListener- baseLine int- lineNumber int- text string- databaseState *DatabaseState- err *WalkThroughError+ baseLine int+ lineNumber int+ text string+ databaseMetadata *model.DatabaseMetadata+ err *WalkThroughError}func (l *mysqlListener) EnterQuery(ctx *mysql.QueryContext) {@@ -51,7 +54,7 @@ func (l *mysqlListener) EnterQuery(ctx *mysql.QueryContext) {l.lineNumber = l.baseLine + ctx.GetStart().GetLine()}-func (d *DatabaseState) mysqlChangeState(in *mysqlparser.ParseResult) (err *WalkThroughError) {+func mysqlChangeState(d *model.DatabaseMetadata, in *mysqlparser.ParseResult) (err *WalkThroughError) {defer func() {if err == nil {return@@ -61,16 +64,9 @@ func (d *DatabaseState) mysqlChangeState(in *mysqlparser.ParseResult) (err *Walk}}()- if d.IsDeleted() {- return &WalkThroughError{- Code: code.DatabaseIsDeleted,- Content: fmt.Sprintf("Database `%s` is deleted", d.name),- }- }-listener := &mysqlListener{- baseLine: in.BaseLine,- databaseState: d,+ baseLine: in.BaseLine,+ databaseMetadata: d,}antlr.ParseTreeWalkerDefault.Walk(listener, in.Tree)if listener.err != nil {@@ -91,20 +87,23 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {return}databaseName, tableName := mysqlparser.NormalizeMySQLTableName(ctx.TableName())- if databaseName != "" && !l.databaseState.isCurrentDatabase(databaseName) {+ if databaseName != "" && !isCurrentDatabase(l.databaseMetadata, databaseName) {l.err = &WalkThroughError{Code: code.NotCurrentDatabase,- Content: fmt.Sprintf("Database `%s` is not the current database `%s`", databaseName, l.databaseState.name),+ Content: fmt.Sprintf("Database `%s` is not the current database `%s`", databaseName, l.databaseMetadata.DatabaseName()),}return}- schema, err := l.databaseState.GetSchema("")- if err != nil {- l.err = err+ schema := l.databaseMetadata.GetSchema("")+ if schema == nil {+ l.err = &WalkThroughError{+ Code: code.SchemaNotExists,+ Content: "Schema does not exist",+ }return}- if _, exists := mysqlGetTable(schema, tableName); exists {+ if schema.GetTable(tableName) != nil {if ctx.IfNotExists() != nil {return}@@ -125,13 +124,13 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {if ctx.LIKE_SYMBOL() != nil {_, referTable := mysqlparser.NormalizeMySQLTableRef(ctx.TableRef())- l.err = l.databaseState.mysqlCopyTable(databaseName, tableName, referTable)+ l.err = mysqlCopyTable(l.databaseMetadata, databaseName, tableName, referTable)return}table, err := schema.CreateTable(tableName)if err != nil {- l.err = err+ l.err = &WalkThroughError{Code: code.TableExists, Content: err.Error()}return}@@ -152,19 +151,19 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {l.err = &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.name),+ Content: fmt.Sprintf("There can be only one auto column for table `%s`", table.GetProto().Name),}}hasAutoIncrement = true}_, _, columnName := mysqlparser.NormalizeMySQLColumnName(tableElement.ColumnDefinition().ColumnName())- if err := table.mysqlCreateColumn(columnName, tableElement.ColumnDefinition().FieldDefinition(), nil /* position */); err != nil {+ if err := mysqlCreateColumn(table, columnName, tableElement.ColumnDefinition().FieldDefinition(), nil /* position */); err != nil {err.Line = l.baseLine + tableElement.GetStart().GetLine()l.err = errreturn}case tableElement.TableConstraintDef() != nil:- if err := table.mysqlCreateConstraint(tableElement.TableConstraintDef()); err != nil {+ if err := mysqlCreateConstraint(table, tableElement.TableConstraintDef()); err != nil {err.Line = tableElement.GetStart().GetLine()l.err = errreturn@@ -186,21 +185,24 @@ func (l *mysqlListener) EnterDropTable(ctx *mysql.DropTableContext) {for _, tableRef := range ctx.TableRefList().AllTableRef() {databaseName, tableName := mysqlparser.NormalizeMySQLTableRef(tableRef)- if databaseName != "" && !l.databaseState.isCurrentDatabase(databaseName) {+ if databaseName != "" && !isCurrentDatabase(l.databaseMetadata, databaseName) {l.err = &WalkThroughError{Code: code.NotCurrentDatabase,Content: fmt.Sprintf("Database `%s` is not the current database `%s`", databaseName, tableName),}}- schema, err := l.databaseState.GetSchema("")- if err != nil {- l.err = err+ schema := l.databaseMetadata.GetSchema("")+ if schema == nil {+ l.err = &WalkThroughError{+ Code: code.SchemaNotExists,+ Content: "Schema does not exist",+ }return}- table, exists := mysqlGetTable(schema, tableName)- if !exists {+ table := schema.GetTable(tableName)+ if table == nil {if ctx.IfExists() != nil {return}@@ -211,9 +213,9 @@ func (l *mysqlListener) EnterDropTable(ctx *mysql.DropTableContext) {return}- // MySQL doesn't check view dependencies for DROP TABLE, so pass nil- if err := schema.DropTable(table.name, nil); err != nil {- l.err = err+ // 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()}return}}@@ -230,7 +232,7 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {}databaseName, tableName := mysqlparser.NormalizeMySQLTableRef(ctx.TableRef())- table, err := l.databaseState.mysqlFindTableState(databaseName, tableName)+ table, err := mysqlFindTableState(l.databaseMetadata, databaseName, tableName)if err != nil {l.err = errreturn@@ -255,15 +257,15 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {continue}engine := op.EngineRef().GetText()- table.SetEngine(engine)+ table.GetProto().Engine = engine// table comment.case op.COMMENT_SYMBOL() != nil && op.TextStringLiteral() != nil:comment := mysqlparser.NormalizeMySQLTextStringLiteral(op.TextStringLiteral())- table.SetComment(comment)+ table.GetProto().Comment = comment// table collation.case op.DefaultCollation() != nil && op.DefaultCollation().CollationName() != nil:collation := mysqlparser.NormalizeMySQLCollationName(op.DefaultCollation().CollationName())- table.SetCollation(collation)+ table.GetProto().Collation = collationdefault:}}@@ -281,7 +283,7 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {// add single column.case item.Identifier() != nil && item.FieldDefinition() != nil:columnName := mysqlparser.NormalizeMySQLIdentifier(item.Identifier())- if err := table.mysqlCreateColumn(columnName, item.FieldDefinition(), positionFromPlaceContext(item.Place())); err != nil {+ if err := mysqlCreateColumn(table, columnName, item.FieldDefinition(), positionFromPlaceContext(item.Place())); err != nil {l.err = errreturn}@@ -292,14 +294,14 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {continue}_, _, columnName := mysqlparser.NormalizeMySQLColumnName(tableElement.ColumnDefinition().ColumnName())- if err := table.mysqlCreateColumn(columnName, tableElement.ColumnDefinition().FieldDefinition(), nil); err != nil {+ if err := mysqlCreateColumn(table, columnName, tableElement.ColumnDefinition().FieldDefinition(), nil); err != nil {l.err = errreturn}}// add constraint.case item.TableConstraintDef() != nil:- if err := table.mysqlCreateConstraint(item.TableConstraintDef()); err != nil {+ if err := mysqlCreateConstraint(table, item.TableConstraintDef()); err != nil {l.err = errreturn}@@ -315,21 +317,26 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {// drop column.case item.ColumnInternalRef() != nil:columnName := mysqlparser.NormalizeMySQLColumnInternalRef(item.ColumnInternalRef())- if err := table.DropColumn(columnName, nil); err != nil {- l.err = err+ // Validate column exists+ if table.GetColumn(columnName) == nil {+ l.err = 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)}return}// drop primary key.case item.PRIMARY_SYMBOL() != nil && item.KEY_SYMBOL() != nil:- if err := table.DropIndex(PrimaryKeyName, nil); err != nil {- l.err = err+ if err := table.DropIndex(PrimaryKeyName); err != nil {+ l.err = &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, nil); err != nil {- l.err = err+ if err := table.DropIndex(indexName); err != nil {+ l.err = &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}return}default:@@ -338,7 +345,7 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {// modify column.case item.MODIFY_SYMBOL() != nil && item.ColumnInternalRef() != nil:columnName := mysqlparser.NormalizeMySQLColumnInternalRef(item.ColumnInternalRef())- if err := table.mysqlChangeColumn(columnName, columnName, item.FieldDefinition(), positionFromPlaceContext(item.Place())); err != nil {+ if err := mysqlChangeColumn(table, columnName, columnName, item.FieldDefinition(), positionFromPlaceContext(item.Place())); err != nil {l.err = errreturn}@@ -346,7 +353,7 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {case item.CHANGE_SYMBOL() != nil && item.ColumnInternalRef() != nil && item.Identifier() != nil:oldColumnName := mysqlparser.NormalizeMySQLColumnInternalRef(item.ColumnInternalRef())newColumnName := mysqlparser.NormalizeMySQLIdentifier(item.Identifier())- if err := table.mysqlChangeColumn(oldColumnName, newColumnName, item.FieldDefinition(), positionFromPlaceContext(item.Place())); err != nil {+ if err := mysqlChangeColumn(table, oldColumnName, newColumnName, item.FieldDefinition(), positionFromPlaceContext(item.Place())); err != nil {l.err = errreturn}@@ -354,22 +361,35 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {case item.RENAME_SYMBOL() != nil && item.COLUMN_SYMBOL() != nil:oldColumnName := mysqlparser.NormalizeMySQLColumnInternalRef(item.ColumnInternalRef())newColumnName := mysqlparser.NormalizeMySQLIdentifier(item.Identifier())+ // Validate old column exists+ if table.GetColumn(oldColumnName) == nil {+ l.err = NewColumnNotExistsError(table.GetProto().Name, oldColumnName)+ return+ }+ // Validate new column doesn't already exist+ if table.GetColumn(newColumnName) != nil {+ l.err = &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 = err+ l.err = &WalkThroughError{Code: code.Internal, Content: fmt.Sprintf("failed to rename column: %v", err)}return}case item.ALTER_SYMBOL() != nil:switch {// alter column.case item.ColumnInternalRef() != nil:- if err := table.mysqlAlterColumn(item); err != nil {+ if err := mysqlAlterColumn(table, item); err != nil {l.err = errreturn}// alter index visibility.case item.INDEX_SYMBOL() != nil && item.IndexRef() != nil && item.Visibility() != nil:_, _, indexName := mysqlparser.NormalizeIndexRef(item.IndexRef())- if err := table.mysqlChangeIndexVisibility(indexName, item.Visibility()); err != nil {+ if err := mysqlChangeIndexVisibility(table, indexName, item.Visibility()); err != nil {l.err = errreturn}@@ -378,21 +398,24 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {// rename table.case item.RENAME_SYMBOL() != nil && item.TableName() != nil:_, newTableName := mysqlparser.NormalizeMySQLTableName(item.TableName())- schema, err := l.databaseState.GetSchema("")- if err != nil {- l.err = err+ schema := l.databaseMetadata.GetSchema("")+ if schema == nil {+ l.err = &WalkThroughError{+ Code: code.SchemaNotExists,+ Content: "Schema does not exist",+ }return}- if err := schema.RenameTable(table.name, newTableName); err != nil {- l.err = err+ if err := schema.RenameTable(table.GetProto().Name, newTableName); err != nil {+ l.err = &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}return}// rename index.case item.RENAME_SYMBOL() != nil && item.KeyOrIndex() != nil && item.IndexRef() != nil && item.IndexName() != nil:_, _, oldIndexName := mysqlparser.NormalizeIndexRef(item.IndexRef())newIndexName := mysqlparser.NormalizeIndexName(item.IndexName())- if err := table.RenameIndex(oldIndexName, newIndexName, nil); err != nil {- l.err = err+ if err := table.RenameIndex(oldIndexName, newIndexName); err != nil {+ l.err = &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}return}default:@@ -410,7 +433,7 @@ func (l *mysqlListener) EnterDropIndex(ctx *mysql.DropIndexContext) {return}databaseName, tableName := mysqlparser.NormalizeMySQLTableRef(ctx.TableRef())- table, err := l.databaseState.mysqlFindTableState(databaseName, tableName)+ table, err := mysqlFindTableState(l.databaseMetadata, databaseName, tableName)if err != nil {l.err = errreturn@@ -421,8 +444,8 @@ func (l *mysqlListener) EnterDropIndex(ctx *mysql.DropIndexContext) {}_, _, indexName := mysqlparser.NormalizeIndexRef(ctx.IndexRef())- if err := table.DropIndex(indexName, nil); err != nil {- l.err = err+ if err := table.DropIndex(indexName); err != nil {+ l.err = &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}}@@ -434,7 +457,7 @@ func (l *mysqlListener) EnterCreateIndex(ctx *mysql.CreateIndexContext) {return}databaseName, tableName := mysqlparser.NormalizeMySQLTableRef(ctx.CreateIndexTarget().TableRef())- table, err := l.databaseState.mysqlFindTableState(databaseName, tableName)+ table, err := mysqlFindTableState(l.databaseMetadata, databaseName, tableName)if err != nil {l.err = errreturn@@ -472,13 +495,13 @@ func (l *mysqlListener) EnterCreateIndex(ctx *mysql.CreateIndexContext) {if ctx.CreateIndexTarget() == nil || ctx.CreateIndexTarget().KeyListVariants() == nil {return}- if err := table.mysqlValidateKeyListVariants(ctx.CreateIndexTarget().KeyListVariants(), false /* primary */, isSpatial); err != nil {+ if err := mysqlValidateKeyListVariants(table, ctx.CreateIndexTarget().KeyListVariants(), false /* primary */, isSpatial); err != nil {l.err = errreturn}columnList := mysqlparser.NormalizeKeyListVariants(ctx.CreateIndexTarget().KeyListVariants())- if err := table.mysqlCreateIndex(indexName, columnList, unique, tp, mysql.NewEmptyTableConstraintDefContext(), ctx); err != nil {+ if err := mysqlCreateIndex(table, indexName, columnList, unique, tp, mysql.NewEmptyTableConstraintDefContext(), ctx); err != nil {l.err = errreturn}@@ -491,8 +514,8 @@ func (l *mysqlListener) EnterAlterDatabase(ctx *mysql.AlterDatabaseContext) {}if ctx.SchemaRef() != nil {databaseName := mysqlparser.NormalizeMySQLSchemaRef(ctx.SchemaRef())- if !l.databaseState.isCurrentDatabase(databaseName) {- l.err = NewAccessOtherDatabaseError(l.databaseState.name, databaseName)+ if !isCurrentDatabase(l.databaseMetadata, databaseName) {+ l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)return}}@@ -505,10 +528,10 @@ func (l *mysqlListener) EnterAlterDatabase(ctx *mysql.AlterDatabaseContext) {switch {case option.CreateDatabaseOption().DefaultCharset() != nil && option.CreateDatabaseOption().DefaultCharset().CharsetName() != nil:charset := mysqlparser.NormalizeMySQLCharsetName(option.CreateDatabaseOption().DefaultCharset().CharsetName())- l.databaseState.SetCharacterSet(charset)+ l.databaseMetadata.GetProto().CharacterSet = charsetcase option.CreateDatabaseOption().DefaultCollation() != nil && option.CreateDatabaseOption().DefaultCollation().CollationName() != nil:collation := mysqlparser.NormalizeMySQLCollationName(option.CreateDatabaseOption().DefaultCollation().CollationName())- l.databaseState.SetCollation(collation)+ l.databaseMetadata.GetProto().Collation = collationdefault:// Other options}@@ -525,12 +548,12 @@ func (l *mysqlListener) EnterDropDatabase(ctx *mysql.DropDatabaseContext) {}databaseName := mysqlparser.NormalizeMySQLSchemaRef(ctx.SchemaRef())- if !l.databaseState.isCurrentDatabase(databaseName) {- l.err = NewAccessOtherDatabaseError(l.databaseState.name, databaseName)+ if !isCurrentDatabase(l.databaseMetadata, databaseName) {+ l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)return}- l.databaseState.MarkDeleted()+ // DROP DATABASE not supported - would mark database as deleted}// EnterCreateDatabase is called when production createDatabase is entered.@@ -542,7 +565,7 @@ func (l *mysqlListener) EnterCreateDatabase(ctx *mysql.CreateDatabaseContext) {return}databaseName := mysqlparser.NormalizeMySQLSchemaName(ctx.SchemaName())- l.err = NewAccessOtherDatabaseError(l.databaseState.name, databaseName)+ l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), databaseName)}// EnterRenameTableStatement is called when production renameTableStatement is entered.@@ -551,40 +574,45 @@ func (l *mysqlListener) EnterRenameTableStatement(ctx *mysql.RenameTableStatemenreturn}for _, pair := range ctx.AllRenamePair() {- schema, err := l.databaseState.GetSchema("")- if err != nil {- l.err = err+ schema := l.databaseMetadata.GetSchema("")+ if schema == nil {+ l.err = &WalkThroughError{+ Code: code.SchemaNotExists,+ Content: "Schema does not exist",+ }return}_, oldTableName := mysqlparser.NormalizeMySQLTableRef(pair.TableRef())_, newTableName := mysqlparser.NormalizeMySQLTableName(pair.TableName())- if l.databaseState.mysqlTheCurrentDatabase(pair) {- if compareIdentifier(oldTableName, newTableName, l.databaseState.ignoreCaseSensitive) {+ if mysqlTheCurrentDatabase(l.databaseMetadata, pair) {+ if compareIdentifier(oldTableName, newTableName, !l.databaseMetadata.GetIsObjectCaseSensitive()) {return}- table, exists := mysqlGetTable(schema, oldTableName)- if !exists {+ if schema.GetTable(oldTableName) == nil {l.err = NewTableNotExistsError(oldTableName)return}- if _, exists := mysqlGetTable(schema, newTableName); exists {+ if schema.GetTable(newTableName) != nil {l.err = NewTableExistsError(newTableName)return}- delete(schema.tableSet, table.name)- table.name = newTableName- schema.tableSet[table.name] = table- } else if l.databaseState.mysqlMoveToOtherDatabase(pair) {- _, exists := mysqlGetTable(schema, oldTableName)- if !exists {+ if err := schema.RenameTable(oldTableName, newTableName); err != nil {+ l.err = &WalkThroughError{Code: code.Internal, Content: err.Error()}+ return+ }+ } else if mysqlMoveToOtherDatabase(l.databaseMetadata, pair) {+ if schema.GetTable(oldTableName) == nil {l.err = NewTableNotExistsError(oldTableName)return}- delete(schema.tableSet, oldTableName)+ if err := schema.DropTable(oldTableName); err != nil {+ l.err = &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ return+ }} else {- l.err = NewAccessOtherDatabaseError(l.databaseState.name, l.databaseState.mysqlTargetDatabase(pair))+ l.err = NewAccessOtherDatabaseError(l.databaseMetadata.DatabaseName(), mysqlTargetDatabase(l.databaseMetadata, pair))return}}@@ -603,7 +631,7 @@ func (l *mysqlListener) EnterCreateTrigger(ctx *mysql.CreateTriggerContext) {return}databaseName, tableName := mysqlparser.NormalizeMySQLTableRef(ctx.TableRef())- _, err := l.databaseState.mysqlFindTableState(databaseName, tableName)+ _, err := mysqlFindTableState(l.databaseMetadata, databaseName, tableName)if err != nil {l.err = errreturn@@ -630,61 +658,62 @@ func (*mysqlListener) EnterCreateEvent(ctx *mysql.CreateEventContext) {// Skip other checks for now.}-func (d *DatabaseState) mysqlTargetDatabase(renamePair mysql.IRenamePairContext) string {+func mysqlTargetDatabase(d *model.DatabaseMetadata, renamePair mysql.IRenamePairContext) string {oldDatabaseName, _ := mysqlparser.NormalizeMySQLTableRef(renamePair.TableRef())- if oldDatabaseName != "" && !d.isCurrentDatabase(oldDatabaseName) {+ if oldDatabaseName != "" && !isCurrentDatabase(d, oldDatabaseName) {return oldDatabaseName}newDatabaseName, _ := mysqlparser.NormalizeMySQLTableName(renamePair.TableName())return newDatabaseName}-func (d *DatabaseState) mysqlMoveToOtherDatabase(renamePair mysql.IRenamePairContext) bool {+func mysqlMoveToOtherDatabase(d *model.DatabaseMetadata, renamePair mysql.IRenamePairContext) bool {oldDatabaseName, _ := mysqlparser.NormalizeMySQLTableRef(renamePair.TableRef())- if oldDatabaseName != "" && !d.isCurrentDatabase(oldDatabaseName) {+ if oldDatabaseName != "" && !isCurrentDatabase(d, oldDatabaseName) {return false}newDatabaseName, _ := mysqlparser.NormalizeMySQLTableName(renamePair.TableName())return oldDatabaseName != newDatabaseName}-func (d *DatabaseState) mysqlTheCurrentDatabase(renamePair mysql.IRenamePairContext) bool {+func mysqlTheCurrentDatabase(d *model.DatabaseMetadata, renamePair mysql.IRenamePairContext) bool {newDatabaseName, _ := mysqlparser.NormalizeMySQLTableName(renamePair.TableName())- if newDatabaseName != "" && !d.isCurrentDatabase(newDatabaseName) {+ if newDatabaseName != "" && !isCurrentDatabase(d, newDatabaseName) {return false}oldDatabaseName, _ := mysqlparser.NormalizeMySQLTableRef(renamePair.TableRef())- if oldDatabaseName != "" && !d.isCurrentDatabase(oldDatabaseName) {+ if oldDatabaseName != "" && !isCurrentDatabase(d, oldDatabaseName) {return false}return true}-func (t *TableState) mysqlChangeIndexVisibility(indexName string, visibility mysql.IVisibilityContext) *WalkThroughError {- index, exists := t.indexSet[strings.ToLower(indexName)]- if !exists {- return NewIndexNotExistsError(t.name, indexName)+func mysqlChangeIndexVisibility(table *model.TableMetadata, indexName string, visibility mysql.IVisibilityContext) *WalkThroughError {+ index := table.GetIndex(indexName)+ if index == nil {+ return NewIndexNotExistsError(table.GetProto().Name, indexName)}+ indexProto := index.GetProto()switch {case visibility.VISIBLE_SYMBOL() != nil:- index.visible = true+ indexProto.Visible = truecase visibility.INVISIBLE_SYMBOL() != nil:- index.visible = false+ indexProto.Visible = falsedefault:// No visibility specified}return nil}-func (t *TableState) mysqlAlterColumn(itemDef mysql.IAlterListItemContext) *WalkThroughError {+func mysqlAlterColumn(table *model.TableMetadata, itemDef mysql.IAlterListItemContext) *WalkThroughError {if itemDef.ColumnInternalRef() == nil {// should not reach here.return nil}columnName := mysqlparser.NormalizeMySQLColumnInternalRef(itemDef.ColumnInternalRef())- colState, exists := t.columnSet[strings.ToLower(columnName)]- if !exists {- return NewColumnNotExistsError(t.name, columnName)+ col := table.GetColumn(columnName)+ if col == nil {+ return NewColumnNotExistsError(table.GetProto().Name, columnName)}switch {@@ -693,8 +722,8 @@ func (t *TableState) mysqlAlterColumn(itemDef mysql.IAlterListItemContext) *Walk// SET DEFAULT.case itemDef.DEFAULT_SYMBOL() != nil:if itemDef.SignedLiteral() != nil && itemDef.SignedLiteral().Literal() != nil && itemDef.SignedLiteral().Literal().NullLiteral() == nil {- if colState.columnType != "" {- switch strings.ToLower(colState.columnType) {+ if col.Type != "" {+ switch strings.ToLower(col.Type) {case "blob", "tinyblob", "mediumblob", "longblob","text", "tinytext", "mediumtext", "longtext","json",@@ -719,9 +748,9 @@ func (t *TableState) mysqlAlterColumn(itemDef mysql.IAlterListItemContext) *Walk// No default value expression}- colState.defaultValue = defaultValue+ col.Default = defaultValue} else {- if !colState.nullable {+ if !col.Nullable {return &WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.@@ -729,69 +758,125 @@ func (t *TableState) mysqlAlterColumn(itemDef mysql.IAlterListItemContext) *Walk}}- colState.defaultValue = ""+ col.Default = ""}// SET VISIBLE/INVISIBLE.default:}case itemDef.DROP_SYMBOL() != nil && itemDef.DEFAULT_SYMBOL() != nil:// DROP DEFAULT.- colState.defaultValue = ""+ col.Default = ""default:// Other ALTER operations}return nil}-func (t *TableState) mysqlChangeColumn(oldColumnName string, newColumnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *WalkThroughError {- return t.mysqlCompleteTableChangeColumn(oldColumnName, newColumnName, fieldDef, position)-}--// mysqlCompleteTableChangeColumn changes column definition.+// mysqlChangeColumn changes column definition.// It works as:-// 1. drop column from tableState.columnSet, but do not drop column from indexSet.-// 2. rename column from indexSet.-// 3. create a new column in columnSet.-func (t *TableState) mysqlCompleteTableChangeColumn(oldColumnName string, newColumnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *WalkThroughError {- column, exists := t.columnSet[strings.ToLower(oldColumnName)]- if !exists {- return NewColumnNotExistsError(t.name, oldColumnName)+// 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 {+ column := table.GetColumn(oldColumnName)+ if column == nil {+ return 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{+ 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)}+ }+ // Get the renamed column+ column = table.GetColumn(newColumnName)}- pos := column.position+ // Update column properties from fieldDef+ if fieldDef.DataType() != nil {+ column.Type = mysqlparser.NormalizeMySQLDataType(fieldDef.DataType(), true /* compact */)+ column.CharacterSet = mysqlparser.GetCharSetName(fieldDef.DataType())+ column.Collation = mysqlparser.GetCollationName(fieldDef)+ }- if position == nil {- position = &mysqlColumnPosition{- tp: ColumnPositionNone,+ // Reset nullable to true, then check for NOT NULL constraint+ // This ensures that if the new definition doesn't have NOT NULL, the column becomes nullable+ column.Nullable = true+ for _, attribute := range fieldDef.AllColumnAttribute() {+ if attribute == nil {+ continue+ }+ // Check for NOT NULL constraint+ if attribute.NullLiteral() != nil && attribute.NOT_SYMBOL() != nil {+ column.Nullable = false+ break+ }+ // Check for PRIMARY KEY or UNIQUE KEY (these imply NOT NULL for primary keys)+ if attribute.GetValue() != nil && attribute.GetValue().GetTokenType() == mysql.MySQLParserKEY_SYMBOL {+ column.Nullable = false+ break}}- if position.tp == ColumnPositionNone {- if pos == 1 {- position.tp = ColumnPositionFirst- } else {- for _, col := range t.columnSet {- if col.position == pos-1 {- position.tp = ColumnPositionAfter- position.relativeColumn = col.name++ // Handle position changes by reordering columns in the proto+ if position != nil && position.tp != ColumnPositionNone {+ tableProto := table.GetProto()+ columns := tableProto.Columns++ // Find the current position of the column+ var currentIdx int+ for i, col := range columns {+ if col == column {+ currentIdx = i+ break+ }+ }++ // Remove from current position+ columns = append(columns[:currentIdx], columns[currentIdx+1:]...)++ // Insert at new position+ var newIdx int+ switch position.tp {+ case ColumnPositionFirst:+ newIdx = 0+ case ColumnPositionAfter:+ // Find the position after the relative column+ for i, col := range columns {+ if col.Name == position.relativeColumn {+ newIdx = i + 1break}}+ default:+ // ColumnPositionNone should not reach here, but keep at end if it does+ newIdx = len(columns)}- }- // drop column from columnSet.- for _, col := range t.columnSet {- if col.position > pos {- col.position--+ // Insert at newIdx+ if newIdx >= len(columns) {+ columns = append(columns, column)+ } else {+ columns = append(columns[:newIdx], append([]*storepb.ColumnMetadata{column}, columns[newIdx:]...)...)}- }- delete(t.columnSet, strings.ToLower(column.name))- // rename column from indexSet- t.renameColumnInIndexKey(oldColumnName, newColumnName)+ // Update the proto's column list+ tableProto.Columns = columns++ // Update position field for all columns+ for i, col := range columns {+ col.Position = int32(i + 1)+ }+ }- // create a new column in columnSet- return t.mysqlCreateColumn(newColumnName, fieldDef, position)+ return nil}type columnPositionType int@@ -828,41 +913,80 @@ func positionFromPlaceContext(place mysql.IPlaceContext) *mysqlColumnPosition {return columnPosition}-func (d *DatabaseState) mysqlCopyTable(databaseName, tableName, referTable string) *WalkThroughError {- targetTable, err := d.mysqlFindTableState(databaseName, referTable)+func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTable string) *WalkThroughError {+ targetTable, err := mysqlFindTableState(d, databaseName, referTable)if err != nil {return err}- schema, err := d.GetSchema("")- if err != nil {- return err+ schema := d.GetSchema("")+ if schema == nil {+ return &WalkThroughError{+ Code: code.SchemaNotExists,+ Content: "Schema does not exist",+ }+ }++ // Create the new table+ newTable, createErr := schema.CreateTable(tableName)+ if createErr != nil {+ return &WalkThroughError{Code: code.TableExists, Content: createErr.Error()}}- table := targetTable.copy()- table.name = tableName- schema.tableSet[table.name] = table++ // Copy table properties+ targetProto := targetTable.GetProto()+ newTableProto := newTable.GetProto()+ newTableProto.Engine = targetProto.Engine+ newTableProto.Collation = targetProto.Collation+ newTableProto.Comment = targetProto.Comment++ // Copy columns+ 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"}+ }+ if err := newTable.CreateColumn(colCopy); err != nil {+ return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ }+ }++ // Copy indexes+ 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"}+ }+ if err := newTable.CreateIndex(idxCopy); err != nil {+ return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ }+ }+return nil}-func (d *DatabaseState) mysqlFindTableState(databaseName, tableName string) (*TableState, *WalkThroughError) {- if databaseName != "" && !d.isCurrentDatabase(databaseName) {- return nil, NewAccessOtherDatabaseError(d.name, databaseName)+func mysqlFindTableState(d *model.DatabaseMetadata, databaseName, tableName string) (*model.TableMetadata, *WalkThroughError) {+ if databaseName != "" && !isCurrentDatabase(d, databaseName) {+ return nil, NewAccessOtherDatabaseError(d.DatabaseName(), databaseName)}- schema, err := d.GetSchema("")- if err != nil {- return nil, err+ schema := d.GetSchema("")+ if schema == nil {+ return nil, &WalkThroughError{+ Code: code.SchemaNotExists,+ Content: "Schema does not exist",+ }}- table, exists := mysqlGetTable(schema, tableName)- if !exists {+ table := schema.GetTable(tableName)+ if table == nil {return nil, NewTableNotExistsError(tableName)}return table, nil}-func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintDefContext) *WalkThroughError {+func mysqlCreateConstraint(table *model.TableMetadata, constraintDef mysql.ITableConstraintDefContext) *WalkThroughError {if constraintDef.GetType_() != nil {switch constraintDef.GetType_().GetTokenType() {// PRIMARY KEY.@@ -871,11 +995,11 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintD// never reach here.return nil}- if err := t.mysqlValidateKeyListVariants(constraintDef.KeyListVariants(), true /* primary */, false /* isSpatial*/); err != nil {+ if err := mysqlValidateKeyListVariants(table, constraintDef.KeyListVariants(), true /* primary */, false /* isSpatial*/); err != nil {return err}keyList := mysqlparser.NormalizeKeyListVariants(constraintDef.KeyListVariants())- if err := t.mysqlCreatePrimaryKey(keyList, mysqlGetIndexType(constraintDef)); err != nil {+ if err := mysqlCreatePrimaryKey(table, keyList, mysqlGetIndexType(constraintDef)); err != nil {return err}// normal KEY/INDEX.@@ -884,7 +1008,7 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintD// never reach here.return nil}- if err := t.mysqlValidateKeyListVariants(constraintDef.KeyListVariants(), false /* primary */, false /* isSpatial */); err != nil {+ if err := mysqlValidateKeyListVariants(table, constraintDef.KeyListVariants(), false /* primary */, false /* isSpatial */); err != nil {return err}@@ -893,7 +1017,7 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintDindexName = mysqlparser.NormalizeIndexName(constraintDef.IndexNameAndType().IndexName())}keyList := mysqlparser.NormalizeKeyListVariants(constraintDef.KeyListVariants())- if err := t.mysqlCreateIndex(indexName, keyList, false /* unique */, mysqlGetIndexType(constraintDef), constraintDef, mysql.NewEmptyCreateIndexContext()); err != nil {+ if err := mysqlCreateIndex(table, indexName, keyList, false /* unique */, mysqlGetIndexType(constraintDef), constraintDef, mysql.NewEmptyCreateIndexContext()); err != nil {return err}// UNIQUE KEY.@@ -902,7 +1026,7 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintD// never reach here.return nil}- if err := t.mysqlValidateKeyListVariants(constraintDef.KeyListVariants(), false /* primary */, false /* isSpatial*/); err != nil {+ if err := mysqlValidateKeyListVariants(table, constraintDef.KeyListVariants(), false /* primary */, false /* isSpatial*/); err != nil {return err}@@ -914,7 +1038,7 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintDindexName = mysqlparser.NormalizeIndexName(constraintDef.IndexNameAndType().IndexName())}keyList := mysqlparser.NormalizeKeyListVariants(constraintDef.KeyListVariants())- if err := t.mysqlCreateIndex(indexName, keyList, true /* unique */, mysqlGetIndexType(constraintDef), constraintDef, mysql.NewEmptyCreateIndexContext()); err != nil {+ if err := mysqlCreateIndex(table, indexName, keyList, true /* unique */, mysqlGetIndexType(constraintDef), constraintDef, mysql.NewEmptyCreateIndexContext()); err != nil {return err}// FULLTEXT KEY.@@ -923,7 +1047,7 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintD// never reach here.return nil}- if err := t.mysqlValidateKeyListVariants(constraintDef.KeyListVariants(), false /* primary */, false /* isSpatial*/); err != nil {+ if err := mysqlValidateKeyListVariants(table, constraintDef.KeyListVariants(), false /* primary */, false /* isSpatial*/); err != nil {return err}indexName := ""@@ -931,7 +1055,7 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintDindexName = mysqlparser.NormalizeIndexName(constraintDef.IndexName())}keyList := mysqlparser.NormalizeKeyListVariants(constraintDef.KeyListVariants())- if err := t.mysqlCreateIndex(indexName, keyList, false /* unique */, mysqlGetIndexType(constraintDef), constraintDef, mysql.NewEmptyCreateIndexContext()); err != nil {+ if err := mysqlCreateIndex(table, indexName, keyList, false /* unique */, mysqlGetIndexType(constraintDef), constraintDef, mysql.NewEmptyCreateIndexContext()); err != nil {return err}case mysql.MySQLParserFOREIGN_SYMBOL:@@ -947,36 +1071,36 @@ func (t *TableState) mysqlCreateConstraint(constraintDef mysql.ITableConstraintD}// mysqlValidateKeyListVariants validates the key list variants.-func (t *TableState) mysqlValidateKeyListVariants(keyList mysql.IKeyListVariantsContext, primary bool, isSpatial bool) *WalkThroughError {+func mysqlValidateKeyListVariants(table *model.TableMetadata, keyList mysql.IKeyListVariantsContext, primary bool, isSpatial bool) *WalkThroughError {if keyList.KeyList() != nil {columns := mysqlparser.NormalizeKeyList(keyList.KeyList())- if err := t.mysqlValidateColumnList(columns, primary, isSpatial); err != nil {+ if err := mysqlValidateColumnList(table, columns, primary, isSpatial); err != nil {return err}}if keyList.KeyListWithExpression() != nil {expressions := mysqlparser.NormalizeKeyListWithExpression(keyList.KeyListWithExpression())- if err := t.mysqlValidateExpressionList(expressions, primary, isSpatial); err != nil {+ if err := mysqlValidateExpressionList(table, expressions, primary, isSpatial); err != nil {return err}}return nil}-func (t *TableState) mysqlValidateColumnList(columnList []string, primary bool, isSpatial bool) *WalkThroughError {+func mysqlValidateColumnList(table *model.TableMetadata, columnList []string, primary bool, isSpatial bool) *WalkThroughError {for _, columnName := range columnList {- column, exists := t.columnSet[strings.ToLower(columnName)]- if !exists {- return NewColumnNotExistsError(t.name, columnName)+ column := table.GetColumn(columnName)+ if column == nil {+ return NewColumnNotExistsError(table.GetProto().Name, columnName)}if primary {- column.nullable = false+ column.Nullable = false}- if isSpatial && column.nullable {+ if isSpatial && column.Nullable {return &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),+ Content: fmt.Sprintf("All parts of a SPATIAL index must be NOT NULL, but `%s` is nullable", column.Name),}}}@@ -985,22 +1109,22 @@ func (t *TableState) mysqlValidateColumnList(columnList []string, primary bool,// mysqlValidateExpressionList validates the expression list.// TODO: update expression validation.-func (t *TableState) mysqlValidateExpressionList(expressionList []string, primary bool, isSpatial bool) *WalkThroughError {+func mysqlValidateExpressionList(table *model.TableMetadata, expressionList []string, primary bool, isSpatial bool) *WalkThroughError {for _, expression := range expressionList {- column, exists := t.columnSet[strings.ToLower(expression)]+ column := table.GetColumn(expression)// If expression is not a column, we do not need to validate it.- if !exists {+ if column == nil {continue}if primary {- column.nullable = false+ column.Nullable = false}- if isSpatial && column.nullable {+ if isSpatial && column.Nullable {return &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),+ Content: fmt.Sprintf("All parts of a SPATIAL index must be NOT NULL, but `%s` is nullable", column.Name),}}}@@ -1045,23 +1169,14 @@ func mysqlGetIndexType(tableConstraint mysql.ITableConstraintDefContext) stringreturn "BTREE"}-func (t *TableState) mysqlCreateColumn(columnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *WalkThroughError {- if _, exists := t.columnSet[strings.ToLower(columnName)]; exists {+func mysqlCreateColumn(table *model.TableMetadata, columnName string, fieldDef mysql.IFieldDefinitionContext, position *mysqlColumnPosition) *WalkThroughError {+ if table.GetColumn(columnName) != nil {return &WalkThroughError{Code: code.ColumnExists,- Content: fmt.Sprintf("Column `%s` already exists in table `%s`", columnName, t.name),+ Content: fmt.Sprintf("Column `%s` already exists in table `%s`", columnName, table.GetProto().Name),}}- // todo: handle position.- pos := len(t.columnSet) + 1- if position != nil {- var err *WalkThroughError- pos, err = t.mysqlReorderColumn(position)- if err != nil {- return err- }- }columnType := ""characterSet := ""collation := ""@@ -1073,15 +1188,14 @@ func (t *TableState) mysqlCreateColumn(columnName string, fieldDef mysql.IFieldDcharacterSet = mysqlparser.GetCharSetName(fieldDef.DataType())collation = mysqlparser.GetCollationName(fieldDef)- col := &ColumnState{- name: columnName,- position: pos,- defaultValue: "",- nullable: true,- columnType: columnType,- characterSet: characterSet,- collation: collation,- comment: "",+ col := &storepb.ColumnMetadata{+ Name: columnName,+ Position: int32(len(table.GetColumns()) + 1),+ Default: "",+ Nullable: true,+ Type: columnType,+ CharacterSet: characterSet,+ Collation: collation,}setNullDefault := false@@ -1095,13 +1209,13 @@ func (t *TableState) mysqlCreateColumn(columnName string, fieldDef mysql.IFieldD}// not null.if attribute.NullLiteral() != nil && attribute.NOT_SYMBOL() != nil {- col.nullable = false+ col.Nullable = false}if attribute.GetValue() != nil {switch attribute.GetValue().GetTokenType() {// default value.case mysql.MySQLParserDEFAULT_SYMBOL:- if err := mysqlCheckDefault(columnName, fieldDef); err != nil {+ if err := mysqlCheckDefault(table, columnName, fieldDef); err != nil {return err}if attribute.SignedLiteral() == nil {@@ -1114,14 +1228,14 @@ func (t *TableState) mysqlCreateColumn(columnName string, fieldDef mysql.IFieldD}// handle default 'null' etc.defaultValue := mysqlparser.NormalizeMySQLSignedLiteral(attribute.SignedLiteral())- col.defaultValue = defaultValue+ col.Default = defaultValue// comment.case mysql.MySQLParserCOMMENT_SYMBOL:if attribute.TextLiteral() == nil {continue}comment := mysqlparser.NormalizeMySQLTextLiteral(attribute.TextLiteral())- col.comment = comment+ col.Comment = comment// on update now().case mysql.MySQLParserON_SYMBOL:if attribute.UPDATE_SYMBOL() == nil || attribute.NOW_SYMBOL() == nil {@@ -1130,21 +1244,21 @@ func (t *TableState) mysqlCreateColumn(columnName string, fieldDef mysql.IFieldDif !mysqlparser.IsTimeType(fieldDef.DataType()) {return &WalkThroughError{Code: code.OnUpdateColumnNotDatetimeOrTimestamp,- Content: fmt.Sprintf("Column `%s` use ON UPDATE but is not DATETIME or TIMESTAMP", col.name),+ Content: fmt.Sprintf("Column `%s` use ON UPDATE but is not DATETIME or TIMESTAMP", col.Name),}}// primary key.case mysql.MySQLParserKEY_SYMBOL:// the key attribute for in a column meaning primary key.- col.nullable = false+ col.Nullable = false// we need to check the key type which generated by tidb parser.- if err := t.mysqlCreatePrimaryKey([]string{strings.ToLower(col.name)}, "BTREE"); err != nil {+ if err := mysqlCreatePrimaryKey(table, []string{strings.ToLower(col.Name)}, "BTREE"); err != nil {return err}// unique key.case mysql.MySQLParserUNIQUE_SYMBOL:// unique index.- if err := t.mysqlCreateIndex("", []string{strings.ToLower(col.name)}, true /* unique */, "BTREE", mysql.NewEmptyTableConstraintDefContext(), mysql.NewEmptyCreateIndexContext()); err != nil {+ if err := mysqlCreateIndex(table, "", []string{strings.ToLower(col.Name)}, true /* unique */, "BTREE", mysql.NewEmptyTableConstraintDefContext(), mysql.NewEmptyCreateIndexContext()); err != nil {return err}// auto_increment.@@ -1162,59 +1276,78 @@ func (t *TableState) mysqlCreateColumn(columnName string, fieldDef mysql.IFieldD}}- if !col.nullable && setNullDefault {+ if !col.Nullable && setNullDefault {return &WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.- Content: fmt.Sprintf("Invalid default value for column `%s`", col.name),+ Content: fmt.Sprintf("Invalid default value for column `%s`", col.Name),}}- t.columnSet[strings.ToLower(col.name)] = col- return nil-}+ if err := table.CreateColumn(col); err != nil {+ return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ }++ // Handle position by reordering columns in the proto+ if position != nil && position.tp != ColumnPositionNone {+ tableProto := table.GetProto()+ columns := tableProto.Columns++ // The new column was just appended, so it's at the end+ lastIdx := len(columns) - 1+ newColumn := columns[lastIdx]-// reorderColumn reorders the columns for new column and returns the new column position.-func (t *TableState) mysqlReorderColumn(position *mysqlColumnPosition) (int, *WalkThroughError) {- switch position.tp {- case ColumnPositionNone:- return len(t.columnSet) + 1, nil- case ColumnPositionFirst:- for _, column := range t.columnSet {- column.position++- }- return 1, nil- case ColumnPositionAfter:- columnName := strings.ToLower(position.relativeColumn)- column, exist := t.columnSet[columnName]- if !exist {- return 0, NewColumnNotExistsError(t.name, columnName)- }- for _, col := range t.columnSet {- if col.position > column.position {- col.position+++ // Remove from the end+ columns = columns[:lastIdx]++ // Insert at the desired position+ var newIdx int+ switch position.tp {+ case ColumnPositionFirst:+ newIdx = 0+ case ColumnPositionAfter:+ // Find the position after the relative column+ for i, c := range columns {+ if c.Name == position.relativeColumn {+ newIdx = i + 1+ break+ }}+ default:+ // ColumnPositionNone should not reach here, but keep at end if it does+ newIdx = len(columns)}- return column.position + 1, nil- default:- return 0, &WalkThroughError{- Code: code.Unsupported,- Content: fmt.Sprintf("Unsupported column position type: %d", position.tp),++ // Insert at newIdx+ if newIdx >= len(columns) {+ columns = append(columns, newColumn)+ } else {+ columns = append(columns[:newIdx], append([]*storepb.ColumnMetadata{newColumn}, columns[newIdx:]...)...)+ }++ // Update the proto's column list+ tableProto.Columns = columns++ // Update position field for all columns+ for i, c := range columns {+ c.Position = int32(i + 1)}}++ return nil}-func (t *TableState) mysqlCreateIndex(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) *WalkThroughError {if len(keyList) == 0 {return &WalkThroughError{Code: code.IndexEmptyKeys,- Content: fmt.Sprintf("Index `%s` in table `%s` has empty key", name, t.name),+ Content: fmt.Sprintf("Index `%s` in table `%s` has empty key", name, table.GetProto().Name),}}// construct a index name if name is empty.if name != "" {- if _, exists := t.indexSet[strings.ToLower(name)]; exists {- return NewIndexExistsError(t.name, name)+ if table.GetIndex(name) != nil {+ return NewIndexExistsError(table.GetProto().Name, name)}} else {suffix := 1@@ -1223,118 +1356,111 @@ func (t *TableState) mysqlCreateIndex(name string, keyList []string, unique boolif suffix > 1 {name = fmt.Sprintf("%s_%d", keyList[0], suffix)}- if _, exists := t.indexSet[strings.ToLower(name)]; !exists {+ if table.GetIndex(name) == nil {break}suffix++}}- index := &IndexState{- name: name,- expressionList: keyList,- indexType: tp,- unique: unique,- primary: false,- visible: true,- comment: "",- }+ visible := true- // need to check the visibility of index.- // we need a for-loop to determined the visibility of index.-- // NORMAL KEY/INDEX.- // PRIMARY KEY.- // UNIQUE KEY.-- // for create table statement.+ // Check visibility from table constraintfor _, attribute := range tableConstraint.AllIndexOption() {if attribute == nil || attribute.CommonIndexOption() == nil {continue}if attribute.CommonIndexOption().Visibility() != nil && attribute.CommonIndexOption().Visibility().INVISIBLE_SYMBOL() != nil {- index.visible = false+ visible = false}}- // for create index statement.+ // Check visibility from create index statementfor _, attribute := range createIndexDef.AllIndexOption() {if attribute == nil || attribute.CommonIndexOption() == nil {continue}if attribute.CommonIndexOption().Visibility() != nil && attribute.CommonIndexOption().Visibility().INVISIBLE_SYMBOL() != nil {- index.visible = false+ visible = false}}- // FULLTEXT INDEX.- // for create table statement.+ // Check FULLTEXT visibilityfor _, attribute := range tableConstraint.AllFulltextIndexOption() {if attribute == nil || attribute.CommonIndexOption() == nil {continue}if attribute.CommonIndexOption().Visibility() != nil && attribute.CommonIndexOption().Visibility().INVISIBLE_SYMBOL() != nil {- index.visible = false+ visible = false}}- // for create index statement.for _, attribute := range createIndexDef.AllFulltextIndexOption() {if attribute == nil || attribute.CommonIndexOption() == nil {continue}if attribute.CommonIndexOption().Visibility() != nil && attribute.CommonIndexOption().Visibility().INVISIBLE_SYMBOL() != nil {- index.visible = false+ visible = false}}- // SPATIAL INDEX.- // for create table statement.+ // Check SPATIAL visibilityfor _, attribute := range tableConstraint.AllSpatialIndexOption() {if attribute == nil || attribute.CommonIndexOption() == nil {continue}if attribute.CommonIndexOption().Visibility() != nil && attribute.CommonIndexOption().Visibility().INVISIBLE_SYMBOL() != nil {- index.visible = false+ visible = false}}- // for create index statement.for _, attribute := range createIndexDef.AllSpatialIndexOption() {if attribute == nil || attribute.CommonIndexOption() == nil {continue}if attribute.CommonIndexOption().Visibility() != nil && attribute.CommonIndexOption().Visibility().INVISIBLE_SYMBOL() != nil {- index.visible = false+ visible = false}}- t.indexSet[strings.ToLower(name)] = index+ index := &storepb.IndexMetadata{+ Name: name,+ Expressions: keyList,+ Type: tp,+ Unique: unique,+ Primary: false,+ Visible: visible,+ }++ if err := table.CreateIndex(index); err != nil {+ return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ }return nil}-func (t *TableState) mysqlCreatePrimaryKey(keys []string, tp string) *WalkThroughError {- if _, exists := t.indexSet[strings.ToLower(PrimaryKeyName)]; exists {+func mysqlCreatePrimaryKey(table *model.TableMetadata, keys []string, tp string) *WalkThroughError {+ if table.GetPrimaryKey() != nil {return &WalkThroughError{Code: code.PrimaryKeyExists,- Content: fmt.Sprintf("Primary key exists in table `%s`", t.name),+ Content: fmt.Sprintf("Primary key exists in table `%s`", table.GetProto().Name),}}- pk := &IndexState{- name: PrimaryKeyName,- expressionList: keys,- indexType: tp,- unique: true,- primary: true,- visible: true,- comment: "",+ pk := &storepb.IndexMetadata{+ Name: PrimaryKeyName,+ Expressions: keys,+ Type: tp,+ Unique: true,+ Primary: true,+ Visible: true,+ }+ if err := table.CreateIndex(pk); err != nil {+ return &WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}}- t.indexSet[strings.ToLower(pk.name)] = pkreturn nil}-func mysqlCheckDefault(columnName string, fieldDefinition mysql.IFieldDefinitionContext) *WalkThroughError {+func mysqlCheckDefault(_ *model.TableMetadata, columnName string, fieldDefinition mysql.IFieldDefinitionContext) *WalkThroughError {if fieldDefinition.DataType() == nil || fieldDefinition.DataType().GetType_() == nil {return nil}diff --git a/backend/plugin/advisor/catalog/walk_through_for_pg.go b/backend/plugin/advisor/catalog/walk_through_for_pg.goindex f283d70bc0..beba5181d7 100644--- a/backend/plugin/advisor/catalog/walk_through_for_pg.go+++ b/backend/plugin/advisor/catalog/walk_through_for_pg.go@@ -5,49 +5,44 @@ import ("strings""github.com/antlr4-go/antlr/v4"- "github.com/pkg/errors"-parser "github.com/bytebase/parser/postgresql"+ "github.com/pkg/errors"+ 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/store/model")-// PgWalkThrough walks through the PostgreSQL ANTLR parse tree and builds catalog state.-func PgWalkThrough(d *DatabaseState, ast any) error {+// PgWalkThrough walks through the PostgreSQL ANTLR parse tree and builds catalog metadata.+func PgWalkThrough(d *model.DatabaseMetadata, ast any) error {// ANTLR-based walkthroughparseResult, ok := ast.(*pgparser.ParseResult)if !ok {return errors.Errorf("PostgreSQL walk-through expects *pgparser.ParseResult, got %T", ast)}-root, ok := parseResult.Tree.(parser.IRootContext)if !ok {return errors.Errorf("invalid ANTLR tree type %T", parseResult.Tree)}-// Build listener with database statelistener := &pgCatalogListener{BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},databaseState: d,}-// Walk through the parse treeantlr.ParseTreeWalkerDefault.Walk(listener, root)-// Return any error encountered during walkif listener.err != nil {return listener.err}-return nil}// pgCatalogListener builds catalog state by listening to ANTLR parse tree events.type pgCatalogListener struct {*parser.BasePostgreSQLParserListener-- databaseState *DatabaseState+ databaseState *model.DatabaseMetadataerr *WalkThroughErrorcurrentLine int}@@ -66,47 +61,39 @@ func (l *pgCatalogListener) setError(err *WalkThroughError) {// ========================================// CREATE TABLE handling// ========================================-// EnterCreatestmt handles CREATE TABLE statements.func (l *pgCatalogListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {if !isTopLevel(ctx.GetParent()) || l.err != nil {return}-l.currentLine = ctx.GetStart().GetLine()-// Extract table name and schemaqualifiedNames := ctx.AllQualified_name()if len(qualifiedNames) == 0 {return}-tableName := extractTableName(qualifiedNames[0])schemaName := extractSchemaName(qualifiedNames[0])-if tableName == "" {return}-// Check database name if specifieddatabaseName := extractDatabaseName(qualifiedNames[0])- if databaseName != "" && l.databaseState.name != databaseName {+ if databaseName != "" && l.databaseState.DatabaseName() != databaseName {l.setError(&WalkThroughError{Code: code.NotCurrentDatabase,- Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.name),+ Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.DatabaseName()),})return}-// Get or create schema- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {l.setError(err)return}-// Check if table already exists- if _, exists := schema.tableSet[tableName]; exists {+ if schema.GetTable(tableName) != nil {// Check IF NOT EXISTS clauseifNotExists := ctx.IF_P() != nil && ctx.NOT() != nil && ctx.EXISTS() != nilif ifNotExists {@@ -114,19 +101,16 @@ func (l *pgCatalogListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {}l.setError(&WalkThroughError{Code: code.TableExists,- Content: fmt.Sprintf(`The table %q already exists in the schema %q`, tableName, schema.name),+ Content: fmt.Sprintf(`The table %q already exists in the schema %q`, tableName, schema.GetProto().Name),})return}-- // Create table state- table := &TableState{- name: tableName,- columnSet: make(columnStateMap),- indexSet: make(IndexStateMap),+ // Create table+ table, createErr := schema.CreateTable(tableName)+ if createErr != nil {+ l.setError(&WalkThroughError{Code: code.TableExists, Content: createErr.Error()})+ return}- schema.tableSet[table.name] = table-// Process column definitionsif ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()@@ -149,12 +133,11 @@ func (l *pgCatalogListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {}}-// createColumn creates a column in the table.-func pgCreateColumn(schema *SchemaState, table *TableState, columnDef parser.IColumnDefContext) *WalkThroughError {+// pgCreateColumn creates a column in the table.+func pgCreateColumn(schema *model.SchemaMetadata, table *model.TableMetadata, columnDef parser.IColumnDefContext) *WalkThroughError {if columnDef == nil {return nil}-// Extract column namevar columnName stringif columnDef.Colid() != nil {@@ -163,33 +146,26 @@ func pgCreateColumn(schema *SchemaState, table *TableState, columnDef parser.ICoif columnName == "" {return nil}-// Check if column already exists- if _, exists := table.columnSet[columnName]; exists {+ if table.GetColumn(columnName) != nil {return &WalkThroughError{Code: code.ColumnExists,- Content: fmt.Sprintf("The column %q already exists in table %q", columnName, table.name),+ Content: fmt.Sprintf("The column %q already exists in table %q", columnName, table.GetProto().Name),}}-// Get column typevar columnType stringif columnDef.Typename() != nil {columnType = extractTypeName(columnDef.Typename())}-- // Create column state- pos := len(table.columnSet) + 1- columnState := &ColumnState{- name: columnName,- position: pos,- defaultValue: "",- nullable: true,- columnType: columnType,- collation: "",- }- table.columnSet[columnState.name] = columnState-+ // Create column metadata+ col := &storepb.ColumnMetadata{+ Name: columnName,+ Position: int32(len(table.GetColumns()) + 1),+ Default: "",+ Nullable: true,+ Type: columnType,+ }// Process column constraintsif columnDef.Colquallist() != nil {allQuals := columnDef.Colquallist().AllColconstraint()@@ -198,21 +174,18 @@ func pgCreateColumn(schema *SchemaState, table *TableState, columnDef parser.ICocontinue}elem := qual.Colconstraintelem()-// Handle NOT NULLif elem.NOT() != nil && elem.NULL_P() != nil {- columnState.nullable = false+ col.Nullable = false}-// Handle DEFAULTif elem.DEFAULT() != nil {// Extract default expression from B_exprif elem.B_expr() != nil {defaultValue := elem.B_expr().GetText()- columnState.defaultValue = defaultValue+ col.Default = defaultValue}}-// Handle PRIMARY KEYif elem.PRIMARY() != nil && elem.KEY() != nil {constraintName := ""@@ -220,68 +193,65 @@ func pgCreateColumn(schema *SchemaState, table *TableState, columnDef parser.ICoconstraintName = pgparser.NormalizePostgreSQLName(qual.Name())}if constraintName == "" {- constraintName = schema.pgGeneratePrimaryKeyName(table.name)+ constraintName = pgGeneratePrimaryKeyName(schema, table.GetProto().Name)}-// Set column as NOT NULL- columnState.nullable = false-+ col.Nullable = false// Create primary key index- index := &IndexState{- name: constraintName,- expressionList: []string{columnName},- indexType: "btree",- unique: true,- primary: true,- isConstraint: true,+ index := &storepb.IndexMetadata{+ Name: constraintName,+ Expressions: []string{columnName},+ Type: "btree",+ Unique: true,+ Primary: true,+ IsConstraint: true,+ }+ if err := table.CreateIndex(index); err != nil {+ return &WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}}- table.indexSet[index.name] = index- schema.identifierMap[index.name] = true}-// Handle UNIQUEif elem.UNIQUE() != nil && (elem.PRIMARY() == nil || elem.KEY() == nil) {constraintName := ""if qual.Name() != nil {constraintName = pgparser.NormalizePostgreSQLName(qual.Name())}-// Generate index name if not specifiedif constraintName == "" {- constraintName = generateIndexName(table.name, []string{columnName}, true)+ constraintName = generateIndexName(table.GetProto().Name, []string{columnName}, true)}-- index := &IndexState{- name: constraintName,- expressionList: []string{columnName},- indexType: "btree",- unique: true,- primary: false,- isConstraint: true,+ index := &storepb.IndexMetadata{+ Name: constraintName,+ Expressions: []string{columnName},+ Type: "btree",+ Unique: true,+ Primary: false,+ IsConstraint: true,+ }+ if err := table.CreateIndex(index); err != nil {+ return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}}- table.indexSet[index.name] = index- schema.identifierMap[index.name] = true}}}-+ // Create the column+ if err := table.CreateColumn(col); err != nil {+ return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ }return nil}// createTableConstraint creates a table-level constraint.-func createTableConstraint(schema *SchemaState, table *TableState, constraint parser.ITableconstraintContext) *WalkThroughError {+func createTableConstraint(schema *model.SchemaMetadata, table *model.TableMetadata, constraint parser.ITableconstraintContext) *WalkThroughError {if constraint == nil || constraint.Constraintelem() == nil {return nil}-elem := constraint.Constraintelem()-// Extract constraint nameconstraintName := ""if constraint.Name() != nil {constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())}-// Handle PRIMARY KEY constraintif elem.PRIMARY() != nil && elem.KEY() != nil {var columnList []string@@ -294,40 +264,40 @@ func createTableConstraint(schema *SchemaState, table *TableState, constraint pa}}}-// Set all PK columns as NOT NULLfor _, colName := range columnList {- if column, exists := table.columnSet[colName]; exists {- column.nullable = false+ column := table.GetColumn(colName)+ if column != nil {+ column.Nullable = false} else {- return NewColumnNotExistsError(table.name, colName)+ return NewColumnNotExistsError(table.GetProto().Name, colName)}}-// Generate PK name if not providedpkName := constraintNameif pkName == "" {- pkName = schema.pgGeneratePrimaryKeyName(table.name)+ pkName = pgGeneratePrimaryKeyName(schema, table.GetProto().Name)}-- // Check if identifier already exists- if _, exists := schema.identifierMap[pkName]; exists {- return NewRelationExistsError(pkName, schema.name)+ // Check if primary key already exists+ if table.GetPrimaryKey() != nil {+ return &WalkThroughError{+ Code: code.PrimaryKeyExists,+ Content: fmt.Sprintf("Primary key already exists in table %q", table.GetProto().Name),+ }}-// Create primary key index- index := &IndexState{- name: pkName,- expressionList: columnList,- indexType: "btree",- unique: true,- primary: true,- isConstraint: true,+ index := &storepb.IndexMetadata{+ Name: pkName,+ Expressions: columnList,+ Type: "btree",+ Unique: true,+ Primary: true,+ IsConstraint: true,+ }+ if err := table.CreateIndex(index); err != nil {+ return &WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()}}- table.indexSet[index.name] = index- schema.identifierMap[index.name] = true}-// Handle UNIQUE constraintif elem.UNIQUE() != nil && (elem.PRIMARY() == nil || elem.KEY() == nil) {var columnList []string@@ -340,85 +310,75 @@ func createTableConstraint(schema *SchemaState, table *TableState, constraint pa}}}-// Generate index name if not specifiedindexName := constraintNameif indexName == "" {- indexName = generateIndexName(table.name, columnList, true)+ indexName = generateIndexName(table.GetProto().Name, columnList, true)}-- // Check if identifier already exists- if _, exists := schema.identifierMap[indexName]; exists {- return NewRelationExistsError(indexName, schema.name)+ // Check if index already exists+ if table.GetIndex(indexName) != nil {+ return &WalkThroughError{+ Code: code.IndexExists,+ Content: fmt.Sprintf("Index %q already exists in table %q", indexName, table.GetProto().Name),+ }}-// Validate columns existfor _, colName := range columnList {- if _, exists := table.columnSet[colName]; !exists {- return NewColumnNotExistsError(table.name, colName)+ if table.GetColumn(colName) == nil {+ return NewColumnNotExistsError(table.GetProto().Name, colName)}}-- // Create unique index- index := &IndexState{- name: indexName,- expressionList: columnList,- indexType: "btree",- unique: true,- primary: false,- isConstraint: true,+ // Create unique index (from UNIQUE constraint)+ index := &storepb.IndexMetadata{+ Name: indexName,+ Expressions: columnList,+ Type: "btree",+ Unique: true,+ Primary: false,+ IsConstraint: true,+ }+ if err := table.CreateIndex(index); err != nil {+ return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}}- table.indexSet[index.name] = index- schema.identifierMap[index.name] = true}-// Note: We skip CHECK, FOREIGN KEY, EXCLUSION constraints for now// as the legacy implementation also skips them-return nil}// ========================================// CREATE INDEX handling// ========================================-// EnterIndexstmt handles CREATE INDEX statements.func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {if !isTopLevel(ctx.GetParent()) || l.err != nil {return}-l.currentLine = ctx.GetStart().GetLine()-// Extract relation (table) namerelationExpr := ctx.Relation_expr()if relationExpr == nil || relationExpr.Qualified_name() == nil {return}-tableName := extractTableName(relationExpr.Qualified_name())schemaName := extractSchemaName(relationExpr.Qualified_name())- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {l.setError(err)return}-- table, exists := schema.tableSet[tableName]- if !exists {+ table := schema.GetTable(tableName)+ if table == nil {l.setError(NewTableNotExistsError(tableName))return}-// Extract index name (can be empty for auto-generated names)indexName := ""if ctx.Name() != nil {indexName = pgparser.NormalizePostgreSQLName(ctx.Name())}-// Check IF NOT EXISTSifNotExists := ctx.IF_P() != nil && ctx.NOT() != nil && ctx.EXISTS() != nil-// Extract column listvar columnList []stringif ctx.Index_params() != nil {@@ -433,7 +393,6 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {}}}-if len(columnList) == 0 {l.setError(&WalkThroughError{Code: code.IndexEmptyKeys,@@ -441,16 +400,14 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {})return}-// Generate index name if not providedisUnique := ctx.Opt_unique() != nil && ctx.Opt_unique().UNIQUE() != nilwasAutoGenerated := indexName == ""if indexName == "" {indexName = generateIndexName(tableName, columnList, isUnique)}-// Check if index name already exists- if _, exists := schema.identifierMap[indexName]; exists {+ if table.GetIndex(indexName) != nil {if ifNotExists {return}@@ -458,110 +415,97 @@ func (l *pgCatalogListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {if wasAutoGenerated {indexName = generateUniqueIndexName(schema, tableName, columnList, isUnique)} else {- l.setError(NewRelationExistsError(indexName, schema.name))+ l.setError(NewRelationExistsError(indexName, schema.GetProto().Name))return}}-// Check that all columns exist (skip expressions)for _, colName := range columnList {if colName != "expr" {- if _, exists := table.columnSet[colName]; !exists {+ if table.GetColumn(colName) == nil {l.setError(NewColumnNotExistsError(tableName, colName))return}}}-// Determine index typeindexType := "btree" // defaultif ctx.Access_method_clause() != nil && ctx.Access_method_clause().Name() != nil {method := pgparser.NormalizePostgreSQLName(ctx.Access_method_clause().Name())indexType = method}-- // Create index state- index := &IndexState{- name: indexName,- expressionList: columnList,- indexType: indexType,- unique: isUnique,- primary: false,- isConstraint: false,+ // Create index+ index := &storepb.IndexMetadata{+ Name: indexName,+ Expressions: columnList,+ Type: indexType,+ Unique: isUnique,+ Primary: false,+ }+ if err := table.CreateIndex(index); err != nil {+ l.setError(&WalkThroughError{Code: code.IndexExists, Content: err.Error()})}-- table.indexSet[index.name] = index- schema.identifierMap[index.name] = true}// ========================================// CREATE SCHEMA handling// ========================================-// TODO: EnterCreateschemastatement - Need to find correct ANTLR context name-// func (l *pgCatalogListener) EnterCreateschemastatement(ctx *parser.CreateschemaContext) {-// if !isTopLevel(ctx.GetParent()) || l.err != nil {-// return-// }//-// if !l.checkDatabaseNotDeleted() {-// return-// }+// func (l *pgCatalogListener) EnterCreateschemastatement(ctx *parser.CreateschemaContext) {+// if !isTopLevel(ctx.GetParent()) || l.err != nil {+// return+// }//-// l.currentLine = ctx.GetStart().GetLine()+// if !l.checkDatabaseNotDeleted() {+// return+// }+//+// l.currentLine = ctx.GetStart().GetLine()+//+// // TODO: Implement CREATE SCHEMA logic+// // Similar to pgCreateSchema() in walk_through_for_pg.go+// }//-// // TODO: Implement CREATE SCHEMA logic-// // Similar to pgCreateSchema() in walk_through_for_pg.go-// }-// ========================================// ALTER TABLE handling// ========================================-// EnterAltertablestmt handles ALTER TABLE statements.func (l *pgCatalogListener) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {if !isTopLevel(ctx.GetParent()) || l.err != nil {return}-l.currentLine = ctx.GetStart().GetLine()-// Extract table nameif ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {return}-tableName := extractTableName(ctx.Relation_expr().Qualified_name())schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())databaseName := extractDatabaseName(ctx.Relation_expr().Qualified_name())-// Check database access- if databaseName != "" && l.databaseState.name != databaseName {+ if databaseName != "" && l.databaseState.DatabaseName() != databaseName {l.setError(&WalkThroughError{Code: code.NotCurrentDatabase,- Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.name),+ Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.DatabaseName()),})return}-// Get schema and table- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {l.setError(err)return}-- table, err := schema.GetTable(tableName)- if err != nil {- l.setError(err)+ table := schema.GetTable(tableName)+ if table == nil {+ l.setError(NewTableNotExistsError(tableName))return}-// Process alter table commandsif ctx.Alter_table_cmds() == nil {return}-allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()for _, cmd := range allCmds {l.processAlterTableCmd(schema, table, cmd)@@ -572,9 +516,8 @@ func (l *pgCatalogListener) EnterAltertablestmt(ctx *parser.AltertablestmtContex}// processAlterTableCmd handles individual ALTER TABLE commands.-func (l *pgCatalogListener) processAlterTableCmd(schema *SchemaState, table *TableState, cmd parser.IAlter_table_cmdContext) {+func (l *pgCatalogListener) processAlterTableCmd(schema *model.SchemaMetadata, table *model.TableMetadata, cmd parser.IAlter_table_cmdContext) {// RENAME operations are handled by EnterRenamestmt, not here-// Handle ADD COLUMNif cmd.ADD_P() != nil && cmd.COLUMN() != nil {if cmd.ColumnDef() != nil {@@ -583,13 +526,11 @@ func (l *pgCatalogListener) processAlterTableCmd(schema *SchemaState, table *Tab}return}-// Handle ADD CONSTRAINTif cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {l.alterTableAddConstraint(schema, table, cmd.Tableconstraint())return}-// Handle DROP CONSTRAINTif cmd.DROP() != nil && cmd.CONSTRAINT() != nil {ifExists := cmd.IF_P() != nil && cmd.EXISTS() != nil@@ -599,7 +540,6 @@ func (l *pgCatalogListener) processAlterTableCmd(schema *SchemaState, table *Tab}return}-// Handle DROP COLUMNif cmd.DROP() != nil && cmd.Opt_column() != nil {ifExists := cmd.IF_P() != nil && cmd.EXISTS() != nil@@ -611,20 +551,17 @@ func (l *pgCatalogListener) processAlterTableCmd(schema *SchemaState, table *Tab}return}-// Handle ALTER COLUMN commandsif cmd.ALTER() != nil && cmd.Opt_column() != nil {allColids := cmd.AllColid()if len(allColids) > 0 {columnName := pgparser.NormalizePostgreSQLColid(allColids[0])-// Check for SET DATA TYPEif cmd.TYPE_P() != nil && cmd.Typename() != nil {typeString := extractTypeName(cmd.Typename())l.alterTableAlterColumnType(schema, table, columnName, typeString)return}-// Check for SET/DROP DEFAULTif cmd.Alter_column_default() != nil {altDefault := cmd.Alter_column_default()@@ -638,7 +575,6 @@ func (l *pgCatalogListener) processAlterTableCmd(schema *SchemaState, table *Tab}return}-// Check for SET NOT NULLif cmd.SET() != nil && cmd.NOT() != nil && cmd.NULL_P() != nil {l.alterTableSetNotNull(table, columnName)@@ -650,125 +586,115 @@ func (l *pgCatalogListener) processAlterTableCmd(schema *SchemaState, table *Tab}// alterTableDropColumn handles DROP COLUMN command.-func (l *pgCatalogListener) alterTableDropColumn(schema *SchemaState, table *TableState, columnName string, ifExists bool) {- column, exists := table.columnSet[columnName]- if !exists {+func (l *pgCatalogListener) alterTableDropColumn(schema *model.SchemaMetadata, table *model.TableMetadata, columnName string, ifExists bool) {+ column := table.GetColumn(columnName)+ if column == nil {if ifExists {return}- l.setError(NewColumnNotExistsError(table.name, columnName))- return- }-- // Check if column is referenced by any views- viewList, err := l.databaseState.existedViewList(column.dependencyView)- if err != nil {- l.setError(&WalkThroughError{- Code: code.Internal,- Content: fmt.Sprintf("Failed to check view dependency: %v", err),- })+ l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))return}- if len(viewList) > 0 {+ // Check if any views depend on this column+ dependentViews := schema.GetDependentViews(table.GetProto().Name, columnName)+ if len(dependentViews) > 0 {+ // Format view names with schema prefix to match old error format+ var viewNames []string+ for _, v := range dependentViews {+ viewNames = append(viewNames, fmt.Sprintf("%q.%q", schema.GetProto().Name, v))+ }l.setError(&WalkThroughError{Code: code.ColumnIsReferencedByView,- Content: fmt.Sprintf("Cannot drop column %q in table %q.%q, it's referenced by view: %s", column.name, schema.name, table.name, strings.Join(viewList, ", ")),+ 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, ", ")),})return}-- // Drop the constraints and indexes involving the column.+ // Drop the constraints and indexes involving the columnvar dropIndexList []string-- for _, index := range table.indexSet {- for _, key := range index.expressionList {+ for _, index := range table.GetProto().Indexes {+ for _, key := range index.Expressions {// TODO(zp): deal with expression key.if key == columnName {- dropIndexList = append(dropIndexList, index.name)+ dropIndexList = append(dropIndexList, index.Name)break // Once we find the column in this index, mark for deletion and move to next index}}}for _, indexName := range dropIndexList {- delete(table.indexSet, indexName)+ if err := table.DropIndex(indexName); err != nil {+ l.setError(&WalkThroughError{Code: code.IndexNotExists, Content: err.Error()})+ return+ }}-// TODO(zp): deal with other constraints.-// TODO(zp): deal with CASCADE.-- // Delete the column- delete(table.columnSet, columnName)-}--// alterTableAlterColumnType handles ALTER COLUMN TYPE command.-func (l *pgCatalogListener) alterTableAlterColumnType(schema *SchemaState, table *TableState, columnName string, typeString string) {- column, err := table.GetColumn(columnName)- if err != nil {- l.setError(err)+ // Validate column exists before dropping+ if table.GetColumn(columnName) == nil {+ l.setError(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)})+ }+}- // Check if column is referenced by any views- viewList, viewErr := l.databaseState.existedViewList(column.dependencyView)- if viewErr != nil {- l.setError(&WalkThroughError{- Code: code.Internal,- Content: fmt.Sprintf("Failed to check view dependency: %v", viewErr),- })+// alterTableAlterColumnType handles ALTER COLUMN TYPE command.+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))return}- if len(viewList) > 0 {+ // Check if any views depend on this column+ dependentViews := schema.GetDependentViews(table.GetProto().Name, columnName)+ if len(dependentViews) > 0 {+ // Format view names with schema prefix to match old error format+ var viewNames []string+ for _, v := range dependentViews {+ viewNames = append(viewNames, fmt.Sprintf("%q.%q", schema.GetProto().Name, v))+ }l.setError(&WalkThroughError{Code: code.ColumnIsReferencedByView,- Content: fmt.Sprintf("Cannot alter type of column %q in table %q.%q, it's referenced by view: %s", column.name, schema.name, table.name, strings.Join(viewList, ", ")),+ 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, ", ")),})return}-// Update column type- column.columnType = typeString+ column.Type = typeString}// alterTableAddColumn handles ADD COLUMN command.-func (l *pgCatalogListener) alterTableAddColumn(schema *SchemaState, table *TableState, columndef parser.IColumnDefContext, ifNotExists bool) {+func (l *pgCatalogListener) alterTableAddColumn(schema *model.SchemaMetadata, table *model.TableMetadata, columndef parser.IColumnDefContext, ifNotExists bool) {if columndef == nil {return}-columnName := pgparser.NormalizePostgreSQLColid(columndef.Colid())-// Check if column already exists- if _, exists := table.columnSet[columnName]; exists {+ if table.GetColumn(columnName) != nil {if ifNotExists {return}l.setError(&WalkThroughError{Code: code.ColumnExists,- Content: fmt.Sprintf("The column %q already exists in table %q", columnName, table.name),+ Content: fmt.Sprintf("The column %q already exists in table %q", columnName, table.GetProto().Name),})return}-- // Get position for new column- pos := len(table.columnSet) + 1-// Extract column typevar typeString stringif columndef.Typename() != nil {typeString = extractTypeName(columndef.Typename())}-- // Create column state- columnState := &ColumnState{- name: columnName,- position: pos,- nullable: true,- columnType: typeString,- defaultValue: "",- }- table.columnSet[columnName] = columnState-+ // Create column metadata+ col := &storepb.ColumnMetadata{+ Name: columnName,+ Position: int32(len(table.GetColumns()) + 1),+ Nullable: true,+ Type: typeString,+ Default: "",+ }// Process column constraints if any (inline processing like in createColumn)if columndef.Colquallist() != nil {allQuals := columndef.Colquallist().AllColconstraint()@@ -777,20 +703,17 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *SchemaState, table *Tablcontinue}elem := qual.Colconstraintelem()-// Handle NOT NULLif elem.NOT() != nil && elem.NULL_P() != nil {- columnState.nullable = false+ col.Nullable = false}-// Handle DEFAULTif elem.DEFAULT() != nil {if elem.B_expr() != nil {defaultValue := elem.B_expr().GetText()- columnState.defaultValue = defaultValue+ col.Default = defaultValue}}-// Handle UNIQUE - creates an indexif elem.UNIQUE() != nil && (elem.PRIMARY() == nil || elem.KEY() == nil) {var constraintName string@@ -798,25 +721,25 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *SchemaState, table *TablconstraintName = pgparser.NormalizePostgreSQLName(qual.Name())}if constraintName == "" {- constraintName = generateIndexName(table.name, []string{columnName}, true)+ constraintName = generateIndexName(table.GetProto().Name, []string{columnName}, true)}// Check for collision- if _, exists := schema.identifierMap[constraintName]; exists {- constraintName = generateUniqueIndexName(schema, table.name, []string{columnName}, true)+ if table.GetIndex(constraintName) != nil {+ constraintName = generateUniqueIndexName(schema, table.GetProto().Name, []string{columnName}, true)}// Create index- index := &IndexState{- name: constraintName,- expressionList: []string{columnName},- indexType: "btree",- unique: true,- primary: false,- isConstraint: true,+ index := &storepb.IndexMetadata{+ Name: constraintName,+ Expressions: []string{columnName},+ Type: "btree",+ Unique: true,+ Primary: false,+ }+ if err := table.CreateIndex(index); err != nil {+ l.setError(&WalkThroughError{Code: code.IndexExists, Content: err.Error()})+ return}- table.indexSet[index.name] = index- schema.identifierMap[index.name] = true}-// Handle PRIMARY KEY - creates an indexif (elem.PRIMARY() != nil && elem.KEY() != nil) || (elem.UNIQUE() != nil && elem.PRIMARY() != nil) {var constraintName string@@ -824,36 +747,41 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *SchemaState, table *TablconstraintName = pgparser.NormalizePostgreSQLName(qual.Name())}if constraintName == "" {- constraintName = schema.pgGeneratePrimaryKeyName(table.name)+ constraintName = pgGeneratePrimaryKeyName(schema, table.GetProto().Name)}// Check for collision- if _, exists := schema.identifierMap[constraintName]; exists {- l.setError(NewRelationExistsError(constraintName, schema.name))+ if table.GetIndex(constraintName) != nil {+ l.setError(NewRelationExistsError(constraintName, schema.GetProto().Name))return}- columnState.nullable = false+ col.Nullable = false// Create primary key index- index := &IndexState{- name: constraintName,- expressionList: []string{columnName},- indexType: "btree",- unique: true,- primary: true,- isConstraint: true,+ index := &storepb.IndexMetadata{+ Name: constraintName,+ Expressions: []string{columnName},+ Type: "btree",+ Unique: true,+ Primary: true,+ IsConstraint: true,+ }+ if err := table.CreateIndex(index); err != nil {+ l.setError(&WalkThroughError{Code: code.PrimaryKeyExists, Content: err.Error()})+ return}- table.indexSet[index.name] = index- schema.identifierMap[index.name] = true}}}+ // Create the column+ if err := table.CreateColumn(col); err != nil {+ l.setError(&WalkThroughError{Code: code.ColumnExists, Content: err.Error()})+ }}// alterTableAddConstraint handles ADD CONSTRAINT command.-func (l *pgCatalogListener) alterTableAddConstraint(schema *SchemaState, table *TableState, constraint parser.ITableconstraintContext) {+func (l *pgCatalogListener) alterTableAddConstraint(schema *model.SchemaMetadata, table *model.TableMetadata, constraint parser.ITableconstraintContext) {if constraint == nil {return}-// Reuse the constraint creation logic from CREATE TABLEerr := createTableConstraint(schema, table, constraint)if err != nil {@@ -862,158 +790,129 @@ func (l *pgCatalogListener) alterTableAddConstraint(schema *SchemaState, table *}// alterTableDropConstraint handles DROP CONSTRAINT command.-func (l *pgCatalogListener) alterTableDropConstraint(schema *SchemaState, table *TableState, constraintName string, ifExists bool) {+func (l *pgCatalogListener) alterTableDropConstraint(_ *model.SchemaMetadata, table *model.TableMetadata, constraintName string, ifExists bool) {// Check if constraint exists as an index- if index, exists := table.indexSet[constraintName]; exists {- delete(schema.identifierMap, index.name)- delete(table.indexSet, index.name)+ if table.GetIndex(constraintName) != nil {+ if err := table.DropIndex(constraintName); err != nil {+ l.setError(&WalkThroughError{Code: code.IndexNotExists, Content: err.Error()})+ }return}-if !ifExists {l.setError(&WalkThroughError{Code: code.ConstraintNotExists,- Content: fmt.Sprintf("Constraint %q for table %q does not exist", constraintName, table.name),+ Content: fmt.Sprintf("Constraint %q for table %q does not exist", constraintName, table.GetProto().Name),})}}// alterTableSetDefault handles ALTER COLUMN SET DEFAULT command.-func (l *pgCatalogListener) alterTableSetDefault(table *TableState, columnName string, defaultValue string) {- column, err := table.GetColumn(columnName)- if err != nil {- l.setError(err)+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))return}-- column.defaultValue = defaultValue+ column.Default = defaultValue}// alterTableDropDefault handles ALTER COLUMN DROP DEFAULT command.-func (l *pgCatalogListener) alterTableDropDefault(table *TableState, columnName string) {- column, err := table.GetColumn(columnName)- if err != nil {- l.setError(err)+func (l *pgCatalogListener) alterTableDropDefault(table *model.TableMetadata, columnName string) {+ column := table.GetColumn(columnName)+ if column == nil {+ l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))return}-- column.defaultValue = ""+ column.Default = ""}// alterTableSetNotNull handles ALTER COLUMN SET NOT NULL command.-func (l *pgCatalogListener) alterTableSetNotNull(table *TableState, columnName string) {- column, err := table.GetColumn(columnName)- if err != nil {- l.setError(err)+func (l *pgCatalogListener) alterTableSetNotNull(table *model.TableMetadata, columnName string) {+ column := table.GetColumn(columnName)+ if column == nil {+ l.setError(NewColumnNotExistsError(table.GetProto().Name, columnName))return}-- column.nullable = false+ column.Nullable = false}// renameTable handles RENAME TO for tables.-func (*pgCatalogListener) pgRenameTable(schema *SchemaState, table *TableState, newName string) *WalkThroughError {+func (*pgCatalogListener) pgRenameTable(schema *model.SchemaMetadata, table *model.TableMetadata, newName string) *WalkThroughError {// Check if new name already exists- if _, exists := schema.identifierMap[newName]; exists {- return NewRelationExistsError(newName, schema.name)+ if schema.GetTable(newName) != nil {+ return 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()}}-- // Remove old name from maps- delete(schema.identifierMap, table.name)- delete(schema.tableSet, table.name)-- // Update table name- table.name = newName-- // Add new name to maps- schema.identifierMap[table.name] = true- schema.tableSet[table.name] = table-return nil}// renameColumn handles RENAME COLUMN.-func (*pgCatalogListener) renameColumn(table *TableState, oldName string, newName string) *WalkThroughError {- column, err := table.GetColumn(oldName)- if err != nil {- return err- }-+func (*pgCatalogListener) renameColumn(table *model.TableMetadata, oldName string, newName string) *WalkThroughError {if oldName == newName {return nil}-- // Check if new name already exists- if _, exists := table.columnSet[newName]; exists {+ // Validate old column exists+ if table.GetColumn(oldName) == nil {+ return NewColumnNotExistsError(table.GetProto().Name, oldName)+ }+ // Validate new column doesn't already exist+ if table.GetColumn(newName) != nil {return &WalkThroughError{Code: code.ColumnExists,- Content: fmt.Sprintf("The column %q already exists in table %q", newName, table.name),+ 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)}+ }// Rename column in all indexes that reference it- for _, index := range table.indexSet {- for i, key := range index.expressionList {+ for _, index := range table.GetProto().Indexes {+ for i, key := range index.Expressions {if key == oldName {- index.expressionList[i] = newName+ index.Expressions[i] = newName}}}-- // Update column name- delete(table.columnSet, column.name)- column.name = newName- table.columnSet[column.name] = column-return nil}// renameConstraint handles RENAME CONSTRAINT.-func (*pgCatalogListener) renameConstraint(schema *SchemaState, table *TableState, oldName string, newName string) *WalkThroughError {- index, exists := table.indexSet[oldName]- if !exists {+func (*pgCatalogListener) renameConstraint(schema *model.SchemaMetadata, table *model.TableMetadata, oldName string, newName string) *WalkThroughError {+ index := table.GetIndex(oldName)+ if index == nil {// We haven't dealt with foreign and check constraints, so skip if not existsreturn nil}-// Check if new name already exists- if _, exists := schema.identifierMap[newName]; exists {- return NewRelationExistsError(newName, schema.name)+ if table.GetIndex(newName) != nil {+ return 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()}}-- // Remove old name from maps- delete(schema.identifierMap, index.name)- delete(table.indexSet, index.name)-- // Update index name- index.name = newName-- // Add new name to maps- schema.identifierMap[index.name] = true- table.indexSet[index.name] = index-return nil}// ========================================// DROP statements handling// ========================================-// EnterDropstmt handles DROP TABLE/VIEW/INDEX statements.func (l *pgCatalogListener) EnterDropstmt(ctx *parser.DropstmtContext) {if !isTopLevel(ctx.GetParent()) || l.err != nil {return}-l.currentLine = ctx.GetStart().GetLine()-// Check IF EXISTSifExists := ctx.IF_P() != nil && ctx.EXISTS() != nil-// Check object type and get list of namesif ctx.Object_type_any_name() != nil {objType := ctx.Object_type_any_name()-if objType.TABLE() != nil {// DROP TABLEif ctx.Any_name_list() != nil {@@ -1061,7 +960,6 @@ func (l *pgCatalogListener) EnterDropstmt(ctx *parser.DropstmtContext) {// ========================================// DROP DATABASE handling// ========================================-// EnterDropdbstmt handles DROP DATABASE statements.// PostgreSQL does not allow dropping the currently connected database.// Walk-through also disallows DROP DATABASE for other databases as it's out of scope.@@ -1069,36 +967,29 @@ func (l *pgCatalogListener) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {if !isTopLevel(ctx.GetParent()) || l.err != nil {return}-l.currentLine = ctx.GetStart().GetLine()-// Extract database nameif ctx.Name() == nil {return}-databaseName := pgparser.NormalizePostgreSQLName(ctx.Name())-// PostgreSQL does not allow dropping the currently open database.// This matches the real PostgreSQL behavior: "ERROR: cannot drop the currently open database"- if l.databaseState.isCurrentDatabase(databaseName) {+ if isCurrentDatabase(l.databaseState, databaseName) {l.setError(&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.name, databaseName))+ l.setError(NewAccessOtherDatabaseError(l.databaseState.DatabaseName(), databaseName))}-func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExists bool) *WalkThroughError {parts := pgparser.NormalizePostgreSQLAnyName(anyName)if len(parts) == 0 {return nil}-var schemaName, tableName stringif len(parts) == 1 {schemaName = ""@@ -1107,82 +998,71 @@ func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExistsschemaName = parts[0]tableName = parts[1]}-- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {if ifExists {return nil}return err}-- table, err := schema.GetTable(tableName)- if err != nil {+ table := schema.GetTable(tableName)+ if table == nil {if ifExists {return nil}- return err- }-- // Check for view dependencies- viewList, viewErr := l.databaseState.existedViewList(table.dependencyView)- if viewErr != nil {- return &WalkThroughError{- Code: code.Internal,- Content: fmt.Sprintf("Failed to check view dependency: %v", viewErr),+ return NewTableNotExistsError(tableName)+ }+ // Check if any views depend on this table+ dependentViews := schema.GetDependentViews(tableName, "")+ if len(dependentViews) > 0 {+ // Format view names with schema prefix to match old error format+ var viewNames []string+ for _, v := range dependentViews {+ viewNames = append(viewNames, fmt.Sprintf("%q.%q", schema.GetProto().Name, v))}- }- if len(viewList) > 0 {return &WalkThroughError{Code: code.TableIsReferencedByView,- Content: fmt.Sprintf("Cannot drop table %q.%q, it's referenced by view: %s", schema.name, table.name, strings.Join(viewList, ", ")),+ Content: fmt.Sprintf("Cannot drop table %q.%q, it's referenced by view: %s", schema.GetProto().Name, tableName, strings.Join(viewNames, ", ")),}}-- // Delete all indexes associated with the table- for indexName := range table.indexSet {- delete(schema.identifierMap, indexName)+ // Drop the table using the schema method+ if err := schema.DropTable(tableName); err != nil {+ return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}-- delete(schema.identifierMap, table.name)- delete(schema.tableSet, table.name)return nil}-func (l *pgCatalogListener) dropView(anyName parser.IAny_nameContext, ifExists bool) *WalkThroughError {parts := pgparser.NormalizePostgreSQLAnyName(anyName)if len(parts) == 0 {return nil}-var schemaName, viewName string- if len(parts) == 1 {- schemaName = ""+ switch len(parts) {+ case 1:viewName = parts[0]- } else {+ case 2:schemaName = parts[0]viewName = parts[1]+ default:+ return nil}-- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {- if ifExists {- return nil- }return err}-- delete(schema.identifierMap, viewName)- delete(schema.viewSet, viewName)+ // Try to drop the view+ if dropErr := schema.DropView(viewName); dropErr != nil {+ if !ifExists {+ return &WalkThroughError{Code: code.ViewNotExists, Content: dropErr.Error()}+ }+ }return nil}-func (l *pgCatalogListener) dropIndex(anyName parser.IAny_nameContext, ifExists bool) *WalkThroughError {parts := pgparser.NormalizePostgreSQLAnyName(anyName)if len(parts) == 0 {return nil}-var schemaName, indexName stringif len(parts) == 1 {schemaName = ""@@ -1191,33 +1071,30 @@ func (l *pgCatalogListener) dropIndex(anyName parser.IAny_nameContext, ifExistsschemaName = parts[0]indexName = parts[1]}-- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {if ifExists {return nil}return err}-- table, index, err := schema.getIndex(indexName)+ table, index, err := getIndexFromSchema(schema, indexName)if err != nil {if ifExists {return nil}return err}-- delete(schema.identifierMap, index.name)- delete(table.indexSet, index.name)+ // Drop the index from the table+ if err := table.DropIndex(index.GetProto().Name); err != nil {+ return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ }return nil}-func (l *pgCatalogListener) dropSchema(schemaNameCtx parser.INameContext, ifExists bool) *WalkThroughError {schemaName := pgparser.NormalizePostgreSQLName(schemaNameCtx)-- schema, exists := l.databaseState.schemaSet[schemaName]- if !exists {+ schema := l.databaseState.GetSchema(schemaName)+ if schema == nil {if ifExists {return nil}@@ -1226,64 +1103,58 @@ func (l *pgCatalogListener) dropSchema(schemaNameCtx parser.INameContext, ifExisContent: fmt.Sprintf("Schema %q does not exist", schemaName),}}-- // Delete all identifiers in this schema- for tableName := range schema.tableSet {- delete(schema.identifierMap, tableName)- }- for viewName := range schema.viewSet {- delete(schema.identifierMap, viewName)+ // Drop the schema (this will also drop all objects in the schema)+ // 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()}}-- // Delete the schema- delete(l.databaseState.schemaSet, schemaName)return nil}// TODO: EnterDropindexstmt - Need to find correct ANTLR context name-// func (l *pgCatalogListener) EnterDropindexstmt(ctx *parser.DropIndexContext) {-// if !isTopLevel(ctx.GetParent()) || l.err != nil {-// return-// }//-// if !l.checkDatabaseNotDeleted() {-// return-// }+// func (l *pgCatalogListener) EnterDropindexstmt(ctx *parser.DropIndexContext) {+// if !isTopLevel(ctx.GetParent()) || l.err != nil {+// return+// }//-// l.currentLine = ctx.GetStart().GetLine()+// if !l.checkDatabaseNotDeleted() {+// return+// }+//+// l.currentLine = ctx.GetStart().GetLine()+//+// // TODO: Implement DROP INDEX logic+// // Similar to pgDropIndexList() in walk_through_for_pg.go+// }//-// // TODO: Implement DROP INDEX logic-// // Similar to pgDropIndexList() in walk_through_for_pg.go-// }-// TODO: EnterDropschemastatement - Need to find correct ANTLR context name-// func (l *pgCatalogListener) EnterDropschemastatement(ctx *parser.DropschemaContext) {-// if !isTopLevel(ctx.GetParent()) || l.err != nil {-// return-// }//-// if !l.checkDatabaseNotDeleted() {-// return-// }+// func (l *pgCatalogListener) EnterDropschemastatement(ctx *parser.DropschemaContext) {+// if !isTopLevel(ctx.GetParent()) || l.err != nil {+// return+// }//-// l.currentLine = ctx.GetStart().GetLine()+// if !l.checkDatabaseNotDeleted() {+// return+// }+//+// l.currentLine = ctx.GetStart().GetLine()+//+// // TODO: Implement DROP SCHEMA logic+// // Similar to pgDropSchema() in walk_through_for_pg.go+// }//-// // TODO: Implement DROP SCHEMA logic-// // Similar to pgDropSchema() in walk_through_for_pg.go-// }-// ========================================// RENAME statements handling// ========================================-// EnterRenamestmt handles RENAME INDEX/CONSTRAINT/TABLE/COLUMN statements.func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {if !isTopLevel(ctx.GetParent()) || l.err != nil {return}-l.currentLine = ctx.GetStart().GetLine()-// Check if this is INDEX rename (ALTER INDEX ... RENAME TO ...)if ctx.INDEX() != nil {// ALTER INDEX index_name RENAME TO new_name@@ -1291,49 +1162,54 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {indexName := extractTableName(ctx.Qualified_name())schemaName := extractSchemaName(ctx.Qualified_name())newName := pgparser.NormalizePostgreSQLName(ctx.AllName()[0])-- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {l.setError(err)return}-// Find the index across all tables- var foundIndex *IndexState- var foundTable *TableState- for _, table := range schema.tableSet {- if index, exists := table.indexSet[indexName]; exists {- foundIndex = index- foundTable = table- break- }- }-- if foundIndex == nil {+ foundTable, _, err := getIndexFromSchema(schema, indexName)+ if err != nil {// Index not found, silently ignore (PostgreSQL behavior)return}-if err := l.renameConstraint(schema, foundTable, indexName, newName); err != nil {l.setError(err)}}return}-+ // Check if this is VIEW rename (ALTER VIEW ... RENAME TO ...)+ if ctx.Qualified_name() != nil && ctx.AllName() != nil && len(ctx.AllName()) > 0 {+ // Could be ALTER VIEW view_name RENAME TO new_name+ // Try to see if the qualified name refers to a view+ viewName := extractTableName(ctx.Qualified_name())+ schemaName := extractSchemaName(ctx.Qualified_name())+ newName := pgparser.NormalizePostgreSQLName(ctx.AllName()[0])+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)+ if err != nil {+ l.setError(err)+ return+ }+ // 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()})+ }+ return+ }+ }// Extract relation (table) if presentvar tableName, schemaName stringif ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {tableName = extractTableName(ctx.Relation_expr().Qualified_name())schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())}-- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {l.setError(err)return}-// Check if this is column renameif ctx.Opt_column() != nil {// RENAME COLUMN: ALTER TABLE table RENAME COLUMN oldname TO newname@@ -1342,20 +1218,17 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {if len(allNames) >= 2 && tableName != "" {oldName := pgparser.NormalizePostgreSQLName(allNames[0])newName := pgparser.NormalizePostgreSQLName(allNames[1])-- table, err := schema.GetTable(tableName)- if err != nil {- l.setError(err)+ table := schema.GetTable(tableName)+ if table == nil {+ l.setError(NewTableNotExistsError(tableName))return}-if err := l.renameColumn(table, oldName, newName); err != nil {l.setError(err)}}return}-// Check if this is constraint renameif ctx.CONSTRAINT() != nil && tableName != "" {// RENAME CONSTRAINT: ALTER TABLE table RENAME CONSTRAINT oldname TO newname@@ -1363,30 +1236,25 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {if len(allNames) >= 2 {oldName := pgparser.NormalizePostgreSQLName(allNames[0])newName := pgparser.NormalizePostgreSQLName(allNames[1])-- table, err := schema.GetTable(tableName)- if err != nil {- l.setError(err)+ table := schema.GetTable(tableName)+ if table == nil {+ l.setError(NewTableNotExistsError(tableName))return}-if err := l.renameConstraint(schema, table, oldName, newName); err != nil {l.setError(err)}}return}-// Otherwise it's table rename: ALTER TABLE oldname RENAME TO newnameif tableName != "" && ctx.AllName() != nil && len(ctx.AllName()) > 0 {newName := pgparser.NormalizePostgreSQLName(ctx.AllName()[0])-- table, err := schema.GetTable(tableName)- if err != nil {- l.setError(err)+ table := schema.GetTable(tableName)+ if table == nil {+ l.setError(NewTableNotExistsError(tableName))return}-if err := l.pgRenameTable(schema, table, newName); err != nil {l.setError(err)}@@ -1397,62 +1265,59 @@ func (l *pgCatalogListener) EnterRenamestmt(ctx *parser.RenamestmtContext) {// ========================================// CREATE VIEW handling// ========================================-// EnterViewstmt handles CREATE VIEW statements.func (l *pgCatalogListener) EnterViewstmt(ctx *parser.ViewstmtContext) {if !isTopLevel(ctx.GetParent()) || l.err != nil {return}-l.currentLine = ctx.GetStart().GetLine()-// Extract view nameif ctx.Qualified_name() == nil {return}-viewName := extractTableName(ctx.Qualified_name())schemaName := extractSchemaName(ctx.Qualified_name())databaseName := extractDatabaseName(ctx.Qualified_name())-// Check if accessing other database- if databaseName != "" && l.databaseState.name != databaseName {+ if databaseName != "" && l.databaseState.DatabaseName() != databaseName {l.setError(&WalkThroughError{Code: code.NotCurrentDatabase,- Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.name),+ Content: fmt.Sprintf("Database %q is not the current database %q", databaseName, l.databaseState.DatabaseName()),})return}-- schema, err := l.databaseState.getOrCreatePublicSchema(schemaName)+ schema, err := getOrCreatePublicSchema(l.databaseState, schemaName)if err != nil {l.setError(err)return}-- // Check if view already exists - currently we don't check views- // This matches the legacy behavior in walk_through_for_pg.go:619-622- if _, exists := schema.viewSet[viewName]; exists {+ // Check if view already exists - silently ignore duplicates+ // This matches the legacy behavior in the old DatabaseState implementation+ if schema.GetView(viewName) != nil {return}-- // Create view state- view := &ViewState{- name: viewName,+ // Get the view definition (the SELECT statement)+ // We don't parse the dependencies yet - that would require full SQL analysis+ // For now, create the view with empty dependency list+ definition := ""+ if ctx.Selectstmt() != nil {+ definition = ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx.Selectstmt())+ }+ // Create the view+ _, createErr := schema.CreateView(viewName, definition, nil)+ if createErr != nil {+ l.setError(&WalkThroughError{Code: code.ViewExists, Content: createErr.Error()})}- schema.viewSet[view.name] = view}// ========================================// Helper functions// ========================================-// isTopLevel checks if the context is at the top level (not nested).func isTopLevel(ctx antlr.Tree) bool {if ctx == nil {return true}-switch ctx := ctx.(type) {case *parser.RootContext, *parser.StmtblockContext:return true@@ -1471,11 +1336,9 @@ func extractTypeName(typename parser.ITypenameContext) string {if typename == nil {return ""}-// Use GetText() to get the full type string// The parser should have already normalized type namestypeText := typename.GetText()-// Normalize common PostgreSQL type aliasesswitch strings.ToLower(typeText) {case "int", "int4":@@ -1501,7 +1364,6 @@ func extractTableName(qualifiedName parser.IQualified_nameContext) string {if qualifiedName == nil {return ""}-parts := pgparser.NormalizePostgreSQLQualifiedName(qualifiedName)if len(parts) == 0 {return ""@@ -1518,7 +1380,6 @@ func extractSchemaName(qualifiedName parser.IQualified_nameContext) string {if qualifiedName == nil {return ""}-parts := pgparser.NormalizePostgreSQLQualifiedName(qualifiedName)switch len(parts) {case 1:@@ -1542,7 +1403,6 @@ func extractDatabaseName(qualifiedName parser.IQualified_nameContext) string {if qualifiedName == nil {return ""}-parts := pgparser.NormalizePostgreSQLQualifiedName(qualifiedName)if len(parts) == 3 {// db.schema.table@@ -1556,7 +1416,6 @@ func extractDatabaseName(qualifiedName parser.IQualified_nameContext) string {func generateIndexName(tableName string, columnList []string, _ bool) string {var builder strings.Builderbuilder.WriteString(tableName)-expressionID := 0for _, col := range columnList {builder.WriteByte('_')@@ -1570,25 +1429,82 @@ func generateIndexName(tableName string, columnList []string, _ bool) string {builder.WriteString(col)}}-builder.WriteString("_idx")-return builder.String()}// generateUniqueIndexName generates a unique index name by adding numeric suffixes.// Tries name1, name2, name3, etc. until finding an available name.-func generateUniqueIndexName(schema *SchemaState, tableName string, columnList []string, isUnique bool) string {+func generateUniqueIndexName(schema *model.SchemaMetadata, tableName string, columnList []string, isUnique bool) string {baseName := generateIndexName(tableName, columnList, isUnique)-// Try with numeric suffixes starting from 1for i := 1; i < 1000; i++ {candidateName := fmt.Sprintf("%s%d", baseName, i)- if _, exists := schema.identifierMap[candidateName]; !exists {+ // Check if index exists in the schema+ if schema.GetIndex(candidateName) == nil {return candidateName}}-// Fallback (should never reach here)return fmt.Sprintf("%s_collision", baseName)}++// pgGeneratePrimaryKeyName generates a primary key name following PostgreSQL conventions.+// Uses the pattern "{tableName}_pkey" and adds numeric suffixes if there are collisions.+func pgGeneratePrimaryKeyName(schema *model.SchemaMetadata, tableName string) string {+ pkName := fmt.Sprintf("%s_pkey", tableName)+ // For PostgreSQL, check if the index name already exists in the schema+ if schema.GetIndex(pkName) == nil {+ return pkName+ }+ suffix := 1+ for {+ candidateName := fmt.Sprintf("%s%d", pkName, suffix)+ if schema.GetIndex(candidateName) == nil {+ return candidateName+ }+ suffix+++ }+}++// 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) {+ if schemaName == "" {+ schemaName = publicSchemaName+ }+ schema := d.GetSchema(schemaName)+ if schema != nil {+ return schema, nil+ }+ // Only auto-create the "public" schema+ if schemaName != publicSchemaName {+ return nil, &WalkThroughError{+ Code: code.SchemaNotExists,+ Content: fmt.Sprintf("The schema %q doesn't exist", schemaName),+ }+ }+ 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) {+ // For PostgreSQL, index names are unique within a schema+ index := s.GetIndex(indexName)+ if index == nil {+ return nil, nil, &WalkThroughError{+ Code: code.IndexNotExists,+ Content: fmt.Sprintf("Index %q does not exist in schema %q", indexName, s.GetProto().Name),+ }+ }+ // Find the table that owns this index+ table := s.GetTable(index.GetTableProto().Name)+ if table == nil {+ return nil, nil, &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+}diff --git a/backend/plugin/advisor/catalog/walk_through_for_tidb.go b/backend/plugin/advisor/catalog/walk_through_for_tidb.goindex 74a5506470..b8f261edd6 100644--- a/backend/plugin/advisor/catalog/walk_through_for_tidb.go+++ b/backend/plugin/advisor/catalog/walk_through_for_tidb.go@@ -2,6 +2,7 @@ package catalogimport ("fmt"+ "slices""strings"tidbast "github.com/pingcap/tidb/pkg/parser/ast"@@ -9,16 +10,19 @@ import ("github.com/pingcap/tidb/pkg/parser/mysql""github.com/pingcap/tidb/pkg/types""github.com/pkg/errors"+ "google.golang.org/protobuf/proto"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor/code"+ "github.com/bytebase/bytebase/backend/store/model")// TiDBWalkThrough walks through TiDB AST and updates the database state.-func TiDBWalkThrough(d *DatabaseState, ast any) error {+func TiDBWalkThrough(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.- if !d.HasSchema("") {+ if d.GetSchema("") == nil {d.CreateSchema("")}@@ -28,7 +32,7 @@ func TiDBWalkThrough(d *DatabaseState, ast any) error {}for _, node := range nodeList {// change state- if err := d.changeState(node); err != nil {+ if err := changeStateTiDB(d, node); err != nil {return err}}@@ -36,7 +40,7 @@ func TiDBWalkThrough(d *DatabaseState, ast any) error {return nil}-func (d *DatabaseState) changeState(in tidbast.StmtNode) (err *WalkThroughError) {+func changeStateTiDB(d *model.DatabaseMetadata, in tidbast.StmtNode) (err *WalkThroughError) {defer func() {if err == nil {return@@ -45,115 +49,112 @@ func (d *DatabaseState) changeState(in tidbast.StmtNode) (err *WalkThroughError)err.Line = in.OriginTextPosition()}}()- if d.IsDeleted() {- return &WalkThroughError{- Code: code.DatabaseIsDeleted,- Content: fmt.Sprintf("Database `%s` is deleted", d.name),- }- }+ // Note: removed database deleted check as it's not stored in protobufswitch node := in.(type) {case *tidbast.CreateTableStmt:- return d.createTable(node)+ return tidbCreateTable(d, node)case *tidbast.DropTableStmt:- return d.dropTable(node)+ return tidbDropTable(d, node)case *tidbast.AlterTableStmt:- return d.alterTable(node)+ return tidbAlterTable(d, node)case *tidbast.CreateIndexStmt:- return d.tidbHandleCreateIndex(node)+ return tidbHandleCreateIndex(d, node)case *tidbast.DropIndexStmt:- return d.dropIndex(node)+ return tidbDropIndex(d, node)case *tidbast.AlterDatabaseStmt:- return d.alterDatabase(node)+ return tidbAlterDatabase(d, node)case *tidbast.DropDatabaseStmt:- return d.dropDatabase(node)+ return tidbDropDatabase(d, node)case *tidbast.CreateDatabaseStmt:- return NewAccessOtherDatabaseError(d.name, node.Name.O)+ return NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)case *tidbast.RenameTableStmt:- return d.tidbRenameTable(node)+ return tidbRenameTable(d, node)default:return nil}}-func (d *DatabaseState) tidbRenameTable(node *tidbast.RenameTableStmt) *WalkThroughError {+func tidbRenameTable(d *model.DatabaseMetadata, node *tidbast.RenameTableStmt) *WalkThroughError {for _, tableToTable := range node.TableToTables {- schema, exists := d.schemaSet[""]- if !exists {+ schema := d.GetSchema("")+ if schema == nil {schema = d.CreateSchema("")}oldTableName := tableToTable.OldTable.Name.OnewTableName := tableToTable.NewTable.Name.O- if d.theCurrentDatabase(tableToTable) {- if compareIdentifier(oldTableName, newTableName, d.ignoreCaseSensitive) {+ if tidbTheCurrentDatabase(d, tableToTable) {+ if strings.EqualFold(oldTableName, newTableName) {return nil}- table, exists := mysqlGetTable(schema, oldTableName)- if !exists {+ table := schema.GetTable(oldTableName)+ if table == nil {return NewTableNotExistsError(oldTableName)}- if _, exists := mysqlGetTable(schema, newTableName); exists {+ if schema.GetTable(newTableName) != nil {return NewTableExistsError(newTableName)}- delete(schema.tableSet, table.name)- table.name = newTableName- schema.tableSet[table.name] = table- } else if d.moveToOtherDatabase(tableToTable) {- _, exists := mysqlGetTable(schema, tableToTable.OldTable.Name.O)- if !exists {+ if err := schema.RenameTable(table.GetProto().Name, newTableName); err != nil {+ return &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)}- delete(schema.tableSet, tableToTable.OldTable.Name.O)+ if err := schema.DropTable(tableToTable.OldTable.Name.O); err != nil {+ return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ }} else {- return NewAccessOtherDatabaseError(d.name, d.targetDatabase(tableToTable))+ return NewAccessOtherDatabaseError(d.GetProto().Name, tidbTargetDatabase(d, tableToTable))}}return nil}-func (d *DatabaseState) targetDatabase(node *tidbast.TableToTable) string {- if node.OldTable.Schema.O != "" && !d.isCurrentDatabase(node.OldTable.Schema.O) {+func tidbTargetDatabase(d *model.DatabaseMetadata, node *tidbast.TableToTable) string {+ if node.OldTable.Schema.O != "" && !isCurrentDatabase(d, node.OldTable.Schema.O) {return node.OldTable.Schema.O}return node.NewTable.Schema.O}-func (d *DatabaseState) moveToOtherDatabase(node *tidbast.TableToTable) bool {- if node.OldTable.Schema.O != "" && !d.isCurrentDatabase(node.OldTable.Schema.O) {+func tidbMoveToOtherDatabase(d *model.DatabaseMetadata, node *tidbast.TableToTable) bool {+ if node.OldTable.Schema.O != "" && !isCurrentDatabase(d, node.OldTable.Schema.O) {return false}return node.OldTable.Schema.O != node.NewTable.Schema.O}-func (d *DatabaseState) theCurrentDatabase(node *tidbast.TableToTable) bool {- if node.NewTable.Schema.O != "" && !d.isCurrentDatabase(node.NewTable.Schema.O) {+func tidbTheCurrentDatabase(d *model.DatabaseMetadata, node *tidbast.TableToTable) bool {+ if node.NewTable.Schema.O != "" && !isCurrentDatabase(d, node.NewTable.Schema.O) {return false}- if node.OldTable.Schema.O != "" && !d.isCurrentDatabase(node.OldTable.Schema.O) {+ if node.OldTable.Schema.O != "" && !isCurrentDatabase(d, node.OldTable.Schema.O) {return false}return true}-func (d *DatabaseState) dropDatabase(node *tidbast.DropDatabaseStmt) *WalkThroughError {- if !d.isCurrentDatabase(node.Name.O) {- return NewAccessOtherDatabaseError(d.name, node.Name.O)+func tidbDropDatabase(d *model.DatabaseMetadata, node *tidbast.DropDatabaseStmt) *WalkThroughError {+ if !isCurrentDatabase(d, node.Name.O) {+ return NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)}- d.MarkDeleted()+ // Note: In walk-through, we don't need to actually delete the database metadata+ // The check is sufficient for validationreturn nil}-func (d *DatabaseState) alterDatabase(node *tidbast.AlterDatabaseStmt) *WalkThroughError {- if !node.AlterDefaultDatabase && !d.isCurrentDatabase(node.Name.O) {- return NewAccessOtherDatabaseError(d.name, node.Name.O)+func tidbAlterDatabase(d *model.DatabaseMetadata, node *tidbast.AlterDatabaseStmt) *WalkThroughError {+ if !node.AlterDefaultDatabase && !isCurrentDatabase(d, node.Name.O) {+ return NewAccessOtherDatabaseError(d.GetProto().Name, node.Name.O)}for _, option := range node.Options {switch option.Tp {case tidbast.DatabaseOptionCharset:- d.characterSet = option.Value+ d.GetProto().CharacterSet = option.Valuecase tidbast.DatabaseOptionCollate:- d.collation = option.Value+ d.GetProto().Collation = option.Valuedefault:// Other database options}@@ -161,35 +162,38 @@ func (d *DatabaseState) alterDatabase(node *tidbast.AlterDatabaseStmt) *WalkThroreturn nil}-func (d *DatabaseState) findTableState(tableName *tidbast.TableName) (*TableState, *WalkThroughError) {- if tableName.Schema.O != "" && !d.isCurrentDatabase(tableName.Schema.O) {- return nil, NewAccessOtherDatabaseError(d.name, tableName.Schema.O)+func tidbFindTableState(d *model.DatabaseMetadata, tableName *tidbast.TableName) (*model.TableMetadata, *WalkThroughError) {+ if tableName.Schema.O != "" && !isCurrentDatabase(d, tableName.Schema.O) {+ return nil, NewAccessOtherDatabaseError(d.GetProto().Name, tableName.Schema.O)}- schema, exists := d.schemaSet[""]- if !exists {+ schema := d.GetSchema("")+ if schema == nil {schema = d.CreateSchema("")}- table, exists := mysqlGetTable(schema, tableName.Name.O)- if !exists {+ table := schema.GetTable(tableName.Name.O)+ if table == nil {return nil, NewTableNotExistsError(tableName.Name.O)}return table, nil}-func (d *DatabaseState) dropIndex(node *tidbast.DropIndexStmt) *WalkThroughError {- table, err := d.findTableState(node.Table)+func tidbDropIndex(d *model.DatabaseMetadata, node *tidbast.DropIndexStmt) *WalkThroughError {+ table, err := tidbFindTableState(d, node.Table)if err != nil {return err}- return table.DropIndex(node.IndexName, nil)+ if err := table.DropIndex(node.IndexName); err != nil {+ return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}+ }+ return nil}-func (d *DatabaseState) tidbHandleCreateIndex(node *tidbast.CreateIndexStmt) *WalkThroughError {- table, err := d.findTableState(node.Table)+func tidbHandleCreateIndex(d *model.DatabaseMetadata, node *tidbast.CreateIndexStmt) *WalkThroughError {+ table, err := tidbFindTableState(d, node.Table)if err != nil {return err}@@ -211,16 +215,16 @@ func (d *DatabaseState) tidbHandleCreateIndex(node *tidbast.CreateIndexStmt) *Wa// Other index key types}- keyList, err := table.validateAndGetKeyStringList(node.IndexPartSpecifications, false /* primary */, isSpatial)+ keyList, err := tidbValidateAndGetKeyStringList(table, node.IndexPartSpecifications, false /* primary */, isSpatial)if err != nil {return err}- return table.tidbCreateIndex(node.IndexName, keyList, unique, tp, node.IndexOption)+ return tidbCreateIndexHelper(table, node.IndexName, keyList, unique, tp, node.IndexOption)}-func (d *DatabaseState) alterTable(node *tidbast.AlterTableStmt) *WalkThroughError {- table, err := d.findTableState(node.Table)+func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *WalkThroughError {+ table, err := tidbFindTableState(d, node.Table)if err != nil {return err}@@ -231,11 +235,11 @@ func (d *DatabaseState) alterTable(node *tidbast.AlterTableStmt) *WalkThroughErrfor _, option := range spec.Options {switch option.Tp {case tidbast.TableOptionCollate:- table.collation = option.StrValue+ table.GetProto().Collation = option.StrValuecase tidbast.TableOptionComment:- table.comment = option.StrValue+ table.GetProto().Comment = option.StrValuecase tidbast.TableOptionEngine:- table.engine = option.StrValue+ table.GetProto().Engine = option.StrValuedefault:// Other table options}@@ -246,61 +250,101 @@ func (d *DatabaseState) alterTable(node *tidbast.AlterTableStmt) *WalkThroughErrif len(spec.NewColumns) == 1 {pos = spec.Position}- if err := table.tidbCreateColumn(column, pos); err != nil {+ if err := tidbCreateColumnHelper(table, column, pos); err != nil {return err}}// MySQL can add table constraints in ALTER TABLE ADD COLUMN statements.for _, constraint := range spec.NewConstraints {- if err := table.createConstraint(constraint); err != nil {+ if err := tidbCreateConstraint(table, constraint); err != nil {return err}}+ // Sort and renumber columns after adding+ // CreateColumn appends to end, but tidbReorderColumn sets position values+ tableProto := table.GetProto()+ slices.SortFunc(tableProto.Columns, func(a, b *storepb.ColumnMetadata) int {+ if a.Position < b.Position {+ return -1+ } else if a.Position > b.Position {+ return 1+ }+ return 0+ })+ for i, col := range tableProto.Columns {+ col.Position = int32(i + 1)+ }case tidbast.AlterTableAddConstraint:- if err := table.createConstraint(spec.Constraint); err != nil {+ if err := tidbCreateConstraint(table, spec.Constraint); err != nil {return err}case tidbast.AlterTableDropColumn:- if err := table.DropColumn(spec.OldColumnName.Name.O, nil); err != nil {- return err+ columnName := spec.OldColumnName.Name.O+ // Validate column exists+ if table.GetColumn(columnName) == nil {+ return 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)}}case tidbast.AlterTableDropPrimaryKey:- if err := table.DropIndex(PrimaryKeyName, nil); err != nil {- return err+ if err := table.DropIndex(PrimaryKeyName); err != nil {+ return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}case tidbast.AlterTableDropIndex:- if err := table.DropIndex(spec.Name, nil); err != nil {- return err+ if err := table.DropIndex(spec.Name); err != nil {+ return &WalkThroughError{Code: code.IndexNotExists, Content: err.Error()}}case tidbast.AlterTableDropForeignKey:// we do not deal with DROP FOREIGN KEY statements.case tidbast.AlterTableModifyColumn:- if err := table.changeColumn(spec.NewColumns[0].Name.Name.O, spec.NewColumns[0], spec.Position); err != nil {+ if err := tidbChangeColumn(table, spec.NewColumns[0].Name.Name.O, spec.NewColumns[0], spec.Position); err != nil {return err}case tidbast.AlterTableChangeColumn:- if err := table.changeColumn(spec.OldColumnName.Name.O, spec.NewColumns[0], spec.Position); err != nil {+ if err := tidbChangeColumn(table, spec.OldColumnName.Name.O, spec.NewColumns[0], spec.Position); err != nil {return err}case tidbast.AlterTableRenameColumn:- if err := table.RenameColumn(spec.OldColumnName.Name.O, spec.NewColumnName.Name.O); err != nil {- return err+ oldColumnName := spec.OldColumnName.Name.O+ newColumnName := spec.NewColumnName.Name.O+ // Validate old column exists+ if table.GetColumn(oldColumnName) == nil {+ return NewColumnNotExistsError(table.GetProto().Name, oldColumnName)+ }+ // Validate new column doesn't already exist+ if table.GetColumn(newColumnName) != nil {+ return &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)}}case tidbast.AlterTableRenameTable:- schema := d.schemaSet[""]- if err := mysqlRenameTable(schema, table.name, spec.NewTable.Name.O); err != nil {- return err+ schema := d.GetSchema("")+ if err := schema.RenameTable(table.GetProto().Name, spec.NewTable.Name.O); err != nil {+ return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}}case tidbast.AlterTableAlterColumn:- if err := table.changeColumnDefault(spec.NewColumns[0]); err != nil {+ if err := tidbChangeColumnDefault(table, spec.NewColumns[0]); err != nil {return err}case tidbast.AlterTableRenameIndex:- if err := table.RenameIndex(spec.FromKey.O, spec.ToKey.O, nil); err != nil {- return err+ // 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)}+ }+ // 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)}+ }+ 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)}}case tidbast.AlterTableIndexInvisible:- if err := table.changeIndexVisibility(spec.IndexName.O, spec.Visibility); err != nil {+ if err := tidbChangeIndexVisibility(table, spec.IndexName.O, spec.Visibility); err != nil {return err}default:@@ -311,34 +355,34 @@ func (d *DatabaseState) alterTable(node *tidbast.AlterTableStmt) *WalkThroughErrreturn nil}-func (t *TableState) changeIndexVisibility(indexName string, visibility tidbast.IndexVisibility) *WalkThroughError {- index, exists := t.indexSet[strings.ToLower(indexName)]- if !exists {- return NewIndexNotExistsError(t.name, indexName)+func tidbChangeIndexVisibility(t *model.TableMetadata, indexName string, visibility tidbast.IndexVisibility) *WalkThroughError {+ index := t.GetIndex(indexName)+ if index == nil {+ return NewIndexNotExistsError(t.GetProto().Name, indexName)}switch visibility {case tidbast.IndexVisibilityVisible:- index.visible = true+ index.GetProto().Visible = truecase tidbast.IndexVisibilityInvisible:- index.visible = false+ index.GetProto().Visible = falsedefault:// Keep current visibility}return nil}-func (t *TableState) changeColumnDefault(column *tidbast.ColumnDef) *WalkThroughError {+func tidbChangeColumnDefault(t *model.TableMetadata, column *tidbast.ColumnDef) *WalkThroughError {columnName := column.Name.Name.L- colState, exists := t.columnSet[columnName]- if !exists {- return NewColumnNotExistsError(t.name, columnName)+ col := t.GetColumn(columnName)+ if col == nil {+ return NewColumnNotExistsError(t.GetProto().Name, columnName)}if len(column.Options) == 1 {// SET DEFAULTif column.Options[0].Expr.GetType().GetType() != mysql.TypeNull {- if colState.columnType != "" {- switch strings.ToLower(colState.columnType) {+ if col.Type != "" {+ switch strings.ToLower(col.Type) {case "blob", "tinyblob", "mediumblob", "longblob","text", "tinytext", "mediumtext", "longtext","json",@@ -360,119 +404,143 @@ func (t *TableState) changeColumnDefault(column *tidbast.ColumnDef) *WalkThroughContent: fmt.Sprintf("Failed to deparse default value: %v", err),}}- colState.defaultValue = defaultValue+ col.Default = defaultValue} else {- if !colState.nullable {+ if !col.Nullable {return &WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.Content: fmt.Sprintf("Invalid default value for column `%s`", columnName),}}- colState.defaultValue = ""+ col.Default = ""}} else {// DROP DEFAULT- colState.defaultValue = ""+ col.Default = ""}return nil}-func (t *TableState) renameColumnInIndexKey(oldName string, newName string) {+func tidbRenameColumnInIndexKey(t *model.TableMetadata, oldName string, newName string) {if strings.EqualFold(oldName, newName) {return}- for _, index := range t.indexSet {- for i, key := range index.expressionList {+ for _, index := range t.GetProto().Indexes {+ for i, key := range index.Expressions {if strings.EqualFold(key, oldName) {- index.expressionList[i] = newName+ index.Expressions[i] = newName}}}}-// completeTableChangeColumn changes column definition.-// It works as:-// 1. drop column from tableState.columnSet, but do not drop column from indexSet.-// 2. rename column from indexSet.-// 3. create a new column in columnSet.-func (t *TableState) completeTableChangeColumn(oldName string, newColumn *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {- column, exists := t.columnSet[strings.ToLower(oldName)]- if !exists {- return NewColumnNotExistsError(t.name, oldName)+// tidbCompleteTableChangeColumn changes column definition.+// It works by:+// 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 {+ column := t.GetColumn(oldName)+ if column == nil {+ return NewColumnNotExistsError(t.GetProto().Name, oldName)}- pos := column.position-- // generate Position struct for creating new column- // Create a local copy to avoid modifying the input parameter+ // Store the current position info if no position specifiedvar localPosition *tidbast.ColumnPositionif position == nil {localPosition = &tidbast.ColumnPosition{Tp: tidbast.ColumnPositionNone}} else {- // Create a copy of the position to avoid modifying the originallocalPosition = &tidbast.ColumnPosition{Tp: position.Tp,RelativeColumn: position.RelativeColumn,}}+ // If position not specified, preserve current position by finding the column before itif localPosition.Tp == tidbast.ColumnPositionNone {- if pos == 1 {+ tableProto := t.GetProto()+ var currentIdx int+ for i, col := range tableProto.Columns {+ if col == column {+ currentIdx = i+ break+ }+ }++ if currentIdx == 0 {localPosition.Tp = tidbast.ColumnPositionFirst} else {- for _, col := range t.columnSet {- if col.position == pos-1 {- localPosition.Tp = tidbast.ColumnPositionAfter- localPosition.RelativeColumn = &tidbast.ColumnName{Name: tidbast.NewCIStr(col.name)}- break- }- }+ // Position after the previous column+ localPosition.Tp = tidbast.ColumnPositionAfter+ previousColumn := tableProto.Columns[currentIdx-1]+ localPosition.RelativeColumn = &tidbast.ColumnName{Name: tidbast.NewCIStr(previousColumn.Name)}}}- position = localPosition- // drop column from columnSet- for _, col := range t.columnSet {- if col.position > pos {- col.position--- }+ // Remove the old column from the table (but keep it in index expressions)+ // 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)}}- delete(t.columnSet, strings.ToLower(column.name))- // rename column from indexSet- t.renameColumnInIndexKey(oldName, newColumn.Name.Name.O)+ // Rename column in index expressions+ tidbRenameColumnInIndexKey(t, oldName, newColumn.Name.Name.O)- // create a new column in columnSet- return t.tidbCreateColumn(newColumn, position)+ // Create the new column+ if err := tidbCreateColumnHelper(t, newColumn, localPosition); err != nil {+ return err+ }++ // Sort columns by position value to get the correct array order+ // CreateColumn appends to the end, but tidbReorderColumn sets position values,+ // so we need to sort the array to match the position values+ tableProto := t.GetProto()+ slices.SortFunc(tableProto.Columns, func(a, b *storepb.ColumnMetadata) int {+ if a.Position < b.Position {+ return -1+ } else if a.Position > b.Position {+ return 1+ }+ return 0+ })++ // Renumber all column positions to be sequential (1, 2, 3, ...)+ // This closes any gaps left by DropColumnWithoutUpdatingIndexes+ for i, col := range tableProto.Columns {+ col.Position = int32(i + 1)+ }++ return nil}-func (t *TableState) changeColumn(oldName string, newColumn *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {- return t.completeTableChangeColumn(oldName, newColumn, position)+func tidbChangeColumn(t *model.TableMetadata, oldName string, newColumn *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {+ return tidbCompleteTableChangeColumn(t, oldName, newColumn, position)}-// reorderColumn reorders the columns for new column and returns the new column position.-func (t *TableState) reorderColumn(position *tidbast.ColumnPosition) (int, *WalkThroughError) {+// tidbReorderColumn reorders the columns for new column and returns the new column position.+func tidbReorderColumn(t *model.TableMetadata, position *tidbast.ColumnPosition) (int, *WalkThroughError) {switch position.Tp {case tidbast.ColumnPositionNone:- return len(t.columnSet) + 1, nil+ return len(t.GetColumns()) + 1, nilcase tidbast.ColumnPositionFirst:- for _, column := range t.columnSet {- column.position+++ for _, column := range t.GetColumns() {+ column.Position++}return 1, nilcase tidbast.ColumnPositionAfter:columnName := position.RelativeColumn.Name.L- column, exist := t.columnSet[columnName]- if !exist {- return 0, NewColumnNotExistsError(t.name, columnName)+ column := t.GetColumn(columnName)+ if column == nil {+ return 0, NewColumnNotExistsError(t.GetProto().Name, columnName)}- for _, col := range t.columnSet {- if col.position > column.position {- col.position+++ for _, col := range t.GetColumns() {+ if col.Position > column.Position {+ col.Position++}}- return column.position + 1, nil+ return int(column.Position) + 1, nildefault:return 0, &WalkThroughError{Code: code.Unsupported,@@ -481,24 +549,24 @@ func (t *TableState) reorderColumn(position *tidbast.ColumnPosition) (int, *Walk}}-func (d *DatabaseState) dropTable(node *tidbast.DropTableStmt) *WalkThroughError {+func tidbDropTable(d *model.DatabaseMetadata, node *tidbast.DropTableStmt) *WalkThroughError {// TODO(rebelice): deal with DROP VIEW statement.if !node.IsView {for _, name := range node.Tables {- if name.Schema.O != "" && !d.isCurrentDatabase(name.Schema.O) {+ if name.Schema.O != "" && !isCurrentDatabase(d, name.Schema.O) {return &WalkThroughError{Code: code.NotCurrentDatabase,- Content: fmt.Sprintf("Database `%s` is not the current database `%s`", name.Schema.O, d.name),+ Content: fmt.Sprintf("Database `%s` is not the current database `%s`", name.Schema.O, d.GetProto().Name),}}- schema, exists := d.schemaSet[""]- if !exists {+ schema := d.GetSchema("")+ if schema == nil {schema = d.CreateSchema("")}- table, exists := mysqlGetTable(schema, name.Name.O)- if !exists {+ table := schema.GetTable(name.Name.O)+ if table == nil {if node.IfExists {return nil}@@ -508,14 +576,16 @@ func (d *DatabaseState) dropTable(node *tidbast.DropTableStmt) *WalkThroughError}}- delete(schema.tableSet, table.name)+ if err := schema.DropTable(table.GetProto().Name); err != nil {+ return &WalkThroughError{Code: code.TableNotExists, Content: err.Error()}+ }}}return nil}-func (d *DatabaseState) copyTable(node *tidbast.CreateTableStmt) *WalkThroughError {- targetTable, err := d.findTableState(node.ReferTable)+func tidbCopyTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *WalkThroughError {+ targetTable, err := tidbFindTableState(d, node.ReferTable)if err != nil {if err.Code == code.NotCurrentDatabase {return &WalkThroughError{@@ -523,29 +593,53 @@ func (d *DatabaseState) copyTable(node *tidbast.CreateTableStmt) *WalkThroughErrContent: fmt.Sprintf("Reference table `%s` in other database `%s`, skip walkthrough", node.ReferTable.Name.O, node.ReferTable.Schema.O),}}+ return err+ }++ schema := d.GetSchema("")+ // Create new table+ newTable, createErr := schema.CreateTable(node.Table.Name.O)+ if createErr != nil {+ return &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"}+ }+ if err := newTable.CreateColumn(colCopy); err != nil {+ return &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"}+ }+ if err := newTable.CreateIndex(idxCopy); err != nil {+ return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ }}- schema := d.schemaSet[""]- table := targetTable.copy()- table.name = node.Table.Name.O- schema.tableSet[table.name] = tablereturn nil}-func (d *DatabaseState) createTable(node *tidbast.CreateTableStmt) *WalkThroughError {- if node.Table.Schema.O != "" && !d.isCurrentDatabase(node.Table.Schema.O) {+func tidbCreateTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *WalkThroughError {+ if node.Table.Schema.O != "" && !isCurrentDatabase(d, node.Table.Schema.O) {return &WalkThroughError{Code: code.NotCurrentDatabase,- Content: fmt.Sprintf("Database `%s` is not the current database `%s`", node.Table.Schema.O, d.name),+ Content: fmt.Sprintf("Database `%s` is not the current database `%s`", node.Table.Schema.O, d.GetProto().Name),}}- schema, exists := d.schemaSet[""]- if !exists {+ schema := d.GetSchema("")+ if schema == nil {schema = d.CreateSchema("")}- if _, exists = mysqlGetTable(schema, node.Table.Name.O); exists {+ if schema.GetTable(node.Table.Name.O) != nil {if node.IfNotExists {return nil}@@ -563,18 +657,14 @@ func (d *DatabaseState) createTable(node *tidbast.CreateTableStmt) *WalkThroughE}if node.ReferTable != nil {- return d.copyTable(node)+ return tidbCopyTable(d, node)}- table := &TableState{- name: node.Table.Name.O,- engine: "",- collation: "",- comment: "",- columnSet: make(columnStateMap),- indexSet: make(IndexStateMap),+ table, createErr := schema.CreateTable(node.Table.Name.O)+ if createErr != nil {+ return &WalkThroughError{Code: code.TableExists, Content: createErr.Error()}}- schema.tableSet[table.name] = table+hasAutoIncrement := falsefor _, column := range node.Cols {@@ -583,19 +673,19 @@ func (d *DatabaseState) createTable(node *tidbast.CreateTableStmt) *WalkThroughEreturn &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.name),+ Content: fmt.Sprintf("There can be only one auto column for table `%s`", table.GetProto().Name),}}hasAutoIncrement = true}- if err := table.tidbCreateColumn(column, nil /* position */); err != nil {+ if err := tidbCreateColumnHelper(table, column, nil /* position */); err != nil {err.Line = column.OriginTextPosition()return err}}for _, constraint := range node.Constraints {- if err := table.createConstraint(constraint); err != nil {+ if err := tidbCreateConstraint(table, constraint); err != nil {err.Line = constraint.OriginTextPosition()return err}@@ -604,40 +694,40 @@ func (d *DatabaseState) createTable(node *tidbast.CreateTableStmt) *WalkThroughEreturn nil}-func (t *TableState) createConstraint(constraint *tidbast.Constraint) *WalkThroughError {+func tidbCreateConstraint(t *model.TableMetadata, constraint *tidbast.Constraint) *WalkThroughError {switch constraint.Tp {case tidbast.ConstraintPrimaryKey:- keyList, err := t.validateAndGetKeyStringList(constraint.Keys, true /* primary */, false /* isSpatial */)+ keyList, err := tidbValidateAndGetKeyStringList(t, constraint.Keys, true /* primary */, false /* isSpatial */)if err != nil {return err}- if err := t.tidbCreatePrimaryKey(keyList, getIndexType(constraint.Option)); err != nil {+ if err := tidbCreatePrimaryKeyHelper(t, keyList, getIndexType(constraint.Option)); err != nil {return err}case tidbast.ConstraintKey, tidbast.ConstraintIndex:- keyList, err := t.validateAndGetKeyStringList(constraint.Keys, false /* primary */, false /* isSpatial */)+ keyList, err := tidbValidateAndGetKeyStringList(t, constraint.Keys, false /* primary */, false /* isSpatial */)if err != nil {return err}- if err := t.tidbCreateIndex(constraint.Name, keyList, false /* unique */, getIndexType(constraint.Option), constraint.Option); err != nil {+ if err := tidbCreateIndexHelper(t, constraint.Name, keyList, false /* unique */, getIndexType(constraint.Option), constraint.Option); err != nil {return err}case tidbast.ConstraintUniq, tidbast.ConstraintUniqKey, tidbast.ConstraintUniqIndex:- keyList, err := t.validateAndGetKeyStringList(constraint.Keys, false /* primary */, false /* isSpatial */)+ keyList, err := tidbValidateAndGetKeyStringList(t, constraint.Keys, false /* primary */, false /* isSpatial */)if err != nil {return err}- if err := t.tidbCreateIndex(constraint.Name, keyList, true /* unique */, getIndexType(constraint.Option), constraint.Option); err != nil {+ if err := tidbCreateIndexHelper(t, constraint.Name, keyList, true /* unique */, getIndexType(constraint.Option), constraint.Option); err != nil {return err}case tidbast.ConstraintForeignKey:// we do not deal with FOREIGN KEY constraintscase tidbast.ConstraintFulltext:- keyList, err := t.validateAndGetKeyStringList(constraint.Keys, false /* primary */, false /* isSpatial */)+ keyList, err := tidbValidateAndGetKeyStringList(t, constraint.Keys, false /* primary */, false /* isSpatial */)if err != nil {return err}- if err := t.tidbCreateIndex(constraint.Name, keyList, false /* unique */, FullTextName, constraint.Option); err != nil {+ if err := tidbCreateIndexHelper(t, constraint.Name, keyList, false /* unique */, FullTextName, constraint.Option); err != nil {return err}case tidbast.ConstraintCheck:@@ -649,7 +739,7 @@ func (t *TableState) createConstraint(constraint *tidbast.Constraint) *WalkThroureturn nil}-func (t *TableState) validateAndGetKeyStringList(keyList []*tidbast.IndexPartSpecification, primary bool, isSpatial bool) ([]string, *WalkThroughError) {+func tidbValidateAndGetKeyStringList(t *model.TableMetadata, keyList []*tidbast.IndexPartSpecification, primary bool, isSpatial bool) ([]string, *WalkThroughError) {var res []stringfor _, key := range keyList {if key.Expr != nil {@@ -663,18 +753,18 @@ func (t *TableState) validateAndGetKeyStringList(keyList []*tidbast.IndexPartSperes = append(res, str)} else {columnName := key.Column.Name.L- column, exists := t.columnSet[columnName]- if !exists {- return nil, NewColumnNotExistsError(t.name, columnName)+ column := t.GetColumn(columnName)+ if column == nil {+ return nil, NewColumnNotExistsError(t.GetProto().Name, columnName)}if primary {- column.nullable = false+ column.Nullable = false}- if isSpatial && column.nullable {+ if isSpatial && column.Nullable {return nil, &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),+ Content: fmt.Sprintf("All parts of a SPATIAL index must be NOT NULL, but `%s` is nullable", column.Name),}}@@ -719,48 +809,47 @@ func checkDefault(columnName string, columnType *types.FieldType, value tidbast.return nil}-func (t *TableState) tidbCreateColumn(column *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {- if _, exists := t.columnSet[column.Name.Name.L]; exists {+func tidbCreateColumnHelper(t *model.TableMetadata, column *tidbast.ColumnDef, position *tidbast.ColumnPosition) *WalkThroughError {+ if t.GetColumn(column.Name.Name.L) != nil {return &WalkThroughError{Code: code.ColumnExists,- Content: fmt.Sprintf("Column `%s` already exists in table `%s`", column.Name.Name.O, t.name),+ Content: fmt.Sprintf("Column `%s` already exists in table `%s`", column.Name.Name.O, t.GetProto().Name),}}- pos := len(t.columnSet) + 1+ pos := len(t.GetColumns()) + 1if position != nil {var err *WalkThroughError- pos, err = t.reorderColumn(position)+ pos, err = tidbReorderColumn(t, position)if err != nil {return err}}- col := &ColumnState{- name: column.Name.Name.L,- position: pos,- defaultValue: "",- nullable: true,- columnType: column.Tp.CompactStr(),- characterSet: column.Tp.GetCharset(),- collation: column.Tp.GetCollate(),- comment: "",+ col := &storepb.ColumnMetadata{+ Name: column.Name.Name.L,+ Position: int32(pos),+ Default: "",+ Nullable: true,+ Type: column.Tp.CompactStr(),+ CharacterSet: column.Tp.GetCharset(),+ Collation: column.Tp.GetCollate(),}setNullDefault := falsefor _, option := range column.Options {switch option.Tp {case tidbast.ColumnOptionPrimaryKey:- col.nullable = false- if err := t.tidbCreatePrimaryKey([]string{col.name}, tidbast.IndexTypeBtree.String()); err != nil {+ col.Nullable = false+ if err := tidbCreatePrimaryKeyHelper(t, []string{col.Name}, tidbast.IndexTypeBtree.String()); err != nil {return err}case tidbast.ColumnOptionNotNull:- col.nullable = false+ col.Nullable = falsecase tidbast.ColumnOptionAutoIncrement:// we do not deal with AUTO-INCREMENTcase tidbast.ColumnOptionDefaultValue:- if err := checkDefault(col.name, column.Tp, option.Expr); err != nil {+ if err := checkDefault(col.Name, column.Tp, option.Expr); err != nil {return err}if option.Expr.GetType().GetType() != mysql.TypeNull {@@ -771,22 +860,22 @@ func (t *TableState) tidbCreateColumn(column *tidbast.ColumnDef, position *tidbaContent: fmt.Sprintf("Failed to deparse default value: %v", err),}}- col.defaultValue = defaultValue+ col.Default = defaultValue} else {setNullDefault = true}case tidbast.ColumnOptionUniqKey:- if err := t.tidbCreateIndex("", []string{col.name}, true /* unique */, tidbast.IndexTypeBtree.String(), nil); err != nil {+ if err := tidbCreateIndexHelper(t, "", []string{col.Name}, true /* unique */, tidbast.IndexTypeBtree.String(), nil); err != nil {return err}case tidbast.ColumnOptionNull:- col.nullable = true+ col.Nullable = truecase tidbast.ColumnOptionOnUpdate:// we do not deal with ON UPDATEif column.Tp.GetType() != mysql.TypeDatetime && column.Tp.GetType() != mysql.TypeTimestamp {return &WalkThroughError{Code: code.OnUpdateColumnNotDatetimeOrTimestamp,- Content: fmt.Sprintf("Column `%s` use ON UPDATE but is not DATETIME or TIMESTAMP", col.name),+ Content: fmt.Sprintf("Column `%s` use ON UPDATE but is not DATETIME or TIMESTAMP", col.Name),}}case tidbast.ColumnOptionComment:@@ -797,14 +886,14 @@ func (t *TableState) tidbCreateColumn(column *tidbast.ColumnDef, position *tidbaContent: fmt.Sprintf("Failed to deparse comment: %v", err),}}- col.comment = comment+ col.Comment = commentcase tidbast.ColumnOptionGenerated:// we do not deal with GENERATED ALWAYS AScase tidbast.ColumnOptionReference:// MySQL will ignore the inline REFERENCE// https://dev.mysql.com/doc/refman/8.0/en/create-table.htmlcase tidbast.ColumnOptionCollate:- col.collation = option.StrValue+ col.Collation = option.StrValuecase tidbast.ColumnOptionCheck:// we do not deal with CHECK constraintcase tidbast.ColumnOptionColumnFormat:@@ -818,28 +907,30 @@ func (t *TableState) tidbCreateColumn(column *tidbast.ColumnDef, position *tidba}}- if !col.nullable && setNullDefault {+ if !col.Nullable && setNullDefault {return &WalkThroughError{Code: code.SetNullDefaultForNotNullColumn,// Content comes from MySQL Error content.- Content: fmt.Sprintf("Invalid default value for column `%s`", col.name),+ Content: fmt.Sprintf("Invalid default value for column `%s`", col.Name),}}- t.columnSet[strings.ToLower(col.name)] = col+ if err := t.CreateColumn(col); err != nil {+ return &WalkThroughError{Code: code.ColumnExists, Content: err.Error()}+ }return nil}-func (t *TableState) tidbCreateIndex(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) *WalkThroughError {if len(keyList) == 0 {return &WalkThroughError{Code: code.IndexEmptyKeys,- Content: fmt.Sprintf("Index `%s` in table `%s` has empty key", name, t.name),+ Content: fmt.Sprintf("Index `%s` in table `%s` has empty key", name, t.GetProto().Name),}}if name != "" {- if _, exists := t.indexSet[strings.ToLower(name)]; exists {- return NewIndexExistsError(t.name, name)+ if t.GetIndex(name) != nil {+ return NewIndexExistsError(t.GetProto().Name, name)}} else {suffix := 1@@ -848,7 +939,7 @@ func (t *TableState) tidbCreateIndex(name string, keyList []string, unique bool,if suffix > 1 {name = fmt.Sprintf("%s_%d", keyList[0], suffix)}- if _, exists := t.indexSet[strings.ToLower(name)]; !exists {+ if t.GetIndex(name) == nil {break}suffix++@@ -857,38 +948,40 @@ func (t *TableState) tidbCreateIndex(name string, keyList []string, unique bool,visible := option == nil || option.Visibility != tidbast.IndexVisibilityInvisible- index := &IndexState{- name: name,- expressionList: keyList,- indexType: tp,- unique: unique,- primary: false,- visible: visible,- comment: "",+ index := &storepb.IndexMetadata{+ Name: name,+ Expressions: keyList,+ Type: tp,+ Unique: unique,+ Primary: false,+ Visible: visible,}- t.indexSet[strings.ToLower(name)] = index+ if err := t.CreateIndex(index); err != nil {+ return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}+ }return nil}-func (t *TableState) tidbCreatePrimaryKey(keys []string, tp string) *WalkThroughError {- if _, exists := t.indexSet[strings.ToLower(PrimaryKeyName)]; exists {+func tidbCreatePrimaryKeyHelper(t *model.TableMetadata, keys []string, tp string) *WalkThroughError {+ if t.GetIndex(PrimaryKeyName) != nil {return &WalkThroughError{Code: code.PrimaryKeyExists,- Content: fmt.Sprintf("Primary key exists in table `%s`", t.name),+ Content: fmt.Sprintf("Primary key exists in table `%s`", t.GetProto().Name),}}- pk := &IndexState{- name: PrimaryKeyName,- expressionList: keys,- indexType: tp,- unique: true,- primary: true,- visible: true,- comment: "",+ pk := &storepb.IndexMetadata{+ Name: PrimaryKeyName,+ Expressions: keys,+ Type: tp,+ Unique: true,+ Primary: true,+ Visible: true,+ }+ if err := t.CreateIndex(pk); err != nil {+ return &WalkThroughError{Code: code.IndexExists, Content: err.Error()}}- t.indexSet[strings.ToLower(pk.name)] = pkreturn nil}diff --git a/backend/plugin/advisor/catalog/walk_through_test.go b/backend/plugin/advisor/catalog/walk_through_test.goindex 91a59361bb..7d1f0f5575 100644--- a/backend/plugin/advisor/catalog/walk_through_test.go+++ b/backend/plugin/advisor/catalog/walk_through_test.go@@ -4,7 +4,6 @@ import ("io""os""path/filepath"- "slices""testing""github.com/google/go-cmp/cmp"@@ -16,6 +15,7 @@ import ("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 {@@ -68,11 +68,13 @@ func TestPostgreSQLWalkThrough(t *testing.T) {Name: "id",Type: "int",Nullable: false,+ Position: 1,},{Name: "name",Type: "varchar(20)",Nullable: true,+ Position: 2,},},},@@ -122,11 +124,13 @@ func TestPostgreSQLANTLRWalkThrough(t *testing.T) {Name: "id",Type: "int",Nullable: false,+ Position: 1,},{Name: "name",Type: "varchar(20)",Nullable: true,+ Position: 2,},},},@@ -178,16 +182,17 @@ func runWalkThroughTest(t *testing.T, file string, engineType storepb.Engine, orfor _, test := range tests {var proto *storepb.DatabaseSchemaMetadataif originDatabase != nil {- proto = originDatabase+ // Make a deep copy to avoid mutation across tests+ proto = cloneDatabaseSchemaMetadata(originDatabase)} else {proto = &storepb.DatabaseSchemaMetadata{}}- // Create DatabaseState for walk-through- state := NewDatabaseState(proto, test.IgnoreCaseSensitive, engineType)+ // Create DatabaseMetadata for walk-through+ state := model.NewDatabaseMetadata(proto, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)asts, _ := sm.GetASTsForChecks(engineType, test.Statement)- err := WalkThrough(state, asts)+ err := WalkThrough(state, engineType, asts)if err != nil {err, yes := err.(*WalkThroughError)require.True(t, yes)@@ -196,10 +201,17 @@ func runWalkThroughTest(t *testing.T, file string, engineType storepb.Engine, or}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)- result := state.convertToDatabaseMetadata()+ // Sort proto for deterministic comparison+ state.SortProto()+ result := state.GetProto()diff := cmp.Diff(want, result, protocmp.Transform())require.Empty(t, diff)}@@ -220,13 +232,14 @@ func runANTLRWalkThroughTest(t *testing.T, file string, engineType storepb.Enginfor _, test := range tests {var proto *storepb.DatabaseSchemaMetadataif originDatabase != nil {- proto = originDatabase+ // Make a deep copy to avoid mutation across tests+ proto = cloneDatabaseSchemaMetadata(originDatabase)} else {proto = &storepb.DatabaseSchemaMetadata{}}- // Create DatabaseState for walk-through- state := NewDatabaseState(proto, test.IgnoreCaseSensitive, engineType)+ // Create DatabaseMetadata for walk-through+ state := model.NewDatabaseMetadata(proto, !test.IgnoreCaseSensitive, !test.IgnoreCaseSensitive)// Parse using ANTLR parser instead of legacy parserparseResult, parseErr := pgparser.ParsePostgreSQL(test.Statement)@@ -235,7 +248,7 @@ func runANTLRWalkThroughTest(t *testing.T, file string, engineType storepb.Engin}// Call WalkThrough with ANTLR tree- err := WalkThrough(state, parseResult)+ err := WalkThrough(state, engineType, parseResult)if err != nil {err, yes := err.(*WalkThroughError)require.True(t, yes)@@ -244,155 +257,106 @@ func runANTLRWalkThroughTest(t *testing.T, file string, engineType storepb.Engin}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)- result := state.convertToDatabaseMetadata()+ // Sort proto for deterministic comparison+ state.SortProto()+ result := state.GetProto()diff := cmp.Diff(want, result, protocmp.Transform())require.Empty(t, diff)}}-// convertToDatabaseMetadata only used for tests.-func (d *DatabaseState) convertToDatabaseMetadata() *storepb.DatabaseSchemaMetadata {- if d.deleted {+// cloneDatabaseSchemaMetadata creates a deep copy of the database schema metadata.+func cloneDatabaseSchemaMetadata(original *storepb.DatabaseSchemaMetadata) *storepb.DatabaseSchemaMetadata {+ if original == nil {return nil}- return &storepb.DatabaseSchemaMetadata{- Name: d.name,- CharacterSet: d.characterSet,- Collation: d.collation,- Schemas: d.convertToSchemaMetadataList(),- Extensions: []*storepb.ExtensionMetadata{},- }-}--// convertToSchemaMetadataList only used for tests.-func (d *DatabaseState) convertToSchemaMetadataList() []*storepb.SchemaMetadata {- result := []*storepb.SchemaMetadata{}-- for _, schema := range d.schemaSet {- schemaMeta := &storepb.SchemaMetadata{- Name: schema.name,- Tables: schema.convertToTableMetadataList(),- // TODO(rebelice): convert views if needed.- Views: []*storepb.ViewMetadata{},- Functions: []*storepb.FunctionMetadata{},- Streams: []*storepb.StreamMetadata{},- Tasks: []*storepb.TaskMetadata{},- }-- result = append(result, schemaMeta)- }-- slices.SortFunc(result, func(x, y *storepb.SchemaMetadata) int {- if x.Name < y.Name {- return -1- } else if x.Name > y.Name {- return 1- }- return 0- })-- return result-}--// convertToTableMetadataList only used for tests.-func (s *SchemaState) convertToTableMetadataList() []*storepb.TableMetadata {- result := []*storepb.TableMetadata{}-- for _, table := range s.tableSet {- tableMeta := &storepb.TableMetadata{- Name: table.name,- Columns: table.convertToColumnMetadataList(),- Indexes: table.convertToIndexMetadataList(),- ForeignKeys: []*storepb.ForeignKeyMetadata{},- }- tableMeta.Engine = table.engine- tableMeta.Collation = table.collation- tableMeta.Comment = table.comment-- result = append(result, tableMeta)+ 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)),}- slices.SortFunc(result, func(x, y *storepb.TableMetadata) int {- if x.Name < y.Name {- return -1- } else if x.Name > y.Name {- return 1+ 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)),}- return 0- })-- return result-}-// convertToIndexMetadataList only used for tests.-func (t *TableState) convertToIndexMetadataList() []*storepb.IndexMetadata {- result := []*storepb.IndexMetadata{}-- for _, index := range t.indexSet {- indexMeta := &storepb.IndexMetadata{- Name: index.name,- Expressions: index.ExpressionList(),- Unique: index.Unique(),- Primary: index.Primary(),- }+ 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)),+ }- indexMeta.Type = index.indexType- indexMeta.Visible = index.visible- indexMeta.Comment = index.comment+ 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)+ }- result = append(result, indexMeta)- }+ 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)+ }- slices.SortFunc(result, func(x, y *storepb.IndexMetadata) int {- if x.Name < y.Name {- return -1- } else if x.Name > y.Name {- return 1+ cloneSchema.Tables = append(cloneSchema.Tables, cloneTable)}- return 0- })- return result-}--// convertToColumnMetadataList only used for tests.-func (t *TableState) convertToColumnMetadataList() []*storepb.ColumnMetadata {- result := []*storepb.ColumnMetadata{}-- for _, column := range t.columnSet {- columnMeta := &storepb.ColumnMetadata{- Name: column.name,- Nullable: column.Nullable(),- Type: column.Type(),+ 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)}- columnMeta.Default = column.defaultValue- columnMeta.CharacterSet = column.characterSet- columnMeta.Collation = column.collation- columnMeta.Comment = column.comment- columnMeta.Position = int32(column.position)-- result = append(result, columnMeta)+ clone.Schemas = append(clone.Schemas, cloneSchema)}- slices.SortFunc(result, func(x, y *storepb.ColumnMetadata) int {- if x.Position != y.Position {- if x.Position < y.Position {- return -1- }- return 1- }- if x.Name < y.Name {- return -1- } else if x.Name > y.Name {- return 1- }- return 0- })-- return result+ return clone}diff --git a/backend/plugin/advisor/code/code.go b/backend/plugin/advisor/code/code.goindex 17777fdba9..44730165df 100644--- a/backend/plugin/advisor/code/code.go+++ b/backend/plugin/advisor/code/code.go@@ -228,6 +228,10 @@ const (// 2101 ~ 2199 constraint error code.ConstraintNotExists Code = 2101++ // 2201 ~ 2299 view error code.+ ViewNotExists Code = 2201+ ViewExists Code = 2202)// Int returns the int type of code.diff --git a/backend/plugin/advisor/mysql/rule_column_no_null.go b/backend/plugin/advisor/mysql/rule_column_no_null.goindex 960316e18e..f8b9b4be35 100644--- a/backend/plugin/advisor/mysql/rule_column_no_null.go+++ b/backend/plugin/advisor/mysql/rule_column_no_null.go@@ -12,9 +12,9 @@ import ("github.com/bytebase/bytebase/backend/common"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/advisor/code"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"+ "github.com/bytebase/bytebase/backend/store/model")var (@@ -44,7 +44,7 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (}// Create the rule- rule := NewColumnNoNullRule(level, string(checkCtx.Rule.Type), checkCtx.FinalCatalog)+ rule := NewColumnNoNullRule(level, string(checkCtx.Rule.Type), checkCtx.FinalMetadata)// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})@@ -74,19 +74,19 @@ func (c columnName) name() string {// ColumnNoNullRule checks for column no NULL value.type ColumnNoNullRule struct {BaseRule- columnSet map[string]columnName- finalCatalog *catalog.DatabaseState+ columnSet map[string]columnName+ finalMetadata *model.DatabaseMetadata}// NewColumnNoNullRule creates a new ColumnNoNullRule.-func NewColumnNoNullRule(level storepb.Advice_Status, title string, finalCatalog *catalog.DatabaseState) *ColumnNoNullRule {+func NewColumnNoNullRule(level storepb.Advice_Status, title string, finalMetadata *model.DatabaseMetadata) *ColumnNoNullRule {return &ColumnNoNullRule{BaseRule: BaseRule{level: level,title: title,},- columnSet: make(map[string]columnName),- finalCatalog: finalCatalog,+ columnSet: make(map[string]columnName),+ finalMetadata: finalMetadata,}}@@ -135,16 +135,16 @@ func (r *ColumnNoNullRule) generateAdvice() {})for _, column := range columnList {- schema, _ := r.finalCatalog.GetSchema("")+ schema := r.finalMetadata.GetSchema("")if schema == nil {continue}- table, _ := schema.GetTable(column.tableName)+ table := schema.GetTable(column.tableName)if table == nil {continue}- col, _ := table.GetColumn(column.columnName)- if col != nil && col.Nullable() {+ col := table.GetColumn(column.columnName)+ if col != nil && col.Nullable {r.AddAdvice(&storepb.Advice{Status: r.level,Code: code.ColumnCannotNull.Int32(),diff --git a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.goindex d01cab2e40..686b962935 100644--- a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go+++ b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go@@ -61,17 +61,17 @@ func (*DatabaseAllowDropIfEmptyAdvisor) Check(_ context.Context, checkCtx adviso// DatabaseDropEmptyDBRule checks for drop database only if empty.type DatabaseDropEmptyDBRule struct {BaseRule- originCatalog *model.DatabaseMetadata+ originMetadata *model.DatabaseMetadata}// NewDatabaseDropEmptyDBRule creates a new DatabaseDropEmptyDBRule.-func NewDatabaseDropEmptyDBRule(level storepb.Advice_Status, title string, originCatalog *model.DatabaseMetadata) *DatabaseDropEmptyDBRule {+func NewDatabaseDropEmptyDBRule(level storepb.Advice_Status, title string, originMetadata *model.DatabaseMetadata) *DatabaseDropEmptyDBRule {return &DatabaseDropEmptyDBRule{BaseRule: BaseRule{level: level,title: title,},- originCatalog: originCatalog,+ originMetadata: originMetadata,}}@@ -102,15 +102,15 @@ func (r *DatabaseDropEmptyDBRule) checkDropDatabase(ctx *mysql.DropDatabaseConte}dbName := mysqlparser.NormalizeMySQLSchemaRef(ctx.SchemaRef())- if r.originCatalog.DatabaseName() != dbName {+ if r.originMetadata.DatabaseName() != dbName {r.AddAdvice(&storepb.Advice{Status: r.level,Code: code.NotCurrentDatabase.Int32(),Title: r.title,- Content: fmt.Sprintf("Database `%s` that is trying to be deleted is not the current database `%s`", dbName, r.originCatalog.DatabaseName()),+ Content: fmt.Sprintf("Database `%s` that is trying to be deleted is not the current database `%s`", dbName, r.originMetadata.DatabaseName()),StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),})- } else if !r.originCatalog.HasNoTable() {+ } else if !r.originMetadata.HasNoTable() {r.AddAdvice(&storepb.Advice{Status: r.level,Code: code.DatabaseNotEmpty.Int32(),diff --git a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go b/backend/plugin/advisor/mysql/rule_index_total_number_limit.goindex af874730d1..c98524fa84 100644--- a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go+++ b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go@@ -14,8 +14,8 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"+ "github.com/bytebase/bytebase/backend/store/model")var (@@ -49,7 +49,7 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.C}// Create the rule- rule := NewIndexTotalNumberLimitRule(level, string(checkCtx.Rule.Type), payload.Number, checkCtx.FinalCatalog)+ rule := NewIndexTotalNumberLimitRule(level, string(checkCtx.Rule.Type), payload.Number, checkCtx.FinalMetadata)// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})@@ -66,21 +66,21 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.C// IndexTotalNumberLimitRule checks for index total number limit.type IndexTotalNumberLimitRule struct {BaseRule- max int- lineForTable map[string]int- finalCatalog *catalog.DatabaseState+ max int+ lineForTable map[string]int+ finalMetadata *model.DatabaseMetadata}// NewIndexTotalNumberLimitRule creates a new IndexTotalNumberLimitRule.-func NewIndexTotalNumberLimitRule(level storepb.Advice_Status, title string, maxIndexes int, finalCatalog *catalog.DatabaseState) *IndexTotalNumberLimitRule {+func NewIndexTotalNumberLimitRule(level storepb.Advice_Status, title string, maxIndexes int, finalMetadata *model.DatabaseMetadata) *IndexTotalNumberLimitRule {return &IndexTotalNumberLimitRule{BaseRule: BaseRule{level: level,title: title,},- max: maxIndexes,- lineForTable: make(map[string]int),- finalCatalog: finalCatalog,+ max: maxIndexes,+ lineForTable: make(map[string]int),+ finalMetadata: finalMetadata,}}@@ -132,14 +132,17 @@ func (r *IndexTotalNumberLimitRule) generateAdvice() []*storepb.Advice {})for _, table := range tableList {- dbState := r.finalCatalog- tableInfo := dbState.GetTable("", table.name)- if tableInfo != nil && tableInfo.CountIndex() > r.max {+ schema := r.finalMetadata.GetSchema("")+ if schema == nil {+ continue+ }+ tableInfo := schema.GetTable(table.name)+ if tableInfo != nil && len(tableInfo.GetProto().Indexes) > r.max {r.AddAdvice(&storepb.Advice{Status: r.level,Code: code.IndexCountExceedsLimit.Int32(),Title: r.title,- Content: fmt.Sprintf("The count of index in table `%s` should be no more than %d, but found %d", table.name, r.max, tableInfo.CountIndex()),+ Content: fmt.Sprintf("The count of index in table `%s` should be no more than %d, but found %d", table.name, r.max, len(tableInfo.GetProto().Indexes)),StartPosition: common.ConvertANTLRLineToPosition(table.line),})}diff --git a/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go b/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.goindex e496f9b2a5..93d6c36fd9 100644--- a/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go+++ b/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go@@ -17,8 +17,8 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"+ "github.com/bytebase/bytebase/backend/store/model")var (@@ -48,7 +48,7 @@ func (*TableMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advis}// Create the rule- rule := NewTableTextFieldsTotalLengthRule(level, string(checkCtx.Rule.Type), checkCtx.FinalCatalog, payload.Number)+ rule := NewTableTextFieldsTotalLengthRule(level, string(checkCtx.Rule.Type), checkCtx.FinalMetadata, payload.Number)// Create the generic checker with the rulechecker := NewGenericChecker([]Rule{rule})@@ -65,19 +65,19 @@ func (*TableMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advis// TableTextFieldsTotalLengthRule checks for table text fields total length.type TableTextFieldsTotalLengthRule struct {BaseRule- finalCatalog *catalog.DatabaseState- maximum int+ finalMetadata *model.DatabaseMetadata+ maximum int}// NewTableTextFieldsTotalLengthRule creates a new TableTextFieldsTotalLengthRule.-func NewTableTextFieldsTotalLengthRule(level storepb.Advice_Status, title string, finalCatalog *catalog.DatabaseState, maximum int) *TableTextFieldsTotalLengthRule {+func NewTableTextFieldsTotalLengthRule(level storepb.Advice_Status, title string, finalMetadata *model.DatabaseMetadata, maximum int) *TableTextFieldsTotalLengthRule {return &TableTextFieldsTotalLengthRule{BaseRule: BaseRule{level: level,title: title,},- finalCatalog: finalCatalog,- maximum: maximum,+ finalMetadata: finalMetadata,+ maximum: maximum,}}@@ -116,8 +116,11 @@ func (r *TableTextFieldsTotalLengthRule) checkCreateTable(ctx *mysql.CreateTableif tableName == "" {return}- dbState := r.finalCatalog- tableInfo := dbState.GetTable("", tableName)+ schema := r.finalMetadata.GetSchema("")+ if schema == nil {+ return+ }+ tableInfo := schema.GetTable(tableName)if tableInfo == nil {return}@@ -151,8 +154,11 @@ func (r *TableTextFieldsTotalLengthRule) checkAlterTable(ctx *mysql.AlterTableCoif tableName == "" {return}- dbState := r.finalCatalog- tableInfo := dbState.GetTable("", tableName)+ schema := r.finalMetadata.GetSchema("")+ if schema == nil {+ return+ }+ tableInfo := schema.GetTable(tableName)if tableInfo == nil {return}@@ -168,11 +174,11 @@ func (r *TableTextFieldsTotalLengthRule) checkAlterTable(ctx *mysql.AlterTableCo}}-func getTotalTextLength(tableInfo *catalog.TableState) int64 {+func getTotalTextLength(tableInfo *model.TableMetadata) int64 {var total int64- columns := tableInfo.ListColumns()+ columns := tableInfo.GetColumns()for _, column := range columns {- total += getTextLength(column.Type())+ total += getTextLength(column.Type)}return total}diff --git a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go b/backend/plugin/advisor/pg/advisor_index_total_number_limit.goindex 8c6ac5a192..243d649aa9 100644--- a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go@@ -13,7 +13,7 @@ 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/store/model")var (@@ -45,10 +45,10 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.C}rule := &indexTotalNumberLimitRule{- BaseRule: BaseRule{level: level, title: string(checkCtx.Rule.Type)},- max: payload.Number,- finalCatalog: checkCtx.FinalCatalog,- tableLine: make(tableLineMap),+ BaseRule: BaseRule{level: level, title: string(checkCtx.Rule.Type)},+ max: payload.Number,+ finalMetadata: checkCtx.FinalMetadata,+ tableLine: make(tableLineMap),}checker := NewGenericChecker([]Rule{rule})@@ -79,9 +79,9 @@ func (m tableLineMap) set(schema string, table string, line int) {type indexTotalNumberLimitRule struct {BaseRule- max int- finalCatalog *catalog.DatabaseState- tableLine tableLineMap+ max int+ finalMetadata *model.DatabaseMetadata+ tableLine tableLineMap}func (*indexTotalNumberLimitRule) Name() string {@@ -122,20 +122,20 @@ func (r *indexTotalNumberLimitRule) generateAdvice() {})for _, table := range tableList {- schema, err := r.finalCatalog.GetSchema(table.schema)- if err != nil {+ schema := r.finalMetadata.GetSchema(table.schema)+ if schema == nil {continue}- tableInfo, err := schema.GetTable(table.table)- if err != nil {+ tableInfo := schema.GetTable(table.table)+ if tableInfo == nil {continue}- if tableInfo != nil && tableInfo.CountIndex() > r.max {+ if len(tableInfo.GetProto().Indexes) > r.max {r.AddAdvice(&storepb.Advice{Status: r.level,Code: code.IndexCountExceedsLimit.Int32(),Title: r.title,- Content: fmt.Sprintf("The count of index in table %q.%q should be no more than %d, but found %d", table.schema, table.table, r.max, tableInfo.CountIndex()),+ Content: fmt.Sprintf("The count of index in table %q.%q should be no more than %d, but found %d", table.schema, table.table, r.max, len(tableInfo.GetProto().Indexes)),StartPosition: &storepb.Position{Line: int32(table.line),Column: 0,diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.goindex 294c6170cf..c87054f1c7 100644--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go@@ -10,9 +10,9 @@ 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/advisor/code"pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/store/model")var (@@ -45,7 +45,7 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)title: string(checkCtx.Rule.Type),},statementsText: checkCtx.Statements,- finalCatalog: checkCtx.FinalCatalog,+ finalMetadata: checkCtx.FinalMetadata,tableMentions: make(map[string]*tableMention),}@@ -66,7 +66,7 @@ type tableMention struct {type tableRequirePKRule struct {BaseRulestatementsText string- finalCatalog *catalog.DatabaseState+ finalMetadata *model.DatabaseMetadata// Simple Solution: Track last mention of each tabletableMentions map[string]*tableMention // key: "schema.table", value: last mention info@@ -180,7 +180,14 @@ func (r *tableRequirePKRule) validateFinalState() {schemaName, tableName := parseTableKey(tableKey)// Check catalog.Final for PRIMARY KEY- hasPK := r.finalCatalog.HasPrimaryKey(schemaName, tableName)+ schema := r.finalMetadata.GetSchema(schemaName)+ var hasPK bool+ if schema != nil {+ table := schema.GetTable(tableName)+ if table != nil {+ hasPK = table.GetPrimaryKey() != nil+ }+ }if !hasPK {content := fmt.Sprintf("Table %q.%q requires PRIMARY KEY", schemaName, tableName)diff --git a/backend/plugin/advisor/pg/test/naming_index_pk.yaml b/backend/plugin/advisor/pg/test/naming_index_pk.yamlindex 6e9faff391..204bd0b772 100644--- a/backend/plugin/advisor/pg/test/naming_index_pk.yaml+++ b/backend/plugin/advisor/pg/test/naming_index_pk.yaml@@ -1,6 +1,10 @@-- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY (id, name)+- statement: |-+ ALTER TABLE tech_book DROP CONSTRAINT old_pk;+ ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY (id, name)changeType: 1-- statement: ALTER TABLE tech_book ADD CONSTRAINT tech_book_id_name PRIMARY KEY (id, name)+- statement: |-+ ALTER TABLE tech_book DROP CONSTRAINT old_pk;+ ALTER TABLE tech_book ADD CONSTRAINT tech_book_id_name PRIMARY KEY (id, name)changeType: 1want:- status: 2@@ -8,10 +12,12 @@title: naming.index.pkcontent: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "tech_book_id_name"startposition:- line: 1+ line: 2column: 0endposition: null-- statement: ALTER TABLE tech_book ADD CONSTRAINT udmhjtnsaablcmjhqcznfiwtnevcehcvw PRIMARY KEY (id, name)+- statement: |-+ ALTER TABLE tech_book DROP CONSTRAINT old_pk;+ ALTER TABLE tech_book ADD CONSTRAINT udmhjtnsaablcmjhqcznfiwtnevcehcvw PRIMARY KEY (id, name)changeType: 1want:- status: 2@@ -19,7 +25,7 @@title: naming.index.pkcontent: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "udmhjtnsaablcmjhqcznfiwtnevcehcvw"startposition:- line: 1+ line: 2column: 0endposition: null- statement: CREATE TABLE book(id INT, name VARCHAR(20), CONSTRAINT pk_book_name PRIMARY KEY (name))@@ -45,9 +51,13 @@changeType: 1- statement: CREATE TABLE book(id INT, name VARCHAR(20) PRIMARY KEY)changeType: 1-- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY USING INDEX old_index+- statement: |-+ ALTER TABLE tech_book DROP CONSTRAINT old_pk;+ ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY USING INDEX old_indexchangeType: 1-- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book PRIMARY KEY USING INDEX old_index+- statement: |-+ ALTER TABLE tech_book DROP CONSTRAINT old_pk;+ ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book PRIMARY KEY USING INDEX old_indexchangeType: 1want:- status: 2@@ -55,7 +65,7 @@title: naming.index.pkcontent: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "pk_tech_book"startposition:- line: 1+ line: 2column: 0endposition: null- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO pk_tech_book_id_namediff --git a/backend/plugin/advisor/pg/test_helper.go b/backend/plugin/advisor/pg/test_helper.goindex c1ce651835..b34add362c 100644--- a/backend/plugin/advisor/pg/test_helper.go+++ b/backend/plugin/advisor/pg/test_helper.go@@ -10,6 +10,7 @@ import ("testing""github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto""gopkg.in/yaml.v3"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -60,11 +61,17 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp}// Create OriginalMetadata as DatabaseMetadata (read-only)- originalSchema := model.NewDatabaseSchema(schemaMetadata, nil, nil, dbType, true /* isCaseSensitive for PostgreSQL */)+ // Clone to avoid mutations affecting future test cases+ originalCatalogClone, ok := proto.Clone(schemaMetadata).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok, "failed to clone schema metadata")+ originalSchema := model.NewDatabaseSchema(originalCatalogClone, nil, nil, dbType, true /* isCaseSensitive for PostgreSQL */)originalMetadata := originalSchema.GetDatabaseMetadata()- // Create FinalCatalog as DatabaseState (mutable for walk-through)- finalCatalog := catalog.NewDatabaseState(schemaMetadata, false /* ignoreCaseSensitive */, dbType)+ // Create FinalMetadata as DatabaseMetadata (mutable for walk-through)+ // Clone to avoid mutations affecting future test cases+ finalCatalogClone, ok := proto.Clone(schemaMetadata).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok, "failed to clone schema metadata")+ finalMetadata := model.NewDatabaseMetadata(finalCatalogClone, true /* isCaseSensitive for PostgreSQL */, true /* isDetailCaseSensitive */)// Get default payload, or use empty string for test-only rulespayload, err := advisor.SetDefaultSQLReviewRulePayload(rule, dbType)@@ -78,7 +85,7 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyprequire.NoError(t, err, "Failed to parse SQL: %s", tc.Statement)// Always walk through the catalog to build metadata.- err = catalog.WalkThrough(finalCatalog, tree)+ err = catalog.WalkThrough(finalMetadata, dbType, tree)require.NoError(t, err, "Failed to walk through final catalog: %s", tc.Statement)ruleList := []*storepb.SQLReviewRule{@@ -102,7 +109,7 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTypStatements: tc.Statement,Rule: ruleList[0],OriginalMetadata: originalMetadata,- FinalCatalog: finalCatalog,+ FinalMetadata: finalMetadata,Driver: nil,CurrentDatabase: "TEST_DB",UsePostgresDatabaseOwner: true,diff --git a/backend/plugin/advisor/sql_review.go b/backend/plugin/advisor/sql_review.goindex 30d8196fbe..467e3b0384 100644--- a/backend/plugin/advisor/sql_review.go+++ b/backend/plugin/advisor/sql_review.go@@ -493,7 +493,7 @@ type SQLReviewCheckContext struct {DBSchema *storepb.DatabaseSchemaMetadataDBType storepb.EngineOriginalMetadata *model.DatabaseMetadata- FinalCatalog *catalog.DatabaseState+ FinalMetadata *model.DatabaseMetadataDriver *sql.DBEnablePriorBackup boolClassificationConfig *storepb.DataClassificationSetting_DataClassificationConfig@@ -532,10 +532,10 @@ func SQLReviewCheck(return parseResult, nil}- if !builtinOnly && checkContext.FinalCatalog != nil {+ 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.FinalCatalog, asts); err != nil {+ if err := catalog.WalkThrough(checkContext.FinalMetadata, checkContext.DBType, asts); err != nil {return convertWalkThroughErrorToAdvice(err)}default:@@ -563,7 +563,7 @@ func SQLReviewCheck(Statements: statements,Rule: rule,OriginalMetadata: checkContext.OriginalMetadata,- FinalCatalog: checkContext.FinalCatalog,+ FinalMetadata: checkContext.FinalMetadata,Driver: checkContext.Driver,CurrentDatabase: checkContext.CurrentDatabase,ClassificationConfig: checkContext.ClassificationConfig,diff --git a/backend/plugin/advisor/tidb/advisor_column_no_null.go b/backend/plugin/advisor/tidb/advisor_column_no_null.goindex 9a168357bd..39eea0392c 100644--- a/backend/plugin/advisor/tidb/advisor_column_no_null.go+++ b/backend/plugin/advisor/tidb/advisor_column_no_null.go@@ -11,8 +11,8 @@ import ("github.com/bytebase/bytebase/backend/common"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/advisor/code"+ "github.com/bytebase/bytebase/backend/store/model")var (@@ -40,10 +40,10 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (return nil, err}checker := &columnNoNullChecker{- level: level,- title: string(checkCtx.Rule.Type),- columnSet: make(map[string]columnName),- finalCatalog: checkCtx.FinalCatalog,+ level: level,+ title: string(checkCtx.Rule.Type),+ columnSet: make(map[string]columnName),+ finalMetadata: checkCtx.FinalMetadata,}for _, stmtNode := range root {@@ -54,11 +54,11 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (}type columnNoNullChecker struct {- adviceList []*storepb.Advice- level storepb.Advice_Status- title string- columnSet map[string]columnName- finalCatalog *catalog.DatabaseState+ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ columnSet map[string]columnName+ finalMetadata *model.DatabaseMetadata}func (checker *columnNoNullChecker) generateAdvice() []*storepb.Advice {@@ -83,16 +83,16 @@ func (checker *columnNoNullChecker) generateAdvice() []*storepb.Advice {})for _, column := range columnList {- schema, _ := checker.finalCatalog.GetSchema("")+ schema := checker.finalMetadata.GetSchema("")if schema == nil {continue}- table, _ := schema.GetTable(column.tableName)+ table := schema.GetTable(column.tableName)if table == nil {continue}- col, _ := table.GetColumn(column.columnName)- if col != nil && col.Nullable() {+ col := table.GetColumn(column.columnName)+ if col != nil && col.Nullable {checker.adviceList = append(checker.adviceList, &storepb.Advice{Status: checker.level,Code: code.ColumnCannotNull.Int32(),diff --git a/backend/plugin/advisor/tidb/advisor_index_total_number_limit.go b/backend/plugin/advisor/tidb/advisor_index_total_number_limit.goindex 346a4efd65..dd653b1f40 100644--- a/backend/plugin/advisor/tidb/advisor_index_total_number_limit.go+++ b/backend/plugin/advisor/tidb/advisor_index_total_number_limit.go@@ -15,7 +15,7 @@ import ("github.com/bytebase/bytebase/backend/common"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/store/model")var (@@ -47,11 +47,11 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Creturn nil, err}checker := &indexTotalNumberLimitChecker{- level: level,- title: string(checkCtx.Rule.Type),- max: payload.Number,- lineForTable: make(map[string]int),- finalCatalog: checkCtx.FinalCatalog,+ level: level,+ title: string(checkCtx.Rule.Type),+ max: payload.Number,+ lineForTable: make(map[string]int),+ finalMetadata: checkCtx.FinalMetadata,}for _, stmt := range stmtList {@@ -64,14 +64,14 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.C}type indexTotalNumberLimitChecker struct {- adviceList []*storepb.Advice- level storepb.Advice_Status- title string- text string- line int- max int- lineForTable map[string]int- finalCatalog *catalog.DatabaseState+ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ text string+ line int+ max int+ lineForTable map[string]int+ finalMetadata *model.DatabaseMetadata}func (checker *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice {@@ -98,13 +98,17 @@ func (checker *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice})for _, table := range tableList {- tableInfo := checker.finalCatalog.GetTable("", table.name)- if tableInfo != nil && tableInfo.CountIndex() > checker.max {+ schema := checker.finalMetadata.GetSchema("")+ if schema == nil {+ continue+ }+ tableInfo := schema.GetTable(table.name)+ if tableInfo != nil && len(tableInfo.GetProto().Indexes) > checker.max {checker.adviceList = append(checker.adviceList, &storepb.Advice{Status: checker.level,Code: code.IndexCountExceedsLimit.Int32(),Title: checker.title,- Content: fmt.Sprintf("The count of index in table `%s` should be no more than %d, but found %d", table.name, checker.max, tableInfo.CountIndex()),+ Content: fmt.Sprintf("The count of index in table `%s` should be no more than %d, but found %d", table.name, checker.max, len(tableInfo.GetProto().Indexes)),StartPosition: common.ConvertANTLRLineToPosition(table.line),})}diff --git a/backend/plugin/advisor/tidb/advisor_table_require_pk.go b/backend/plugin/advisor/tidb/advisor_table_require_pk.goindex c5a3d3a4bd..1d2f9a8be5 100644--- a/backend/plugin/advisor/tidb/advisor_table_require_pk.go+++ b/backend/plugin/advisor/tidb/advisor_table_require_pk.go@@ -11,7 +11,6 @@ import ("github.com/bytebase/bytebase/backend/common"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/advisor/code""github.com/bytebase/bytebase/backend/store/model")@@ -50,7 +49,7 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)tables: make(tablePK),line: make(map[string]int),originalMetadata: checkCtx.OriginalMetadata,- finalCatalog: checkCtx.FinalCatalog,+ finalMetadata: checkCtx.FinalMetadata,}for _, stmtNode := range root {@@ -67,7 +66,7 @@ type tableRequirePKChecker struct {tables tablePKline map[string]intoriginalMetadata *model.DatabaseMetadata- finalCatalog *catalog.DatabaseState+ finalMetadata *model.DatabaseMetadata}// Enter implements the ast.Visitor interface.diff --git a/backend/plugin/advisor/utils_for_tests.go b/backend/plugin/advisor/utils_for_tests.goindex 5e8864051c..f36040363d 100644--- a/backend/plugin/advisor/utils_for_tests.go+++ b/backend/plugin/advisor/utils_for_tests.go@@ -14,12 +14,12 @@ import ("github.com/pkg/errors""github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto""gopkg.in/yaml.v3""github.com/bytebase/bytebase/backend/component/sheet"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"- "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"database "github.com/bytebase/bytebase/backend/plugin/db""github.com/bytebase/bytebase/backend/store/model")@@ -213,11 +213,17 @@ func RunSQLReviewRuleTest(t *testing.T, rule SQLReviewRuleType, dbType storepb.E}// Create OriginalMetadata as DatabaseMetadata (read-only)- originalSchema := model.NewDatabaseSchema(catalogMetadata, nil, nil, dbType, isCaseSensitive)+ // Clone to avoid mutations affecting future test cases+ originalCatalogClone, ok := proto.Clone(catalogMetadata).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok, "failed to clone catalog metadata")+ originalSchema := model.NewDatabaseSchema(originalCatalogClone, nil, nil, dbType, isCaseSensitive)originalMetadata := originalSchema.GetDatabaseMetadata()- // Create FinalCatalog as DatabaseState (mutable for walk-through)- finalCatalog := catalog.NewDatabaseState(catalogMetadata, !isCaseSensitive, dbType)+ // Create FinalMetadata as DatabaseMetadata (mutable for walk-through)+ // Clone to avoid mutations affecting future test cases+ finalCatalogClone, ok := proto.Clone(catalogMetadata).(*storepb.DatabaseSchemaMetadata)+ require.True(t, ok, "failed to clone catalog metadata")+ finalMetadata := model.NewDatabaseMetadata(finalCatalogClone, isCaseSensitive, isCaseSensitive)payload, err := SetDefaultSQLReviewRulePayload(rule, dbType)require.NoError(t, err)@@ -235,7 +241,7 @@ func RunSQLReviewRuleTest(t *testing.T, rule SQLReviewRuleType, dbType storepb.ECollation: "",DBType: dbType,OriginalMetadata: originalMetadata,- FinalCatalog: finalCatalog,+ FinalMetadata: finalMetadata,Driver: nil,CurrentDatabase: curDB,DBSchema: schemaMetadata,diff --git a/backend/runner/plancheck/statement_advise_executor.go b/backend/runner/plancheck/statement_advise_executor.goindex a68b2517e6..f46b8a935e 100644--- a/backend/runner/plancheck/statement_advise_executor.go+++ b/backend/runner/plancheck/statement_advise_executor.go@@ -149,7 +149,7 @@ func (e *StatementAdviseExecutor) runReview(}}- originCatalog, finalCatalog, err := catalog.NewCatalogWithMetadata(dbSchema.GetMetadata(), instance.Metadata.GetEngine(), store.IsObjectCaseSensitive(instance))+ originMetadata, finalMetadata, err := catalog.NewCatalogWithMetadata(dbSchema.GetMetadata(), instance.Metadata.GetEngine(), store.IsObjectCaseSensitive(instance))if err != nil {return nil, common.Wrapf(err, common.Internal, "failed to create a catalog")}@@ -176,8 +176,8 @@ func (e *StatementAdviseExecutor) runReview(DBSchema: dbSchema.GetMetadata(),ChangeType: changeType,DBType: instance.Metadata.GetEngine(),- OriginalMetadata: originCatalog,- FinalCatalog: finalCatalog,+ OriginalMetadata: originMetadata,+ FinalMetadata: finalMetadata,Driver: connection,EnablePriorBackup: enablePriorBackup,ClassificationConfig: classificationConfig,diff --git a/backend/store/model/database.go b/backend/store/model/database.goindex 79a0fc8270..ec5dca347a 100644--- a/backend/store/model/database.go+++ b/backend/store/model/database.go@@ -459,6 +459,46 @@ func (d *DatabaseMetadata) GetProto() *storepb.DatabaseSchemaMetadata {return d.proto}+// SortProto sorts the proto structures to ensure deterministic output.+// This matches the behavior of the old DatabaseState.convertToDatabaseMetadata.+// This should be called before comparing protos in tests.+func (d *DatabaseMetadata) SortProto() {+ // Sort schemas by name+ slices.SortFunc(d.proto.Schemas, func(x, y *storepb.SchemaMetadata) int {+ return strings.Compare(x.Name, y.Name)+ })++ // Sort tables and indexes within each schema+ for _, schema := range d.proto.Schemas {+ // Sort tables by name+ slices.SortFunc(schema.Tables, func(x, y *storepb.TableMetadata) int {+ return strings.Compare(x.Name, y.Name)+ })++ // Sort indexes within each table by name+ for _, table := range schema.Tables {+ slices.SortFunc(table.Indexes, func(x, y *storepb.IndexMetadata) int {+ return strings.Compare(x.Name, y.Name)+ })++ // Sort columns by position+ slices.SortFunc(table.Columns, func(x, y *storepb.ColumnMetadata) int {+ if x.Position < y.Position {+ return -1+ } else if x.Position > y.Position {+ return 1+ }+ return 0+ })+ }++ // Sort views by name+ slices.SortFunc(schema.Views, func(x, y *storepb.ViewMetadata) int {+ return strings.Compare(x.Name, y.Name)+ })+ }+}+// GetIsObjectCaseSensitive returns whether object names (schemas, tables) are case-sensitive.func (d *DatabaseMetadata) GetIsObjectCaseSensitive() bool {return d.isObjectCaseSensitive@@ -469,6 +509,81 @@ func (d *DatabaseMetadata) GetIsDetailCaseSensitive() bool {return d.isDetailCaseSensitive}+// CreateSchema creates a new schema in the database.+// Returns the created SchemaMetadata.+func (d *DatabaseMetadata) CreateSchema(schemaName string) *SchemaMetadata {+ // Create new schema proto+ newSchemaProto := &storepb.SchemaMetadata{+ Name: schemaName,+ Tables: []*storepb.TableMetadata{},+ Views: []*storepb.ViewMetadata{},+ }++ // Add to proto's schema list+ d.proto.Schemas = append(d.proto.Schemas, newSchemaProto)++ // Create SchemaMetadata wrapper+ schemaMeta := &SchemaMetadata{+ isObjectCaseSensitive: d.isObjectCaseSensitive,+ isDetailCaseSensitive: d.isDetailCaseSensitive,+ internalTables: make(map[string]*TableMetadata),+ internalExternalTable: make(map[string]*ExternalTableMetadata),+ internalViews: make(map[string]*ViewMetadata),+ internalMaterializedView: make(map[string]*MaterializedViewMetadata),+ internalFunctions: []*FunctionMetadata{},+ internalProcedures: make(map[string]*ProcedureMetadata),+ internalPackages: make(map[string]*PackageMetadata),+ internalSequences: make(map[string]*SequenceMetadata),+ proto: newSchemaProto,+ }++ // Add to internal map+ var schemaID string+ if d.isObjectCaseSensitive {+ schemaID = schemaName+ } else {+ schemaID = strings.ToLower(schemaName)+ }+ d.internal[schemaID] = schemaMeta++ return schemaMeta+}++// DropSchema drops a schema from the database.+// Returns an error if the schema does not exist.+func (d *DatabaseMetadata) DropSchema(schemaName string) error {+ // Check if schema exists+ if d.GetSchema(schemaName) == nil {+ return errors.Errorf("schema %q does not exist in database %q", schemaName, d.name)+ }++ // Remove from internal map+ var schemaID string+ if d.isObjectCaseSensitive {+ schemaID = schemaName+ } else {+ schemaID = strings.ToLower(schemaName)+ }+ delete(d.internal, schemaID)++ // Remove from proto's schema list+ newSchemas := make([]*storepb.SchemaMetadata, 0, len(d.proto.Schemas)-1)+ for _, schema := range d.proto.Schemas {+ if d.isObjectCaseSensitive {+ if schema.Name != schemaName {+ newSchemas = append(newSchemas, schema)+ }+ } else {+ if !strings.EqualFold(schema.Name, schemaName) {+ newSchemas = append(newSchemas, schema)+ }+ }+ }+ d.proto.Schemas = newSchemas++ return nil+}+// LinkedDatabaseMetadata is the metadata for a linked database.type LinkedDatabaseMetadata struct {name string@@ -788,6 +903,203 @@ func (s *SchemaMetadata) DropTable(tableName string) error {return nil}+// RenameTable renames a table in the schema.+// Returns an error if the old table doesn't exist or new table already exists.+func (s *SchemaMetadata) RenameTable(oldName string, newName string) error {+ if oldName == newName {+ return nil+ }++ // Check if old table exists+ oldTable := s.GetTable(oldName)+ if oldTable == nil {+ return errors.Errorf("table %q does not exist in schema %q", oldName, s.proto.Name)+ }++ // Check if new table already exists+ if s.GetTable(newName) != nil {+ return errors.Errorf("table %q already exists in schema %q", newName, s.proto.Name)+ }++ // Remove from internal map using old name+ var oldTableID string+ if s.isObjectCaseSensitive {+ oldTableID = oldName+ } else {+ oldTableID = strings.ToLower(oldName)+ }+ delete(s.internalTables, oldTableID)++ // Update the table name in the proto+ oldTable.proto.Name = newName++ // Add back to internal map using new name+ var newTableID string+ if s.isObjectCaseSensitive {+ newTableID = newName+ } else {+ newTableID = strings.ToLower(newName)+ }+ s.internalTables[newTableID] = oldTable++ return nil+}++// CreateView creates a new view in the schema.+// Returns an error if the view already exists.+func (s *SchemaMetadata) CreateView(viewName string, definition string, dependencyColumns []*storepb.DependencyColumn) (*ViewMetadata, error) {+ // Check if view already exists+ if s.GetView(viewName) != nil {+ return nil, errors.Errorf("view %q already exists in schema %q", viewName, s.proto.Name)+ }++ // Create new view proto+ newViewProto := &storepb.ViewMetadata{+ Name: viewName,+ Definition: definition,+ DependencyColumns: dependencyColumns,+ }++ // Add to proto's view list+ s.proto.Views = append(s.proto.Views, newViewProto)++ // Create ViewMetadata wrapper+ viewMeta := &ViewMetadata{+ Definition: definition,+ proto: newViewProto,+ }++ // Add to internal map+ var viewID string+ if s.isObjectCaseSensitive {+ viewID = viewName+ } else {+ viewID = strings.ToLower(viewName)+ }+ s.internalViews[viewID] = viewMeta++ return viewMeta, nil+}++// DropView drops a view from the schema.+// Returns an error if the view does not exist.+func (s *SchemaMetadata) DropView(viewName string) error {+ // Check if view exists+ if s.GetView(viewName) == nil {+ return errors.Errorf("view %q does not exist in schema %q", viewName, s.proto.Name)+ }++ // Remove from internal map+ var viewID string+ if s.isObjectCaseSensitive {+ viewID = viewName+ } else {+ viewID = strings.ToLower(viewName)+ }+ delete(s.internalViews, viewID)++ // Remove from proto's view list+ newViews := make([]*storepb.ViewMetadata, 0, len(s.proto.Views)-1)+ for _, view := range s.proto.Views {+ if s.isObjectCaseSensitive {+ if view.Name != viewName {+ newViews = append(newViews, view)+ }+ } else {+ if !strings.EqualFold(view.Name, viewName) {+ newViews = append(newViews, view)+ }+ }+ }+ s.proto.Views = newViews++ return nil+}++// RenameView renames a view in the schema.+// Returns an error if the old view doesn't exist or new view already exists.+func (s *SchemaMetadata) RenameView(oldName string, newName string) error {+ if oldName == newName {+ return nil+ }++ // Check if old view exists+ oldView := s.GetView(oldName)+ if oldView == nil {+ return errors.Errorf("view %q does not exist in schema %q", oldName, s.proto.Name)+ }++ // Check if new view already exists+ if s.GetView(newName) != nil {+ return errors.Errorf("view %q already exists in schema %q", newName, s.proto.Name)+ }++ // Remove from internal map using old name+ var oldViewID string+ if s.isObjectCaseSensitive {+ oldViewID = oldName+ } else {+ oldViewID = strings.ToLower(oldName)+ }+ delete(s.internalViews, oldViewID)++ // Update the view name in the proto+ oldView.proto.Name = newName++ // Add back to internal map using new name+ var newViewID string+ if s.isObjectCaseSensitive {+ newViewID = newName+ } else {+ newViewID = strings.ToLower(newName)+ }+ s.internalViews[newViewID] = oldView++ return nil+}++// GetDependentViews returns all views that depend on the given table and column.+// This is used to check if a column can be dropped or if a table can be dropped.+func (s *SchemaMetadata) GetDependentViews(tableName string, columnName string) []string {+ var dependentViews []string++ for _, view := range s.internalViews {+ viewProto := view.GetProto()+ for _, dep := range viewProto.DependencyColumns {+ // Schema is implicitly the same schema, or explicitly matches+ tableMatches := false+ if s.isObjectCaseSensitive {+ tableMatches = dep.Table == tableName+ } else {+ tableMatches = strings.EqualFold(dep.Table, tableName)+ }++ if tableMatches {+ // If columnName is empty, we're checking for table dependency+ if columnName == "" {+ dependentViews = append(dependentViews, viewProto.Name)+ break+ }++ // Check column dependency+ if s.isDetailCaseSensitive {+ if dep.Column == columnName {+ dependentViews = append(dependentViews, viewProto.Name)+ break+ }+ } else {+ if strings.EqualFold(dep.Column, columnName) {+ dependentViews = append(dependentViews, viewProto.Name)+ break+ }+ }+ }+ }+ }++ return dependentViews+}+func buildTablesMetadata(table *storepb.TableMetadata, isDetailCaseSensitive bool) ([]*TableMetadata, []string) {if table == nil {return nil, nil@@ -993,6 +1305,11 @@ func (t *TableMetadata) CreateColumn(columnProto *storepb.ColumnMetadata) error// DropColumn drops a column from the table.// Returns an error if the column does not exist.func (t *TableMetadata) DropColumn(columnName string) error {+ return t.dropColumnInternal(columnName, true)+}++// dropColumnInternal is the internal implementation that allows controlling position renumbering.+func (t *TableMetadata) dropColumnInternal(columnName string, renumberPositions bool) error {// Check if column existsif t.GetColumn(columnName) == nil {return errors.Errorf("column %q does not exist in table %q", columnName, t.proto.Name)@@ -1025,6 +1342,165 @@ func (t *TableMetadata) DropColumn(columnName string) error {// Rebuild columns slicet.columns = newColumns+ // Renumber positions to be sequential (1-indexed) if requested+ // MySQL/TiDB: renumber positions (1, 2, 3, ...)+ // PostgreSQL: keep original positions (gaps are allowed)+ if renumberPositions {+ for i, col := range newColumns {+ col.Position = int32(i + 1)+ }+ }++ // Remove column from indexes that reference it+ for _, index := range t.internalIndexes {+ var newExpressions []string+ for _, expr := range index.proto.Expressions {+ if t.isDetailCaseSensitive {+ if expr != columnName {+ newExpressions = append(newExpressions, expr)+ }+ } else {+ if !strings.EqualFold(expr, columnName) {+ newExpressions = append(newExpressions, expr)+ }+ }+ }+ index.proto.Expressions = newExpressions+ }++ // Remove empty indexes (indexes that had all columns dropped)+ var indexesToRemove []string+ for indexName, index := range t.internalIndexes {+ if len(index.proto.Expressions) == 0 {+ indexesToRemove = append(indexesToRemove, indexName)+ }+ }+ for _, indexName := range indexesToRemove {+ delete(t.internalIndexes, indexName)+ }++ // Remove empty indexes from proto+ newIndexes := make([]*storepb.IndexMetadata, 0)+ for _, index := range t.proto.Indexes {+ if len(index.Expressions) > 0 {+ newIndexes = append(newIndexes, index)+ }+ }+ t.proto.Indexes = newIndexes++ return nil+}++// DropColumnWithoutRenumbering drops a column from the table without renumbering positions.+// This is used for PostgreSQL where column positions are stable (attnum) and shouldn't be renumbered.+// Returns an error if the column doesn't exist.+func (t *TableMetadata) DropColumnWithoutRenumbering(columnName string) error {+ return t.dropColumnInternal(columnName, false)+}++// DropColumnWithoutUpdatingIndexes drops a column from the table without updating index expressions.+// This is used when changing a column definition (MODIFY/CHANGE COLUMN) where we want to:+// 1. Drop the old column from the column list+// 2. Manually rename it in index expressions+// 3. Create a new column with the new definition+// Returns an error if the column doesn't exist.+func (t *TableMetadata) DropColumnWithoutUpdatingIndexes(columnName string) error {+ // Check if column exists+ if t.GetColumn(columnName) == nil {+ return errors.Errorf("column %q does not exist in table %q", columnName, t.proto.Name)+ }++ // Remove from internal map+ var columnID string+ if t.isDetailCaseSensitive {+ columnID = columnName+ } else {+ columnID = strings.ToLower(columnName)+ }+ delete(t.internalColumn, columnID)++ // Remove from proto's column list+ newColumns := make([]*storepb.ColumnMetadata, 0, len(t.proto.Columns)-1)+ for _, column := range t.proto.Columns {+ if t.isDetailCaseSensitive {+ if column.Name != columnName {+ newColumns = append(newColumns, column)+ }+ } else {+ if !strings.EqualFold(column.Name, columnName) {+ newColumns = append(newColumns, column)+ }+ }+ }+ t.proto.Columns = newColumns++ // Rebuild columns slice+ t.columns = newColumns++ // NOTE: We intentionally do NOT renumber positions here+ // The caller (tidbCompleteTableChangeColumn) will handle position adjustments+ // as part of the column reordering logic.++ // NOTE: We intentionally do NOT update index expressions here+ // The caller is responsible for updating index expressions as needed++ return nil+}++// RenameColumn renames a column in the table.+// Returns an error if the old column doesn't exist or new column already exists.+func (t *TableMetadata) RenameColumn(oldName string, newName string) error {+ if oldName == newName {+ return nil+ }++ // Check if old column exists+ oldColumn := t.GetColumn(oldName)+ if oldColumn == nil {+ return errors.Errorf("column %q does not exist in table %q", oldName, t.proto.Name)+ }++ // Check if new column already exists+ if t.GetColumn(newName) != nil {+ return errors.Errorf("column %q already exists in table %q", newName, t.proto.Name)+ }++ // Remove from internal map using old name+ var oldColumnID string+ if t.isDetailCaseSensitive {+ oldColumnID = oldName+ } else {+ oldColumnID = strings.ToLower(oldName)+ }+ delete(t.internalColumn, oldColumnID)++ // Update the column name in the proto+ oldColumn.Name = newName++ // Add back to internal map using new name+ var newColumnID string+ if t.isDetailCaseSensitive {+ newColumnID = newName+ } else {+ newColumnID = strings.ToLower(newName)+ }+ t.internalColumn[newColumnID] = oldColumn++ // Update column references in indexes+ for _, index := range t.internalIndexes {+ for i, expr := range index.proto.Expressions {+ if t.isDetailCaseSensitive {+ if expr == oldName {+ index.proto.Expressions[i] = newName+ }+ } else {+ if strings.EqualFold(expr, oldName) {+ index.proto.Expressions[i] = newName+ }+ }+ }+ }+return nil}@@ -1093,6 +1569,109 @@ func (i *IndexMetadata) ExpressionList() []string {return i.proto.Expressions}+// CreateIndex creates a new index in the table.+// Returns an error if the index already exists.+func (t *TableMetadata) CreateIndex(indexProto *storepb.IndexMetadata) error {+ // Check if index already exists+ if t.GetIndex(indexProto.Name) != nil {+ return errors.Errorf("index %q already exists in table %q", indexProto.Name, t.proto.Name)+ }++ // Add to proto's index list+ t.proto.Indexes = append(t.proto.Indexes, indexProto)++ // Add to internal map+ var indexID string+ if t.isDetailCaseSensitive {+ indexID = indexProto.Name+ } else {+ indexID = strings.ToLower(indexProto.Name)+ }+ t.internalIndexes[indexID] = &IndexMetadata{+ tableProto: t.proto,+ proto: indexProto,+ }++ return nil+}++// DropIndex drops an index from the table.+// Returns an error if the index does not exist.+func (t *TableMetadata) DropIndex(indexName string) error {+ // Check if index exists+ if t.GetIndex(indexName) == nil {+ return errors.Errorf("index %q does not exist in table %q", indexName, t.proto.Name)+ }++ // Remove from internal map+ var indexID string+ if t.isDetailCaseSensitive {+ indexID = indexName+ } else {+ indexID = strings.ToLower(indexName)+ }+ delete(t.internalIndexes, indexID)++ // Remove from proto's index list+ newIndexes := make([]*storepb.IndexMetadata, 0, len(t.proto.Indexes)-1)+ for _, index := range t.proto.Indexes {+ if t.isDetailCaseSensitive {+ if index.Name != indexName {+ newIndexes = append(newIndexes, index)+ }+ } else {+ if !strings.EqualFold(index.Name, indexName) {+ newIndexes = append(newIndexes, index)+ }+ }+ }+ t.proto.Indexes = newIndexes++ return nil+}++// RenameIndex renames an index in the table.+// Returns an error if the old index doesn't exist or new index already exists.+func (t *TableMetadata) RenameIndex(oldName string, newName string) error {+ if oldName == newName {+ return nil+ }++ // Check if old index exists+ oldIndex := t.GetIndex(oldName)+ if oldIndex == nil {+ return errors.Errorf("index %q does not exist in table %q", oldName, t.proto.Name)+ }++ // Check if new index already exists+ if t.GetIndex(newName) != nil {+ return errors.Errorf("index %q already exists in table %q", newName, t.proto.Name)+ }++ // Remove from internal map using old name+ var oldIndexID string+ if t.isDetailCaseSensitive {+ oldIndexID = oldName+ } else {+ oldIndexID = strings.ToLower(oldName)+ }+ delete(t.internalIndexes, oldIndexID)++ // Update the index name in the proto+ oldIndex.proto.Name = newName++ // Add back to internal map using new name+ var newIndexID string+ if t.isDetailCaseSensitive {+ newIndexID = newName+ } else {+ newIndexID = strings.ToLower(newName)+ }+ t.internalIndexes[newIndexID] = oldIndex++ return nil+}+// ViewMetadata is the metadata for a view.type ViewMetadata struct {Definition string