This is an automated email from the ASF dual-hosted git repository.
menghaoranss pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 295c2dfad82 Fix unload all single table (#38674)
295c2dfad82 is described below
commit 295c2dfad82c4f12f1dfa53d5a0f43b143f34496
Author: Haoran Meng <[email protected]>
AuthorDate: Thu May 7 19:04:42 2026 +0800
Fix unload all single table (#38674)
* Fix unload all single table
* Fix unload all single table for standalone
* Fix unload all single table for standalone
* Revert "Fix unload all single table for standalone"
This reverts commit ea335c5e0820b2bb5dc9045832a8705a96989a08.
---
.../metadata/DatabaseMetaDataPersistFacade.java | 12 ++++++++++
.../DatabaseMetaDataPersistFacadeTest.java | 9 ++++++++
.../ClusterMetaDataManagerPersistService.java | 27 ++++++++++++++--------
.../ClusterMetaDataManagerPersistServiceTest.java | 26 +++++++++++++++------
.../StandaloneMetaDataManagerPersistService.java | 16 +++++++++++++
...tandaloneMetaDataManagerPersistServiceTest.java | 25 ++++++++++++++++++++
6 files changed, 98 insertions(+), 17 deletions(-)
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacade.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacade.java
index 15dfd5fde80..991ad7144db 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacade.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacade.java
@@ -165,4 +165,16 @@ public final class DatabaseMetaDataPersistFacade {
}
});
}
+
+ /**
+ * Persist reload database by unload single table.
+ *
+ * @param databaseName database name
+ * @param reloadDatabase reload database
+ * @param currentDatabase current database
+ */
+ public void persistReloadDatabaseByUnloadSingleTable(final String
databaseName, final ShardingSphereDatabase reloadDatabase, final
ShardingSphereDatabase currentDatabase) {
+ Collection<ShardingSphereSchema> toBeAlteredSchemasWithTablesDropped =
GenericSchemaManager.getToBeAlteredSchemasWithTablesDropped(reloadDatabase,
currentDatabase);
+ toBeAlteredSchemasWithTablesDropped.forEach(each ->
table.drop(databaseName, each.getName(), each.getAllTables()));
+ }
}
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacadeTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacadeTest.java
index 690fce5e908..ae062aebdf7 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacadeTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/persist/metadata/DatabaseMetaDataPersistFacadeTest.java
@@ -125,6 +125,15 @@ class DatabaseMetaDataPersistFacadeTest {
verify(tableMetaDataService).drop(eq("foo_db"), eq("Foo_Dropped"),
anyCollection());
}
+ @Test
+ void assertPersistReloadDatabaseByUnloadSingleTable() {
+
when(GenericSchemaManager.getToBeAlteredSchemasWithTablesDropped(any(), any()))
+ .thenReturn(Collections.singleton(new
ShardingSphereSchema("Foo_Dropped", mock(DatabaseType.class))));
+
databaseMetaDataFacade.persistReloadDatabaseByUnloadSingleTable("foo_db",
mock(ShardingSphereDatabase.class), mock(ShardingSphereDatabase.class));
+ verify(tableMetaDataService).drop(eq("foo_db"), eq("Foo_Dropped"),
anyCollection());
+ verify(tableMetaDataService, never()).persist(anyString(),
anyString(), anyCollection());
+ }
+
@Test
void assertRenameSchemaWithEmptySchema() {
ShardingSphereDatabase database = createDatabase("foo_db",
Collections.singleton(new ShardingSphereSchema("foo_schema",
mock(DatabaseType.class))));
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 a0d969db722..e1308aff5ac 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
@@ -208,28 +208,35 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
if (null == toBeRemovedRuleItemConfig) {
return;
}
- Collection<String> needReloadTables = getNeedReloadTables(database,
toBeRemovedRuleItemConfig);
MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaDataContextManager.getMetaDataContexts().getMetaData(),
metaDataContextManager.getMetaDataContexts().getStatistics());
+ if (toBeRemovedRuleItemConfig instanceof SingleRuleConfiguration) {
+ removeSingleRuleConfiguration(database, toBeRemovedRuleItemConfig,
originalMetaDataContexts);
+ return;
+ }
+ Collection<String> needReloadTables =
toBeRemovedRuleItemConfig.getLogicTableNames();
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
Collections.singleton(toBeRemovedRuleItemConfig));
metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(database.getName(),
getReloadedMetaDataContexts(originalMetaDataContexts), needReloadTables);
}
- private Collection<String> getNeedReloadTables(final
ShardingSphereDatabase originalDatabase, final RuleConfiguration
toBeAlteredRuleConfig) {
- if (toBeAlteredRuleConfig instanceof SingleRuleConfiguration) {
- Collection<String> originalSingleTables =
originalDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
- return
toBeAlteredRuleConfig.getLogicTableNames().stream().filter(each ->
!originalSingleTables.contains(each)).collect(Collectors.toList());
- }
- return toBeAlteredRuleConfig.getLogicTableNames();
- }
-
@Override
public void removeRuleConfiguration(final ShardingSphereDatabase database,
final RuleConfiguration toBeRemovedRuleConfig, final String ruleType) {
- Collection<String> needReloadTables = getNeedReloadTables(database,
toBeRemovedRuleConfig);
MetaDataContexts originalMetaDataContexts = new
MetaDataContexts(metaDataContextManager.getMetaDataContexts().getMetaData(),
metaDataContextManager.getMetaDataContexts().getStatistics());
+ if (toBeRemovedRuleConfig instanceof SingleRuleConfiguration) {
+ removeSingleRuleConfiguration(database, toBeRemovedRuleConfig,
originalMetaDataContexts);
+ return;
+ }
+ Collection<String> needReloadTables =
toBeRemovedRuleConfig.getLogicTableNames();
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
ruleType);
metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(database.getName(),
getReloadedMetaDataContexts(originalMetaDataContexts), needReloadTables);
}
+ private void removeSingleRuleConfiguration(final ShardingSphereDatabase
database, final RuleConfiguration toBeRemovedRuleItemConfig, final
MetaDataContexts originalMetaDataContexts) {
+
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
Collections.singleton(toBeRemovedRuleItemConfig));
+
metaDataPersistFacade.getDatabaseMetaDataFacade().persistReloadDatabaseByUnloadSingleTable(database.getName(),
+
getReloadedMetaDataContexts(originalMetaDataContexts).getMetaData().getDatabase(database.getName()),
+
originalMetaDataContexts.getMetaData().getDatabase(database.getName()));
+ }
+
@Override
public void alterGlobalRuleConfiguration(final RuleConfiguration
toBeAlteredRuleConfig) {
metaDataPersistFacade.getGlobalRuleService().persist(Collections.singleton(toBeAlteredRuleConfig));
diff --git
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
index dd1e59c3d71..e53bf3369dd 100644
---
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
+++
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistServiceTest.java
@@ -47,7 +47,6 @@ import java.util.Properties;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyCollection;
-import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
@@ -179,19 +178,32 @@ class ClusterMetaDataManagerPersistServiceTest {
ruleConfig.setTables(Collections.singleton("ds_0.t_order"));
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
when(database.getName()).thenReturn("foo_db");
- SingleRule singleRule = mock(SingleRule.class);
- when(singleRule.getConfiguration()).thenReturn(new
SingleRuleConfiguration());
- when(database.getRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singleton(singleRule)));
metaDataManagerPersistService.removeRuleConfigurationItem(database,
ruleConfig);
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
Collections.singleton(ruleConfig));
-
verify(metaDataPersistFacade.getDatabaseMetaDataFacade()).persistAlteredTables(eq("foo_db"),
any(), argThat(actual -> 1 == actual.size() && actual.contains("t_order")));
+
verify(metaDataPersistFacade.getDatabaseMetaDataFacade()).persistReloadDatabaseByUnloadSingleTable(eq("foo_db"),
any(), any());
+ verify(metaDataPersistFacade.getDatabaseMetaDataFacade(),
never()).persistAlteredTables(eq("foo_db"), any(), any());
}
@Test
void assertRemoveRuleConfiguration() {
- metaDataManagerPersistService.removeRuleConfiguration(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList(), new ConfigurationProperties(new Properties())),
- mock(RuleConfiguration.class), "fixtureRule");
+ RuleConfiguration ruleConfig = mock(RuleConfiguration.class);
+
when(ruleConfig.getLogicTableNames()).thenReturn(Collections.singleton("t_order"));
+ metaDataManagerPersistService.removeRuleConfiguration(
+ new ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList(), new ConfigurationProperties(new Properties())),
ruleConfig, "fixtureRule");
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
"fixtureRule");
+
verify(metaDataPersistFacade.getDatabaseMetaDataFacade()).persistAlteredTables(eq("foo_db"),
any(), eq(Collections.singleton("t_order")));
+ }
+
+ @Test
+ void assertRemoveSingleRuleConfiguration() {
+ SingleRuleConfiguration ruleConfig = new SingleRuleConfiguration();
+ ruleConfig.setTables(Collections.singleton("ds_0.t_order"));
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
+ when(database.getName()).thenReturn("foo_db");
+ metaDataManagerPersistService.removeRuleConfiguration(database,
ruleConfig, "SINGLE");
+
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
Collections.singleton(ruleConfig));
+
verify(metaDataPersistFacade.getDatabaseMetaDataFacade()).persistReloadDatabaseByUnloadSingleTable(eq("foo_db"),
any(), any());
+ verify(metaDataPersistFacade.getDatabaseRuleService(),
never()).delete("foo_db", "SINGLE");
}
@Test
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 2f6151e5bc0..f2698431d66 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
@@ -234,6 +234,14 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
if (null == toBeRemovedRuleItemConfig) {
return;
}
+ if (toBeRemovedRuleItemConfig instanceof SingleRuleConfiguration) {
+ Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
Collections.singleton(toBeRemovedRuleItemConfig));
+ removeRuleItem(database.getName(), metaDataVersions);
+
metaDataPersistFacade.getDatabaseMetaDataFacade().persistReloadDatabaseByUnloadSingleTable(
+ database.getName(),
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(database.getName()),
database);
+ clearServicesCache();
+ return;
+ }
Collection<String> needReloadTables = getNeedReloadTables(database,
toBeRemovedRuleItemConfig);
Collection<MetaDataVersion> metaDataVersions =
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
Collections.singleton(toBeRemovedRuleItemConfig));
removeRuleItem(database.getName(), metaDataVersions);
@@ -267,6 +275,14 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
@Override
public void removeRuleConfiguration(final ShardingSphereDatabase database,
final RuleConfiguration toBeRemovedRuleConfig, final String ruleType) {
+ if (toBeRemovedRuleConfig instanceof SingleRuleConfiguration) {
+
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
ruleType);
+ metaDataContextManager.getDatabaseRuleItemManager().drop(new
DatabaseRuleNodePath(database.getName(), ruleType, null));
+
metaDataPersistFacade.getDatabaseMetaDataFacade().persistReloadDatabaseByUnloadSingleTable(
+ database.getName(),
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(database.getName()),
database);
+ clearServicesCache();
+ return;
+ }
Collection<String> needReloadTables = getNeedReloadTables(database,
toBeRemovedRuleConfig);
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(),
ruleType);
metaDataContextManager.getDatabaseRuleItemManager().drop(new
DatabaseRuleNodePath(database.getName(), ruleType, null));
diff --git
a/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
b/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
index 4583b8f0e05..ff755da0b24 100644
---
a/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
+++
b/mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java
@@ -197,6 +197,20 @@ class StandaloneMetaDataManagerPersistServiceTest {
verify(metaDataContextManager.getDatabaseRuleItemManager()).drop(deepEq(databaseRuleNodePath));
}
+ @Test
+ void assertRemoveSingleRuleConfigurationItem() {
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ when(database.getName()).thenReturn("foo_db");
+ SingleRuleConfiguration ruleConfig = new SingleRuleConfiguration();
+ ruleConfig.setTables(Collections.singleton("ds_0.t_order"));
+ DatabaseRuleNodePath databaseRuleNodePath = new
DatabaseRuleNodePath("foo_db", "single", new DatabaseRuleItem("unique"));
+ when(metaDataPersistFacade.getDatabaseRuleService().delete("foo_db",
Collections.singleton(ruleConfig))).thenReturn(Collections.singleton(new
MetaDataVersion(databaseRuleNodePath)));
+ metaDataManagerPersistService.removeRuleConfigurationItem(database,
ruleConfig);
+
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
Collections.singleton(ruleConfig));
+
verify(metaDataPersistFacade.getDatabaseMetaDataFacade()).persistReloadDatabaseByUnloadSingleTable(eq("foo_db"),
any(), eq(database));
+ verify(metaDataPersistFacade.getDatabaseMetaDataFacade(),
never()).persistAlteredTables(eq("foo_db"), any(), any());
+ }
+
@Test
void assertRemoveRuleConfiguration() {
metaDataManagerPersistService.removeRuleConfiguration(new
ShardingSphereDatabase("foo_db", mock(), mock(), mock(),
Collections.emptyList(), new ConfigurationProperties(new Properties())),
@@ -204,6 +218,17 @@ class StandaloneMetaDataManagerPersistServiceTest {
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
"foo_rule");
}
+ @Test
+ void assertRemoveSingleRuleConfiguration() {
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
+ when(database.getName()).thenReturn("foo_db");
+ SingleRuleConfiguration ruleConfig = new SingleRuleConfiguration();
+ ruleConfig.setTables(Collections.singleton("ds_0.t_order"));
+ metaDataManagerPersistService.removeRuleConfiguration(database,
ruleConfig, "SINGLE");
+
verify(metaDataPersistFacade.getDatabaseRuleService()).delete("foo_db",
"SINGLE");
+
verify(metaDataPersistFacade.getDatabaseMetaDataFacade()).persistReloadDatabaseByUnloadSingleTable(eq("foo_db"),
any(), eq(database));
+ }
+
@Test
void assertAlterGlobalRuleConfiguration() {
RuleConfiguration ruleConfig = mock(RuleConfiguration.class);
