diff --git a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedChecker.java b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedChecker.java index ccae4d9fc0c98..c42b346603260 100644 --- a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedChecker.java +++ b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedChecker.java @@ -28,9 +28,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment; import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.AlterTableStatement; -import java.util.Collection; import java.util.Optional; -import java.util.stream.Collectors; /** * Alter table supported checker for sharding. @@ -45,10 +43,16 @@ public boolean isCheck(final SQLStatementContext sqlStatementContext) { @Override public void check(final ShardingRule rule, final ShardingSphereDatabase database, final ShardingSphereSchema currentSchema, final CommonSQLStatementContext sqlStatementContext) { AlterTableStatement sqlStatement = (AlterTableStatement) sqlStatementContext.getSqlStatement(); - Collection tableNames = sqlStatementContext.getTablesContext().getSimpleTables().stream() - .map(each -> each.getTableName().getIdentifier().getValue()).collect(Collectors.toList()); Optional renameTable = sqlStatement.getRenameTable(); - ShardingSpherePreconditions.checkState(!renameTable.isPresent() || !rule.containsShardingTable(tableNames), - () -> new UnsupportedShardingOperationException("ALTER TABLE ... RENAME TO ...", renameTable.map(optional -> optional.getTableName().getIdentifier().getValue()).orElse(""))); + if (!renameTable.isPresent()) { + return; + } + String newTableName = renameTable.get().getTableName().getIdentifier().getValue(); + // Validate new table name does not conflict with existing sharding tables + ShardingSpherePreconditions.checkState(!rule.isShardingTable(newTableName), + () -> new UnsupportedShardingOperationException("ALTER TABLE ... RENAME TO ...", newTableName)); + // Validate new table name does not exist in current schema + ShardingSpherePreconditions.checkState(!currentSchema.containsTable(newTableName), + () -> new UnsupportedShardingOperationException("ALTER TABLE ... RENAME TO ...", newTableName)); } } diff --git a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedChecker.java b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedChecker.java index 153d6ef44b447..009c4480e761f 100644 --- a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedChecker.java +++ b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedChecker.java @@ -25,13 +25,8 @@ import org.apache.shardingsphere.sharding.exception.syntax.UnsupportedShardingOperationException; import org.apache.shardingsphere.sharding.rule.ShardingRule; import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.table.RenameTableDefinitionSegment; -import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment; import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.RenameTableStatement; -import java.util.Collection; -import java.util.List; -import java.util.stream.Collectors; - /** * Rename table supported checker for sharding. */ @@ -44,11 +39,15 @@ public boolean isCheck(final SQLStatementContext sqlStatementContext) { @Override public void check(final ShardingRule rule, final ShardingSphereDatabase database, final ShardingSphereSchema currentSchema, final SQLStatementContext sqlStatementContext) { - Collection tableNames = sqlStatementContext.getTablesContext().getSimpleTables().stream() - .map(each -> each.getTableName().getIdentifier().getValue()).collect(Collectors.toList()); - List renameTables = ((RenameTableStatement) sqlStatementContext.getSqlStatement()) - .getRenameTables().stream().map(RenameTableDefinitionSegment::getRenameTable).collect(Collectors.toList()); - ShardingSpherePreconditions.checkState(renameTables.isEmpty() || !rule.containsShardingTable(tableNames), - () -> new UnsupportedShardingOperationException("RENAME TABLE", renameTables.get(0).getTableName().getIdentifier().getValue())); + RenameTableStatement sqlStatement = (RenameTableStatement) sqlStatementContext.getSqlStatement(); + for (RenameTableDefinitionSegment each : sqlStatement.getRenameTables()) { + String newTableName = each.getRenameTable().getTableName().getIdentifier().getValue(); + // Validate new table name does not conflict with existing sharding tables + ShardingSpherePreconditions.checkState(!rule.isShardingTable(newTableName), + () -> new UnsupportedShardingOperationException("RENAME TABLE", newTableName)); + // Validate new table name does not exist in current schema + ShardingSpherePreconditions.checkState(!currentSchema.containsTable(newTableName), + () -> new UnsupportedShardingOperationException("RENAME TABLE", newTableName)); + } } } diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedCheckerTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedCheckerTest.java index 413e7aa61e7ff..15117293263d6 100644 --- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedCheckerTest.java +++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingAlterTableSupportedCheckerTest.java @@ -20,6 +20,7 @@ import org.apache.shardingsphere.database.connector.core.type.DatabaseType; import org.apache.shardingsphere.infra.binder.context.statement.type.CommonSQLStatementContext; import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase; +import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema; import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader; import org.apache.shardingsphere.sharding.exception.syntax.UnsupportedShardingOperationException; import org.apache.shardingsphere.sharding.rule.ShardingRule; @@ -35,8 +36,7 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.Arrays; - +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -54,12 +54,46 @@ class ShardingAlterTableSupportedCheckerTest { private ShardingSphereDatabase database; @Test - void assertCheckWithRenameTableWithShardingTable() { + void assertCheckWithRenameTableWhenNewTableNameConflictsWithShardingTable() { + AlterTableStatement sqlStatement = new AlterTableStatement(databaseType); + sqlStatement.setTable(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_order")))); + sqlStatement.setRenameTable(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_user")))); + CommonSQLStatementContext sqlStatementContext = new CommonSQLStatementContext(sqlStatement); + ShardingSphereSchema schema = mock(ShardingSphereSchema.class); + when(rule.isShardingTable("t_user")).thenReturn(true); + when(schema.containsTable("t_user")).thenReturn(false); + assertThrows(UnsupportedShardingOperationException.class, () -> new ShardingAlterTableSupportedChecker().check(rule, database, schema, sqlStatementContext)); + } + + @Test + void assertCheckWithRenameTableWhenNewTableNameConflictsWithExistingTable() { + AlterTableStatement sqlStatement = new AlterTableStatement(databaseType); + sqlStatement.setTable(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_order")))); + sqlStatement.setRenameTable(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_existing")))); + CommonSQLStatementContext sqlStatementContext = new CommonSQLStatementContext(sqlStatement); + ShardingSphereSchema schema = mock(ShardingSphereSchema.class); + when(rule.isShardingTable("t_existing")).thenReturn(false); + when(schema.containsTable("t_existing")).thenReturn(true); + assertThrows(UnsupportedShardingOperationException.class, () -> new ShardingAlterTableSupportedChecker().check(rule, database, schema, sqlStatementContext)); + } + + @Test + void assertCheckWithRenameTableSuccess() { AlterTableStatement sqlStatement = new AlterTableStatement(databaseType); sqlStatement.setTable(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_order")))); sqlStatement.setRenameTable(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_order_new")))); CommonSQLStatementContext sqlStatementContext = new CommonSQLStatementContext(sqlStatement); - when(rule.containsShardingTable(Arrays.asList("t_order", "t_order_new"))).thenReturn(true); - assertThrows(UnsupportedShardingOperationException.class, () -> new ShardingAlterTableSupportedChecker().check(rule, database, mock(), sqlStatementContext)); + ShardingSphereSchema schema = mock(ShardingSphereSchema.class); + when(rule.isShardingTable("t_order_new")).thenReturn(false); + when(schema.containsTable("t_order_new")).thenReturn(false); + assertDoesNotThrow(() -> new ShardingAlterTableSupportedChecker().check(rule, database, schema, sqlStatementContext)); + } + + @Test + void assertCheckWithoutRenameTable() { + AlterTableStatement sqlStatement = new AlterTableStatement(databaseType); + sqlStatement.setTable(new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue("t_order")))); + CommonSQLStatementContext sqlStatementContext = new CommonSQLStatementContext(sqlStatement); + assertDoesNotThrow(() -> new ShardingAlterTableSupportedChecker().check(rule, database, mock(ShardingSphereSchema.class), sqlStatementContext)); } } diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedCheckerTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedCheckerTest.java index 7a940bc5cabf5..f93f105c988dc 100644 --- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedCheckerTest.java +++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/sql/ddl/ShardingRenameTableSupportedCheckerTest.java @@ -19,6 +19,7 @@ import org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext; import org.apache.shardingsphere.infra.binder.context.statement.type.CommonSQLStatementContext; +import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema; import org.apache.shardingsphere.sharding.exception.syntax.UnsupportedShardingOperationException; import org.apache.shardingsphere.sharding.rule.ShardingRule; import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.table.RenameTableDefinitionSegment; @@ -32,33 +33,75 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.Arrays; import java.util.Collections; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.ArgumentMatchers.argThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.LENIENT) class ShardingRenameTableSupportedCheckerTest { @Mock private ShardingRule rule; @Test - void assertCheckShardingTable() { + void assertCheckWhenNewTableNameConflictsWithShardingTable() { + SQLStatementContext sqlStatementContext = createRenameTableStatementContext("t_order", "t_user"); + ShardingSphereSchema schema = mock(ShardingSphereSchema.class); + when(rule.isShardingTable("t_user")).thenReturn(true); + when(schema.containsTable("t_user")).thenReturn(false); + assertThrows(UnsupportedShardingOperationException.class, () -> new ShardingRenameTableSupportedChecker().check(rule, mock(), schema, sqlStatementContext)); + } + + @Test + void assertCheckWhenNewTableNameConflictsWithExistingTable() { + SQLStatementContext sqlStatementContext = createRenameTableStatementContext("t_order", "t_existing"); + ShardingSphereSchema schema = mock(ShardingSphereSchema.class); + when(rule.isShardingTable("t_existing")).thenReturn(false); + when(schema.containsTable("t_existing")).thenReturn(true); + assertThrows(UnsupportedShardingOperationException.class, () -> new ShardingRenameTableSupportedChecker().check(rule, mock(), schema, sqlStatementContext)); + } + + @Test + void assertCheckSuccess() { SQLStatementContext sqlStatementContext = createRenameTableStatementContext("t_order", "t_user_order"); - when(rule.containsShardingTable(argThat(tableNames -> tableNames.contains("t_order") || tableNames.contains("t_user_order")))).thenReturn(true); - assertThrows(UnsupportedShardingOperationException.class, () -> new ShardingRenameTableSupportedChecker().check(rule, mock(), mock(), sqlStatementContext)); + ShardingSphereSchema schema = mock(ShardingSphereSchema.class); + when(rule.isShardingTable("t_user_order")).thenReturn(false); + when(schema.containsTable("t_user_order")).thenReturn(false); + assertDoesNotThrow(() -> new ShardingRenameTableSupportedChecker().check(rule, mock(), schema, sqlStatementContext)); } @Test - void assertCheckNormalCase() { - SQLStatementContext sqlStatementContext = createRenameTableStatementContext("t_not_sharding_table", "t_not_sharding_table_new"); - assertDoesNotThrow(() -> new ShardingRenameTableSupportedChecker().check(rule, mock(), mock(), sqlStatementContext)); + void assertCheckWithMultipleTables() { + RenameTableStatement sqlStatement = mock(RenameTableStatement.class); + RenameTableDefinitionSegment segment1 = createRenameTableDefinitionSegment("t_order", "t_order_new"); + RenameTableDefinitionSegment segment2 = createRenameTableDefinitionSegment("t_user", "t_user_new"); + when(sqlStatement.getRenameTables()).thenReturn(Arrays.asList(segment1, segment2)); + when(sqlStatement.getAttributes()).thenReturn(new SQLStatementAttributes(new TableSQLStatementAttribute(Arrays.asList( + segment1.getTable(), segment1.getRenameTable(), segment2.getTable(), segment2.getRenameTable())))); + SQLStatementContext sqlStatementContext = new CommonSQLStatementContext(sqlStatement); + ShardingSphereSchema schema = mock(ShardingSphereSchema.class); + when(rule.isShardingTable("t_order_new")).thenReturn(false); + when(rule.isShardingTable("t_user_new")).thenReturn(false); + when(schema.containsTable("t_order_new")).thenReturn(false); + when(schema.containsTable("t_user_new")).thenReturn(false); + assertDoesNotThrow(() -> new ShardingRenameTableSupportedChecker().check(rule, mock(), schema, sqlStatementContext)); + } + + private RenameTableDefinitionSegment createRenameTableDefinitionSegment(final String originTableName, final String newTableName) { + RenameTableDefinitionSegment renameTableDefinitionSegment = new RenameTableDefinitionSegment(0, 0); + SimpleTableSegment table = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue(originTableName))); + SimpleTableSegment renameTable = new SimpleTableSegment(new TableNameSegment(0, 0, new IdentifierValue(newTableName))); + renameTableDefinitionSegment.setTable(table); + renameTableDefinitionSegment.setRenameTable(renameTable); + return renameTableDefinitionSegment; } private SQLStatementContext createRenameTableStatementContext(final String originTableName, final String newTableName) { diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java index 9083f2662a53e..2cc53917f3432 100644 --- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java +++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/AlterTablePushDownMetaDataRefresher.java @@ -48,16 +48,18 @@ public void refresh(final MetaDataManagerPersistService metaDataManagerPersistSe final String schemaName, final DatabaseType databaseType, final AlterTableStatement sqlStatement, final ConfigurationProperties props) throws SQLException { String tableName = TableRefreshUtils.getTableName(sqlStatement.getTable().getTableName().getIdentifier(), databaseType); Collection alteredTables = new LinkedList<>(); - Collection droppedTables = new LinkedList<>(); if (sqlStatement.getRenameTable().isPresent()) { String renameTable = sqlStatement.getRenameTable().get().getTableName().getIdentifier().getValue(); alteredTables.add(getTable(database, logicDataSourceName, schemaName, renameTable, props)); - droppedTables.add(tableName); + // Add new table to metadata first + metaDataManagerPersistService.alterTables(database, schemaName, alteredTables); + // Then drop old table and update single table rules + Map renameTableMap = Collections.singletonMap(tableName, renameTable); + metaDataManagerPersistService.renameTables(database, schemaName, renameTableMap); } else { alteredTables.add(getTable(database, logicDataSourceName, schemaName, tableName, props)); + metaDataManagerPersistService.alterTables(database, schemaName, alteredTables); } - metaDataManagerPersistService.alterTables(database, schemaName, alteredTables); - metaDataManagerPersistService.dropTables(database, schemaName, droppedTables); } private ShardingSphereTable getTable(final ShardingSphereDatabase database, final String logicDataSourceName, final String schemaName, diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java index 88cbe395cbb6b..8f73c5a678be0 100644 --- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java +++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/refresher/pushdown/type/table/RenameTablePushDownMetaDataRefresher.java @@ -28,7 +28,9 @@ import java.sql.SQLException; import java.util.Collection; +import java.util.LinkedHashMap; import java.util.LinkedList; +import java.util.Map; /** * Rename table push down meta data refresher. @@ -39,16 +41,18 @@ public final class RenameTablePushDownMetaDataRefresher implements PushDownMetaD public void refresh(final MetaDataManagerPersistService metaDataManagerPersistService, final ShardingSphereDatabase database, final String logicDataSourceName, final String schemaName, final DatabaseType databaseType, final RenameTableStatement sqlStatement, final ConfigurationProperties props) throws SQLException { Collection alteredTables = new LinkedList<>(); - Collection droppedTables = new LinkedList<>(); + Map renameTableMap = new LinkedHashMap<>(); for (RenameTableDefinitionSegment each : sqlStatement.getRenameTables()) { - String toBeRenamedTableName = each.getTable().getTableName().getIdentifier().getValue(); - ShardingSphereTable toBeRenamedTable = database.getSchema(schemaName).getTable(toBeRenamedTableName); - alteredTables.add(new ShardingSphereTable( - each.getRenameTable().getTableName().getIdentifier().getValue(), toBeRenamedTable.getAllColumns(), toBeRenamedTable.getAllIndexes(), toBeRenamedTable.getAllConstraints())); - droppedTables.add(toBeRenamedTableName); + String oldTableName = each.getTable().getTableName().getIdentifier().getValue(); + String newTableName = each.getRenameTable().getTableName().getIdentifier().getValue(); + ShardingSphereTable toBeRenamedTable = database.getSchema(schemaName).getTable(oldTableName); + alteredTables.add(new ShardingSphereTable(newTableName, toBeRenamedTable.getAllColumns(), toBeRenamedTable.getAllIndexes(), toBeRenamedTable.getAllConstraints())); + renameTableMap.put(oldTableName, newTableName); } + // Add new tables to metadata first metaDataManagerPersistService.alterTables(database, schemaName, alteredTables); - metaDataManagerPersistService.dropTables(database, schemaName, droppedTables); + // Then drop old tables and update single table rules + metaDataManagerPersistService.renameTables(database, schemaName, renameTableMap); } @Override diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java index d4e0475f23b8e..9933d2a94be31 100644 --- a/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java +++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/persist/service/MetaDataManagerPersistService.java @@ -90,6 +90,15 @@ public interface MetaDataManagerPersistService { */ void dropTables(ShardingSphereDatabase database, String schemaName, Collection tableNames); + /** + * Rename tables. + * + * @param database database + * @param schemaName schema name + * @param renameTableMap rename table map, key is old table name, value is new table name + */ + void renameTables(ShardingSphereDatabase database, String schemaName, Map renameTableMap); + /** * Alter tables. * diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java index b85ef469349fd..d1c8828715e47 100644 --- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java +++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java @@ -116,6 +116,19 @@ public void dropTables(final ShardingSphereDatabase database, final String schem } } + @Override + public void renameTables(final ShardingSphereDatabase database, final String schemaName, final Map renameTableMap) { + boolean isNeedRefresh = TableRefreshUtils.isNeedRefresh(database.getRuleMetaData(), schemaName, renameTableMap.keySet()); + // Drop old tables from metadata + renameTableMap.keySet().forEach(each -> metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().drop(database.getName(), schemaName, each)); + // Add new tables to metadata (new tables should be auto-discovered after physical rename) + // For single tables, update rule configuration + if (isNeedRefresh && renameTableMap.keySet().stream().anyMatch(each -> TableRefreshUtils.isSingleTable(each, database))) { + alterSingleRuleConfiguration(database, database.getRuleMetaData()); + } + // Note: For sharding and broadcast tables, rules need to be updated through separate DistSQL commands or manual configuration updates + } + @Override public void alterTables(final ShardingSphereDatabase database, final String schemaName, final Collection alteredTables) { metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(database.getName(), schemaName, alteredTables); diff --git a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java index 6e56b85e5f0cc..66fd1fde86454 100644 --- a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java +++ b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java @@ -126,6 +126,22 @@ public void dropTables(final ShardingSphereDatabase database, final String schem } } + @Override + public void renameTables(final ShardingSphereDatabase database, final String schemaName, final Map renameTableMap) { + boolean isNeedRefresh = TableRefreshUtils.isNeedRefresh(database.getRuleMetaData(), schemaName, renameTableMap.keySet()); + // Drop old tables from metadata + renameTableMap.keySet().forEach(each -> { + metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().drop(database.getName(), schemaName, each); + metaDataContextManager.getDatabaseMetaDataManager().dropTable(database.getName(), schemaName, each); + }); + // Add new tables to metadata (new tables should be auto-discovered after physical rename) + // For single tables, update rule configuration + if (isNeedRefresh && renameTableMap.keySet().stream().anyMatch(each -> TableRefreshUtils.isSingleTable(each, database))) { + alterSingleRuleConfiguration(database, database.getRuleMetaData()); + } + // Note: For sharding and broadcast tables, rules need to be updated through separate DistSQL commands or manual configuration updates + } + @Override public void alterTables(final ShardingSphereDatabase database, final String schemaName, final Collection alteredTables) { metaDataPersistFacade.getDatabaseMetaDataFacade().getTable().persist(database.getName(), schemaName, alteredTables);