Skip to content

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

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.go
index 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 []*v
func (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.go
index 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 any
Rule *storepb.SQLReviewRule
OriginalMetadata *model.DatabaseMetadata
- FinalCatalog *catalog.DatabaseState
+ FinalMetadata *model.DatabaseMetadata
Driver *sql.DB
// CurrentDatabase is the current database.
diff --git a/backend/plugin/advisor/catalog/catalog.go b/backend/plugin/advisor/catalog/catalog.go
index 4c0a9a4593..67d52b0a78 100644
--- a/backend/plugin/advisor/catalog/catalog.go
+++ b/backend/plugin/advisor/catalog/catalog.go
@@ -2,6 +2,8 @@
package catalog
import (
+ "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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.yaml
deleted file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/catalog/test/pg_walk_through.yaml b/backend/plugin/advisor/catalog/test/pg_walk_through.yaml
index 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.go
index ade3687870..b9e696e201 100644
--- a/backend/plugin/advisor/catalog/walk_through.go
+++ b/backend/plugin/advisor/catalog/walk_through.go
@@ -2,13 +2,13 @@ package catalog
import (
"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.go
index 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 = err
return
}
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 = err
return
@@ -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 = err
return
@@ -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 = collation
default:
}
}
@@ -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 = err
return
}
@@ -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 = err
return
}
}
// add constraint.
case item.TableConstraintDef() != nil:
- if err := table.mysqlCreateConstraint(item.TableConstraintDef()); err != nil {
+ if err := mysqlCreateConstraint(table, item.TableConstraintDef()); err != nil {
l.err = err
return
}
@@ -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 = err
return
}
@@ -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 = err
return
}
@@ -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 = err
return
}
// 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 = err
return
}
@@ -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 = err
return
@@ -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 = err
return
@@ -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 = err
return
}
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 = err
return
}
@@ -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 = charset
case option.CreateDatabaseOption().DefaultCollation() != nil && option.CreateDatabaseOption().DefaultCollation().CollationName() != nil:
collation := mysqlparser.NormalizeMySQLCollationName(option.CreateDatabaseOption().DefaultCollation().CollationName())
- l.databaseState.SetCollation(collation)
+ l.databaseMetadata.GetProto().Collation = collation
default:
// 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.RenameTableStatemen
return
}
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 = err
return
@@ -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 = true
case visibility.INVISIBLE_SYMBOL() != nil:
- index.visible = false
+ indexProto.Visible = false
default:
// 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 + 1
break
}
}
+ 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.ITableConstraintD
indexName = 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.ITableConstraintD
indexName = 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.ITableConstraintD
indexName = 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) string
return "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.IFieldD
characterSet = 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.IFieldD
if !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 bool
if 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 constraint
for _, 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 statement
for _, 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 visibility
for _, 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 visibility
for _, 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)] = pk
return 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.go
index 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 walkthrough
parseResult, 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 state
listener := &pgCatalogListener{
BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},
databaseState: d,
}
-
// Walk through the parse tree
antlr.ParseTreeWalkerDefault.Walk(listener, root)
-
// Return any error encountered during walk
if 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.DatabaseMetadata
err *WalkThroughError
currentLine 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 schema
qualifiedNames := ctx.AllQualified_name()
if len(qualifiedNames) == 0 {
return
}
-
tableName := extractTableName(qualifiedNames[0])
schemaName := extractSchemaName(qualifiedNames[0])
-
if tableName == "" {
return
}
-
// Check database name if specified
databaseName := 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 clause
ifNotExists := ctx.IF_P() != nil && ctx.NOT() != nil && ctx.EXISTS() != nil
if 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 definitions
if 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 name
var columnName string
if columnDef.Colid() != nil {
@@ -163,33 +146,26 @@ func pgCreateColumn(schema *SchemaState, table *TableState, columnDef parser.ICo
if 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 type
var columnType string
if 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 constraints
if columnDef.Colquallist() != nil {
allQuals := columnDef.Colquallist().AllColconstraint()
@@ -198,21 +174,18 @@ func pgCreateColumn(schema *SchemaState, table *TableState, columnDef parser.ICo
continue
}
elem := qual.Colconstraintelem()
-
// Handle NOT NULL
if elem.NOT() != nil && elem.NULL_P() != nil {
- columnState.nullable = false
+ col.Nullable = false
}
-
// Handle DEFAULT
if elem.DEFAULT() != nil {
// Extract default expression from B_expr
if elem.B_expr() != nil {
defaultValue := elem.B_expr().GetText()
- columnState.defaultValue = defaultValue
+ col.Default = defaultValue
}
}
-
// Handle PRIMARY KEY
if elem.PRIMARY() != nil && elem.KEY() != nil {
constraintName := ""
@@ -220,68 +193,65 @@ func pgCreateColumn(schema *SchemaState, table *TableState, columnDef parser.ICo
constraintName = 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 UNIQUE
if elem.UNIQUE() != nil && (elem.PRIMARY() == nil || elem.KEY() == nil) {
constraintName := ""
if qual.Name() != nil {
constraintName = pgparser.NormalizePostgreSQLName(qual.Name())
}
-
// Generate index name if not specified
if 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 name
constraintName := ""
if constraint.Name() != nil {
constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())
}
-
// Handle PRIMARY KEY constraint
if 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 NULL
for _, 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 provided
pkName := constraintName
if 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 constraint
if 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 specified
indexName := constraintName
if 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 exist
for _, 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) name
relationExpr := 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 EXISTS
ifNotExists := ctx.IF_P() != nil && ctx.NOT() != nil && ctx.EXISTS() != nil
-
// Extract column list
var columnList []string
if 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 provided
isUnique := ctx.Opt_unique() != nil && ctx.Opt_unique().UNIQUE() != nil
wasAutoGenerated := 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 type
indexType := "btree" // default
if 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 name
if 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 commands
if 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 COLUMN
if 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 CONSTRAINT
if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {
l.alterTableAddConstraint(schema, table, cmd.Tableconstraint())
return
}
-
// Handle DROP CONSTRAINT
if 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 COLUMN
if 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 commands
if cmd.ALTER() != nil && cmd.Opt_column() != nil {
allColids := cmd.AllColid()
if len(allColids) > 0 {
columnName := pgparser.NormalizePostgreSQLColid(allColids[0])
-
// Check for SET DATA TYPE
if cmd.TYPE_P() != nil && cmd.Typename() != nil {
typeString := extractTypeName(cmd.Typename())
l.alterTableAlterColumnType(schema, table, columnName, typeString)
return
}
-
// Check for SET/DROP DEFAULT
if 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 NULL
if 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 column
var 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 type
var typeString string
if 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 *Tabl
continue
}
elem := qual.Colconstraintelem()
-
// Handle NOT NULL
if elem.NOT() != nil && elem.NULL_P() != nil {
- columnState.nullable = false
+ col.Nullable = false
}
-
// Handle DEFAULT
if elem.DEFAULT() != nil {
if elem.B_expr() != nil {
defaultValue := elem.B_expr().GetText()
- columnState.defaultValue = defaultValue
+ col.Default = defaultValue
}
}
-
// Handle UNIQUE - creates an index
if elem.UNIQUE() != nil && (elem.PRIMARY() == nil || elem.KEY() == nil) {
var constraintName string
@@ -798,25 +721,25 @@ func (l *pgCatalogListener) alterTableAddColumn(schema *SchemaState, table *Tabl
constraintName = 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 index
if (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 *Tabl
constraintName = 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 TABLE
err := 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 exists
return 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 EXISTS
ifExists := ctx.IF_P() != nil && ctx.EXISTS() != nil
-
// Check object type and get list of names
if ctx.Object_type_any_name() != nil {
objType := ctx.Object_type_any_name()
-
if objType.TABLE() != nil {
// DROP TABLE
if 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 name
if 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 string
if len(parts) == 1 {
schemaName = ""
@@ -1107,82 +998,71 @@ func (l *pgCatalogListener) dropTable(anyName parser.IAny_nameContext, ifExists
schemaName = 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 string
if len(parts) == 1 {
schemaName = ""
@@ -1191,33 +1071,30 @@ func (l *pgCatalogListener) dropIndex(anyName parser.IAny_nameContext, ifExists
schemaName = 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, ifExis
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)
+ // 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 present
var tableName, schemaName string
if 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 rename
if 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 rename
if 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 newname
if 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 name
if 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 names
typeText := typename.GetText()
-
// Normalize common PostgreSQL type aliases
switch 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.Builder
builder.WriteString(tableName)
-
expressionID := 0
for _, 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 1
for 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.go
index 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 catalog
import (
"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 protobuf
switch 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.O
newTableName := 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 validation
return 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.Value
case tidbast.DatabaseOptionCollate:
- d.collation = option.Value
+ d.GetProto().Collation = option.Value
default:
// Other database options
}
@@ -161,35 +162,38 @@ func (d *DatabaseState) alterDatabase(node *tidbast.AlterDatabaseStmt) *WalkThro
return 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) *WalkThroughErr
for _, option := range spec.Options {
switch option.Tp {
case tidbast.TableOptionCollate:
- table.collation = option.StrValue
+ table.GetProto().Collation = option.StrValue
case tidbast.TableOptionComment:
- table.comment = option.StrValue
+ table.GetProto().Comment = option.StrValue
case tidbast.TableOptionEngine:
- table.engine = option.StrValue
+ table.GetProto().Engine = option.StrValue
default:
// Other table options
}
@@ -246,61 +250,101 @@ func (d *DatabaseState) alterTable(node *tidbast.AlterTableStmt) *WalkThroughErr
if 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) *WalkThroughErr
return 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 = true
case tidbast.IndexVisibilityInvisible:
- index.visible = false
+ index.GetProto().Visible = false
default:
// 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 DEFAULT
if 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) *WalkThrough
Content: 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 specified
var localPosition *tidbast.ColumnPosition
if position == nil {
localPosition = &tidbast.ColumnPosition{Tp: tidbast.ColumnPositionNone}
} else {
- // Create a copy of the position to avoid modifying the original
localPosition = &tidbast.ColumnPosition{
Tp: position.Tp,
RelativeColumn: position.RelativeColumn,
}
}
+ // If position not specified, preserve current position by finding the column before it
if 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, nil
case tidbast.ColumnPositionFirst:
- for _, column := range t.columnSet {
- column.position++
+ for _, column := range t.GetColumns() {
+ column.Position++
}
return 1, nil
case 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, nil
default:
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) *WalkThroughErr
Content: 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] = table
return 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 := false
for _, column := range node.Cols {
@@ -583,19 +673,19 @@ func (d *DatabaseState) createTable(node *tidbast.CreateTableStmt) *WalkThroughE
return &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) *WalkThroughE
return 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 constraints
case 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) *WalkThrou
return 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 []string
for _, key := range keyList {
if key.Expr != nil {
@@ -663,18 +753,18 @@ func (t *TableState) validateAndGetKeyStringList(keyList []*tidbast.IndexPartSpe
res = 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()) + 1
if 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 := false
for _, 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 = false
case tidbast.ColumnOptionAutoIncrement:
// we do not deal with AUTO-INCREMENT
case 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 *tidba
Content: 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 = true
case tidbast.ColumnOptionOnUpdate:
// we do not deal with ON UPDATE
if 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 *tidba
Content: fmt.Sprintf("Failed to deparse comment: %v", err),
}
}
- col.comment = comment
+ col.Comment = comment
case tidbast.ColumnOptionGenerated:
// we do not deal with GENERATED ALWAYS AS
case tidbast.ColumnOptionReference:
// MySQL will ignore the inline REFERENCE
// https://dev.mysql.com/doc/refman/8.0/en/create-table.html
case tidbast.ColumnOptionCollate:
- col.collation = option.StrValue
+ col.Collation = option.StrValue
case tidbast.ColumnOptionCheck:
// we do not deal with CHECK constraint
case 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)] = pk
return nil
}
diff --git a/backend/plugin/advisor/catalog/walk_through_test.go b/backend/plugin/advisor/catalog/walk_through_test.go
index 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, or
for _, test := range tests {
var proto *storepb.DatabaseSchemaMetadata
if 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.Engin
for _, test := range tests {
var proto *storepb.DatabaseSchemaMetadata
if 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 parser
parseResult, 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.go
index 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.go
index 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 rule
checker := 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.go
index 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.go
index 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 rule
checker := 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.go
index 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 rule
checker := 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.CreateTable
if 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.AlterTableCo
if 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.go
index 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.go
index 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 {
BaseRule
statementsText string
- finalCatalog *catalog.DatabaseState
+ finalMetadata *model.DatabaseMetadata
// Simple Solution: Track last mention of each table
tableMentions 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.yaml
index 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: 1
want:
- status: 2
@@ -8,10 +12,12 @@
title: naming.index.pk
content: 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: 2
column: 0
endposition: 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: 1
want:
- status: 2
@@ -19,7 +25,7 @@
title: naming.index.pk
content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "udmhjtnsaablcmjhqcznfiwtnevcehcvw"
startposition:
- line: 1
+ line: 2
column: 0
endposition: 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_index
changeType: 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_index
changeType: 1
want:
- status: 2
@@ -55,7 +65,7 @@
title: naming.index.pk
content: 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: 2
column: 0
endposition: null
- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO pk_tech_book_id_name
diff --git a/backend/plugin/advisor/pg/test_helper.go b/backend/plugin/advisor/pg/test_helper.go
index 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 rules
payload, err := advisor.SetDefaultSQLReviewRulePayload(rule, dbType)
@@ -78,7 +85,7 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
require.NoError(t, err, "Failed to parse SQL: %s", tc.Statement)
// Always walk through the catalog to build metadata.
- err = catalog.WalkThrough(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, dbTyp
Statements: 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.go
index 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.DatabaseSchemaMetadata
DBType storepb.Engine
OriginalMetadata *model.DatabaseMetadata
- FinalCatalog *catalog.DatabaseState
+ FinalMetadata *model.DatabaseMetadata
Driver *sql.DB
EnablePriorBackup bool
ClassificationConfig *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.go
index 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.go
index 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.C
return 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.go
index 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 tablePK
line map[string]int
originalMetadata *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.go
index 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.E
Collation: "",
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.go
index 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.go
index 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 exists
if 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 slice
t.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