You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by du...@apache.org on 2024/03/20 02:18:52 UTC
(shardingsphere) branch master updated: Remove updateCurrentRuleConfiguration interface (#30549)
This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 3b6baaee929 Remove updateCurrentRuleConfiguration interface (#30549)
3b6baaee929 is described below
commit 3b6baaee929a14c2f633b57815545c355b183358
Author: zhaojinchao <zh...@apache.org>
AuthorDate: Wed Mar 20 10:18:45 2024 +0800
Remove updateCurrentRuleConfiguration interface (#30549)
* Remove updateCurrentRuleConfiguration interface
* Fix RDL test cases
* Fix checkstyle
---------
Co-authored-by: Pace2Car <ch...@apache.org>
---
.../update/CreateBroadcastTableRuleExecutor.java | 6 -
.../update/DropBroadcastTableRuleExecutor.java | 7 -
.../CreateBroadcastTableRuleExecutorTest.java | 6 +-
.../update/DropBroadcastTableRuleExecutorTest.java | 7 +-
.../handler/update/AlterEncryptRuleExecutor.java | 7 -
.../handler/update/CreateEncryptRuleExecutor.java | 6 -
.../handler/update/DropEncryptRuleExecutor.java | 7 -
.../update/AlterEncryptRuleExecutorTest.java | 8 +-
.../update/CreateEncryptRuleExecutorTest.java | 7 +-
.../update/DropEncryptRuleExecutorTest.java | 17 +--
.../handler/update/AlterMaskRuleExecutor.java | 7 -
.../handler/update/CreateMaskRuleExecutor.java | 28 ----
.../handler/update/DropMaskRuleExecutor.java | 7 -
.../handler/update/AlterMaskRuleExecutorTest.java | 5 +-
.../handler/update/CreateMaskRuleExecutorTest.java | 22 +---
.../handler/update/DropMaskRuleExecutorTest.java | 11 +-
.../AlterReadwriteSplittingRuleExecutor.java | 6 -
.../CreateReadwriteSplittingRuleExecutor.java | 6 -
.../update/DropReadwriteSplittingRuleExecutor.java | 17 ---
.../CreateReadwriteSplittingRuleExecutorTest.java | 6 +-
.../DropReadwriteSplittingRuleExecutorTest.java | 20 ++-
.../AlterDefaultShadowAlgorithmExecutor.java | 6 -
.../handler/update/AlterShadowRuleExecutor.java | 20 +--
.../CreateDefaultShadowAlgorithmExecutor.java | 11 +-
.../handler/update/CreateShadowRuleExecutor.java | 7 -
.../update/DropDefaultShadowAlgorithmExecutor.java | 7 -
.../update/DropShadowAlgorithmExecutor.java | 9 --
.../handler/update/DropShadowRuleExecutor.java | 11 --
.../DropDefaultShadowAlgorithmExecutorTest.java | 10 +-
.../update/DropShadowAlgorithmExecutorTest.java | 7 +-
.../distsql/update/DropShadowRuleExecutorTest.java | 17 ++-
.../AlterDefaultShardingStrategyExecutor.java | 13 --
.../AlterShardingTableReferenceRuleExecutor.java | 7 -
.../update/AlterShardingTableRuleExecutor.java | 28 ----
.../CreateDefaultShardingStrategyExecutor.java | 16 ---
.../CreateShardingTableReferenceRuleExecutor.java | 5 -
.../update/CreateShardingTableRuleExecutor.java | 9 --
.../DropDefaultShardingStrategyExecutor.java | 11 --
.../update/DropShardingAlgorithmExecutor.java | 8 --
.../update/DropShardingAuditorExecutor.java | 6 -
.../update/DropShardingKeyGeneratorExecutor.java | 6 -
.../update/DropShardingTableReferenceExecutor.java | 6 -
.../update/DropShardingTableRuleExecutor.java | 10 --
.../AlterDefaultShardingStrategyExecutorTest.java | 18 +--
...lterShardingTableReferenceRuleExecutorTest.java | 11 +-
.../update/AlterShardingTableRuleExecutorTest.java | 33 +++--
.../CreateDefaultShardingStrategyExecutorTest.java | 50 ++-----
...eateShardingTableReferenceRuleExecutorTest.java | 10 +-
.../CreateShardingTableRuleExecutorTest.java | 49 ++-----
.../DropDefaultShardingStrategyExecutorTest.java | 39 +++---
.../update/DropShardingAlgorithmExecutorTest.java | 25 +---
.../update/DropShardingAuditorExecutorTest.java | 9 +-
.../DropShardingKeyGeneratorExecutorTest.java | 13 +-
.../DropShardingTableReferenceExecutorTest.java | 10 +-
.../update/DropShardingTableRuleExecutorTest.java | 37 +++---
.../engine/update/DistSQLUpdateExecuteEngine.java | 34 +----
.../LegacyDatabaseRuleDefinitionExecuteEngine.java | 143 ---------------------
.../LegacyGlobalRuleDefinitionExecuteEngine.java | 63 ---------
.../spi/database/DatabaseRuleAlterExecutor.java | 9 --
.../spi/database/DatabaseRuleCreateExecutor.java | 9 --
.../spi/database/DatabaseRuleDropExecutor.java | 21 ---
.../DriverDatabaseConnectionManager.java | 4 +-
.../DriverDatabaseConnectionManagerTest.java | 6 +-
.../database/DatabaseBasedPersistService.java | 32 +----
.../datasource/DataSourceNodePersistService.java | 58 ++++-----
.../datasource/DataSourceUnitPersistService.java | 58 ++++-----
.../database/rule/DatabaseRulePersistService.java | 26 ++--
.../config/global/GlobalPersistService.java | 12 --
.../config/global/GlobalRulePersistService.java | 16 ---
.../handler/update/LoadSingleTableExecutor.java | 6 -
.../SetDefaultSingleTableStorageUnitExecutor.java | 5 -
.../handler/update/UnloadSingleTableExecutor.java | 6 -
.../update/LoadSingleTableExecutorTest.java | 5 +-
...tDefaultSingleTableStorageUnitExecutorTest.java | 15 +--
.../standalone/StandaloneModeContextManager.java | 9 +-
.../fixture/FixtureDatabaseRuleCreateExecutor.java | 4 -
76 files changed, 280 insertions(+), 1008 deletions(-)
diff --git a/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java b/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java
index 15bbe5360d2..5887d4c95ee 100644
--- a/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java
+++ b/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutor.java
@@ -75,12 +75,6 @@ public final class CreateBroadcastTableRuleExecutor implements DatabaseRuleCreat
return result;
}
- @Override
- public void updateCurrentRuleConfiguration(final BroadcastRuleConfiguration currentRuleConfig, final BroadcastRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getTables().clear();
- currentRuleConfig.getTables().addAll(toBeCreatedRuleConfig.getTables());
- }
-
@Override
public Class<BroadcastRule> getRuleClass() {
return BroadcastRule.class;
diff --git a/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutor.java b/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutor.java
index 4d1ccfadbbe..10857cb04cf 100644
--- a/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutor.java
+++ b/features/broadcast/distsql/handler/src/main/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutor.java
@@ -70,13 +70,6 @@ public final class DropBroadcastTableRuleExecutor implements DatabaseRuleDropExe
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropBroadcastTableRuleStatement sqlStatement, final BroadcastRuleConfiguration currentRuleConfig) {
- Collection<String> toBeDroppedTableNames = new CaseInsensitiveSet<>(sqlStatement.getTables());
- currentRuleConfig.getTables().removeIf(toBeDroppedTableNames::contains);
- return currentRuleConfig.isEmpty();
- }
-
@Override
public Class<BroadcastRule> getRuleClass() {
return BroadcastRule.class;
diff --git a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
index 2d28ff25d4d..27b53ddb06c 100644
--- a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
+++ b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/CreateBroadcastTableRuleExecutorTest.java
@@ -74,10 +74,8 @@ class CreateBroadcastTableRuleExecutorTest {
CreateBroadcastTableRuleStatement sqlStatement = new CreateBroadcastTableRuleStatement(false, Collections.singleton("t_address"));
executor.checkBeforeUpdate(sqlStatement);
BroadcastRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
- assertThat(currentConfig.getTables().size(), is(1));
- assertThat(currentConfig.getTables().iterator().next(), is("t_address"));
- executor.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
+ assertThat(toBeCreatedRuleConfig.getTables().size(), is(1));
+ assertThat(toBeCreatedRuleConfig.getTables().iterator().next(), is("t_address"));
}
private ShardingSphereDatabase mockShardingSphereDatabase() {
diff --git a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java
index 77738151087..1f1227b6d5a 100644
--- a/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java
+++ b/features/broadcast/distsql/handler/src/test/java/org/apache/shardingsphere/broadcast/distsql/handler/update/DropBroadcastTableRuleExecutorTest.java
@@ -58,8 +58,11 @@ class DropBroadcastTableRuleExecutorTest {
void assertUpdateCurrentRuleConfiguration() {
BroadcastRuleConfiguration config = new BroadcastRuleConfiguration(new LinkedList<>());
config.getTables().add("t_address");
+ BroadcastRule rule = mock(BroadcastRule.class);
+ when(rule.getConfiguration()).thenReturn(config);
+ executor.setRule(rule);
DropBroadcastTableRuleStatement sqlStatement = new DropBroadcastTableRuleStatement(false, Collections.singleton("t_address"));
- assertTrue(executor.updateCurrentRuleConfiguration(sqlStatement, config));
- assertTrue(config.getTables().isEmpty());
+ BroadcastRuleConfiguration toBeDroppedConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
+ assertTrue(toBeDroppedConfig.getTables().isEmpty());
}
}
diff --git a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutor.java b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutor.java
index 2e119fdd531..f3c86d19713 100644
--- a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutor.java
+++ b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutor.java
@@ -115,13 +115,6 @@ public final class AlterEncryptRuleExecutor implements DatabaseRuleAlterExecutor
return new EncryptRuleConfiguration(Collections.emptyList(), toBeDroppedEncryptors);
}
- @Override
- public void updateCurrentRuleConfiguration(final EncryptRuleConfiguration currentRuleConfig, final EncryptRuleConfiguration toBeAlteredRuleConfig) {
- dropRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- addRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- dropUnusedEncryptor(currentRuleConfig);
- }
-
private void dropRuleConfiguration(final EncryptRuleConfiguration currentRuleConfig, final EncryptRuleConfiguration toBeAlteredRuleConfig) {
for (EncryptTableRuleConfiguration each : toBeAlteredRuleConfig.getTables()) {
Optional<EncryptTableRuleConfiguration> toBeRemovedTableRuleConfig = currentRuleConfig.getTables().stream().filter(tableRule -> tableRule.getName().equals(each.getName())).findAny();
diff --git a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutor.java b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutor.java
index b521beb7b92..b66f677527f 100644
--- a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutor.java
+++ b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutor.java
@@ -151,12 +151,6 @@ public final class CreateEncryptRuleExecutor implements DatabaseRuleCreateExecut
return EncryptRuleStatementConverter.convert(segments);
}
- @Override
- public void updateCurrentRuleConfiguration(final EncryptRuleConfiguration currentRuleConfig, final EncryptRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getTables().addAll(toBeCreatedRuleConfig.getTables());
- currentRuleConfig.getEncryptors().putAll(toBeCreatedRuleConfig.getEncryptors());
- }
-
@Override
public Class<EncryptRule> getRuleClass() {
return EncryptRule.class;
diff --git a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutor.java b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutor.java
index d17e1cd63f2..3c0d974d825 100644
--- a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutor.java
+++ b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutor.java
@@ -79,13 +79,6 @@ public final class DropEncryptRuleExecutor implements DatabaseRuleDropExecutor<D
return new EncryptRuleConfiguration(toBeDroppedTables, toBeDroppedEncryptors);
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
- sqlStatement.getTables().forEach(this::dropRule);
- dropUnusedEncryptor(currentRuleConfig);
- return currentRuleConfig.isEmpty();
- }
-
private void dropRule(final String ruleName) {
Optional<EncryptTableRuleConfiguration> encryptTableRuleConfig = rule.getConfiguration().getTables().stream()
.filter(each -> each.getName().equals(ruleName)).findAny();
diff --git a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java
index bfac3fd1cbd..949a9b8d8f9 100644
--- a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java
+++ b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/AlterEncryptRuleExecutorTest.java
@@ -84,9 +84,11 @@ class AlterEncryptRuleExecutorTest {
@Test
void assertUpdateCurrentRuleConfigurationWithInUsedEncryptor() {
- EncryptRuleConfiguration currentRuleConfig = createCurrentRuleConfigurationWithMultipleTableRules();
- executor.updateCurrentRuleConfiguration(currentRuleConfig, createToBeAlteredRuleConfiguration());
- assertThat(currentRuleConfig.getEncryptors().size(), is(1));
+ EncryptRule rule = mock(EncryptRule.class);
+ when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+ executor.setRule(rule);
+ EncryptRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(createSQLStatement("MD5"));
+ assertThat(toBeAlteredRuleConfig.getEncryptors().size(), is(3));
}
private AlterEncryptRuleStatement createSQLStatement(final String encryptorName) {
diff --git a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java
index 061b6489e77..a246e160d76 100644
--- a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java
+++ b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/CreateEncryptRuleExecutorTest.java
@@ -41,8 +41,6 @@ import java.util.HashMap;
import java.util.LinkedList;
import java.util.Properties;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
@@ -88,9 +86,8 @@ class CreateEncryptRuleExecutorTest {
CreateEncryptRuleStatement sqlStatement = createAESEncryptRuleSQLStatement(true);
executor.checkBeforeUpdate(sqlStatement);
EncryptRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- assertThat(currentRuleConfig.getTables().size(), is(2));
- assertTrue(currentRuleConfig.getEncryptors().isEmpty());
+ assertTrue(toBeCreatedRuleConfig.getTables().isEmpty());
+ assertTrue(toBeCreatedRuleConfig.getEncryptors().isEmpty());
}
private CreateEncryptRuleStatement createAESEncryptRuleSQLStatement(final boolean ifNotExists) {
diff --git a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java
index 469a1a31a6a..b605326d959 100644
--- a/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java
+++ b/features/encrypt/distsql/handler/src/test/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleExecutorTest.java
@@ -38,7 +38,6 @@ import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
@@ -69,8 +68,9 @@ class DropEncryptRuleExecutorTest {
EncryptRule rule = mock(EncryptRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
- assertTrue(executor.updateCurrentRuleConfiguration(createSQLStatement("t_encrypt"), ruleConfig));
- assertTrue(ruleConfig.getEncryptors().isEmpty());
+ EncryptRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("t_encrypt"));
+ assertThat(toBeDroppedRuleConfig.getTables().size(), is(1));
+ assertThat(toBeDroppedRuleConfig.getEncryptors().size(), is(3));
}
@Test
@@ -79,8 +79,9 @@ class DropEncryptRuleExecutorTest {
EncryptRule rule = mock(EncryptRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
- assertFalse(executor.updateCurrentRuleConfiguration(createSQLStatement("t_encrypt"), ruleConfig));
- assertThat(ruleConfig.getEncryptors().size(), is(1));
+ EncryptRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("t_encrypt"));
+ assertThat(toBeDroppedRuleConfig.getTables().size(), is(1));
+ assertTrue(toBeDroppedRuleConfig.getEncryptors().isEmpty());
}
@Test
@@ -90,9 +91,9 @@ class DropEncryptRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(new EncryptRuleConfiguration(Collections.emptyList(), Collections.emptyMap()));
executor.setRule(rule);
executor.checkBeforeUpdate(statement);
- EncryptRuleConfiguration ruleConfig = createCurrentRuleConfiguration();
- assertFalse(executor.updateCurrentRuleConfiguration(statement, ruleConfig));
- assertThat(ruleConfig.getEncryptors().size(), is(3));
+ EncryptRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(statement);
+ assertThat(toBeDroppedRuleConfig.getTables().size(), is(1));
+ assertTrue(toBeDroppedRuleConfig.getEncryptors().isEmpty());
}
private DropEncryptRuleStatement createSQLStatement(final String tableName) {
diff --git a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutor.java b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutor.java
index dd84a13ae23..21247b7c830 100644
--- a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutor.java
+++ b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutor.java
@@ -85,13 +85,6 @@ public final class AlterMaskRuleExecutor implements DatabaseRuleAlterExecutor<Al
return new MaskRuleConfiguration(Collections.emptyList(), toBeDroppedAlgorithms);
}
- @Override
- public void updateCurrentRuleConfiguration(final MaskRuleConfiguration currentRuleConfig, final MaskRuleConfiguration toBeAlteredRuleConfig) {
- dropRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- addRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- dropUnusedAlgorithms(currentRuleConfig);
- }
-
private void dropRuleConfiguration(final MaskRuleConfiguration currentRuleConfig, final MaskRuleConfiguration toBeAlteredRuleConfig) {
Collection<String> toBeAlteredRuleName = toBeAlteredRuleConfig.getTables().stream().map(MaskTableRuleConfiguration::getName).collect(Collectors.toList());
currentRuleConfig.getTables().removeIf(each -> toBeAlteredRuleName.contains(each.getName()));
diff --git a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutor.java b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutor.java
index 7eee926844a..9179d98b187 100644
--- a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutor.java
+++ b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutor.java
@@ -24,7 +24,6 @@ import org.apache.shardingsphere.infra.exception.core.ShardingSpherePrecondition
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mask.api.config.MaskRuleConfiguration;
-import org.apache.shardingsphere.mask.api.config.rule.MaskColumnRuleConfiguration;
import org.apache.shardingsphere.mask.api.config.rule.MaskTableRuleConfiguration;
import org.apache.shardingsphere.mask.distsql.handler.converter.MaskRuleStatementConverter;
import org.apache.shardingsphere.mask.distsql.segment.MaskColumnSegment;
@@ -77,33 +76,6 @@ public final class CreateMaskRuleExecutor implements DatabaseRuleCreateExecutor<
return MaskRuleStatementConverter.convert(sqlStatement.getRules());
}
- @Override
- public void updateCurrentRuleConfiguration(final MaskRuleConfiguration currentRuleConfig, final MaskRuleConfiguration toBeCreatedRuleConfig) {
- if (ifNotExists) {
- removeDuplicatedRules(currentRuleConfig, toBeCreatedRuleConfig);
- }
- if (toBeCreatedRuleConfig.getTables().isEmpty()) {
- return;
- }
- currentRuleConfig.getTables().addAll(toBeCreatedRuleConfig.getTables());
- currentRuleConfig.getMaskAlgorithms().putAll(toBeCreatedRuleConfig.getMaskAlgorithms());
- }
-
- private void removeDuplicatedRules(final MaskRuleConfiguration currentRuleConfig, final MaskRuleConfiguration toBeCreatedRuleConfig) {
- Collection<String> currentTables = new LinkedList<>();
- Collection<String> toBeRemovedAlgorithms = new LinkedList<>();
- Collection<String> toBeRemovedTables = new LinkedList<>();
- currentRuleConfig.getTables().forEach(each -> currentTables.add(each.getName()));
- toBeCreatedRuleConfig.getTables().forEach(each -> {
- if (currentTables.contains(each.getName())) {
- toBeRemovedAlgorithms.addAll(each.getColumns().stream().map(MaskColumnRuleConfiguration::getMaskAlgorithm).collect(Collectors.toList()));
- toBeRemovedTables.add(each.getName());
- }
- });
- toBeCreatedRuleConfig.getTables().removeIf(each -> toBeRemovedTables.contains(each.getName()));
- toBeCreatedRuleConfig.getMaskAlgorithms().keySet().removeIf(toBeRemovedAlgorithms::contains);
- }
-
@Override
public Class<MaskRule> getRuleClass() {
return MaskRule.class;
diff --git a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutor.java b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutor.java
index 8885e33df85..5eeb25a5fed 100644
--- a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutor.java
+++ b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutor.java
@@ -79,13 +79,6 @@ public final class DropMaskRuleExecutor implements DatabaseRuleDropExecutor<Drop
return new MaskRuleConfiguration(toBeDroppedTables, toBeDroppedAlgorithms);
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropMaskRuleStatement sqlStatement, final MaskRuleConfiguration currentRuleConfig) {
- sqlStatement.getTables().forEach(this::dropRule);
- dropUnusedAlgorithm(currentRuleConfig);
- return currentRuleConfig.isEmpty();
- }
-
private void dropRule(final String ruleName) {
Optional<MaskTableRuleConfiguration> maskTableRuleConfig = rule.getConfiguration().getTables().stream().filter(each -> each.getName().equals(ruleName)).findAny();
maskTableRuleConfig.ifPresent(optional -> rule.getConfiguration().getTables().remove(maskTableRuleConfig.get()));
diff --git a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java
index 13a8ba1bd2d..2f3f29c85f5 100644
--- a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java
+++ b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/AlterMaskRuleExecutorTest.java
@@ -90,9 +90,8 @@ class AlterMaskRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
MaskRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- assertThat(currentRuleConfig.getMaskAlgorithms().size(), is(1));
- assertTrue(currentRuleConfig.getMaskAlgorithms().containsKey("t_order_order_id_md5"));
+ assertThat(toBeAlteredRuleConfig.getMaskAlgorithms().size(), is(1));
+ assertTrue(toBeAlteredRuleConfig.getMaskAlgorithms().containsKey("t_order_order_id_md5"));
}
private AlterMaskRuleStatement createSQLStatement(final String algorithmName) {
diff --git a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java
index 09cf7116885..10d99f64045 100644
--- a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java
+++ b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/CreateMaskRuleExecutorTest.java
@@ -75,31 +75,23 @@ class CreateMaskRuleExecutorTest {
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
MaskRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- assertThat(currentRuleConfig.getTables().size(), is(4));
- assertTrue(currentRuleConfig.getMaskAlgorithms().containsKey("t_mask_1_user_id_md5"));
- assertTrue(currentRuleConfig.getMaskAlgorithms().containsKey("t_order_1_order_id_md5"));
+ assertThat(toBeCreatedRuleConfig.getTables().size(), is(2));
+ assertTrue(toBeCreatedRuleConfig.getMaskAlgorithms().containsKey("t_mask_1_user_id_md5"));
+ assertTrue(toBeCreatedRuleConfig.getMaskAlgorithms().containsKey("t_order_1_order_id_md5"));
}
@Test
void assertCreateMaskRuleWithIfNotExists() {
MaskRuleConfiguration currentRuleConfig = getCurrentRuleConfig();
- CreateMaskRuleStatement sqlStatement = createSQLStatement(false, "MD5");
MaskRule rule = mock(MaskRule.class);
+ CreateMaskRuleStatement sqlStatement = createSQLStatement(true, "MD5");
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
MaskRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- sqlStatement = createSQLStatement(true, "MD5");
- when(rule.getConfiguration()).thenReturn(currentRuleConfig);
- executor.setRule(rule);
- executor.checkBeforeUpdate(sqlStatement);
- toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- assertThat(currentRuleConfig.getTables().size(), is(4));
- assertTrue(currentRuleConfig.getMaskAlgorithms().containsKey("t_mask_1_user_id_md5"));
- assertTrue(currentRuleConfig.getMaskAlgorithms().containsKey("t_order_1_order_id_md5"));
+ assertThat(toBeCreatedRuleConfig.getTables().size(), is(2));
+ assertTrue(toBeCreatedRuleConfig.getMaskAlgorithms().containsKey("t_mask_1_user_id_md5"));
+ assertTrue(toBeCreatedRuleConfig.getMaskAlgorithms().containsKey("t_order_1_order_id_md5"));
}
private CreateMaskRuleStatement createSQLStatement(final boolean ifNotExists, final String algorithmType) {
diff --git a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java
index 93080888b74..4baa329ba56 100644
--- a/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java
+++ b/features/mask/distsql/handler/src/test/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleExecutorTest.java
@@ -33,7 +33,6 @@ import java.util.LinkedList;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
@@ -63,9 +62,9 @@ class DropMaskRuleExecutorTest {
MaskRule rule = mock(MaskRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
- assertTrue(executor.updateCurrentRuleConfiguration(createSQLStatement(false, "t_mask"), ruleConfig));
- assertTrue(ruleConfig.getMaskAlgorithms().isEmpty());
- assertTrue(ruleConfig.getTables().isEmpty());
+ MaskRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(createSQLStatement(false, "t_mask"));
+ assertTrue(toBeDroppedRuleConfig.getMaskAlgorithms().isEmpty());
+ assertThat(toBeDroppedRuleConfig.getTables().size(), is(1));
}
@Test
@@ -78,8 +77,8 @@ class DropMaskRuleExecutorTest {
MaskRuleConfiguration ruleConfig = createCurrentRuleConfiguration();
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
- assertFalse(executor.updateCurrentRuleConfiguration(statement, ruleConfig));
- assertThat(ruleConfig.getTables().size(), is(1));
+ MaskRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(statement);
+ assertThat(toBeDroppedRuleConfig.getTables().size(), is(1));
}
private DropMaskRuleStatement createSQLStatement(final boolean ifExists, final String tableName) {
diff --git a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java
index 6d47bae0478..5bbc186b377 100644
--- a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java
+++ b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java
@@ -73,12 +73,6 @@ public final class AlterReadwriteSplittingRuleExecutor implements DatabaseRuleAl
return new ReadwriteSplittingRuleConfiguration(dataSources, loadBalancers);
}
- @Override
- public void updateCurrentRuleConfiguration(final ReadwriteSplittingRuleConfiguration currentRuleConfig, final ReadwriteSplittingRuleConfiguration toBeAlteredRuleConfig) {
- dropRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- addRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- }
-
private void dropRuleConfiguration(final ReadwriteSplittingRuleConfiguration currentRuleConfig, final ReadwriteSplittingRuleConfiguration toBeAlteredRuleConfig) {
for (ReadwriteSplittingDataSourceRuleConfiguration each : toBeAlteredRuleConfig.getDataSources()) {
Optional<ReadwriteSplittingDataSourceRuleConfiguration> toBeRemovedDataSourceRuleConfig =
diff --git a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java
index 41943407867..dd2263054d9 100644
--- a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java
+++ b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java
@@ -57,12 +57,6 @@ public final class CreateReadwriteSplittingRuleExecutor implements DatabaseRuleC
return ReadwriteSplittingRuleStatementConverter.convert(segments);
}
- @Override
- public void updateCurrentRuleConfiguration(final ReadwriteSplittingRuleConfiguration currentRuleConfig, final ReadwriteSplittingRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getDataSources().addAll(toBeCreatedRuleConfig.getDataSources());
- currentRuleConfig.getLoadBalancers().putAll(toBeCreatedRuleConfig.getLoadBalancers());
- }
-
private Collection<String> getDuplicatedRuleNames(final Collection<ReadwriteSplittingRuleSegment> segments) {
Collection<String> currentRuleNames = new LinkedList<>();
if (null != rule) {
diff --git a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java
index 5f953ee549a..43204b2d803 100644
--- a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java
+++ b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java
@@ -29,7 +29,6 @@ import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.attribute.datanode.DataNodeRuleAttribute;
import org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
-import org.apache.shardingsphere.infra.rule.attribute.datasource.StaticDataSourceRuleAttribute;
import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.distsql.statement.DropReadwriteSplittingRuleStatement;
@@ -116,15 +115,6 @@ public final class DropReadwriteSplittingRuleExecutor implements DatabaseRuleDro
return new ReadwriteSplittingRuleConfiguration(toBeDroppedDataSources, toBeDroppedLoadBalancers);
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
- for (String each : sqlStatement.getNames()) {
- dropRule(each);
- }
- dropUnusedLoadBalancer(currentRuleConfig);
- return currentRuleConfig.isEmpty();
- }
-
private void dropRule(final String ruleName) {
Optional<ReadwriteSplittingDataSourceRuleConfiguration> dataSourceRuleConfig = rule.getConfiguration().getDataSources().stream().filter(each -> ruleName.equals(each.getName())).findAny();
dataSourceRuleConfig.ifPresent(optional -> rule.getConfiguration().getDataSources().remove(optional));
@@ -145,13 +135,6 @@ public final class DropReadwriteSplittingRuleExecutor implements DatabaseRuleDro
rule.getConfiguration().getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toSet()), sqlStatement.getNames());
}
- @Override
- public void operate(final DropReadwriteSplittingRuleStatement sqlStatement, final ShardingSphereDatabase database) {
- for (StaticDataSourceRuleAttribute each : database.getRuleMetaData().getAttributes(StaticDataSourceRuleAttribute.class)) {
- sqlStatement.getNames().forEach(each::cleanStorageNodeDataSource);
- }
- }
-
@Override
public Class<ReadwriteSplittingRule> getRuleClass() {
return ReadwriteSplittingRule.class;
diff --git a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
index c3a51fb414a..f8c113fd913 100644
--- a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
+++ b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
@@ -38,11 +38,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
-import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
-import java.util.HashMap;
import java.util.LinkedList;
import java.util.Properties;
@@ -156,11 +154,9 @@ class CreateReadwriteSplittingRuleExecutorTest {
CreateReadwriteSplittingRuleStatement sqlStatement = createSQLStatement(false, staticSegment);
executor.setDatabase(database);
executor.checkBeforeUpdate(sqlStatement);
- ReadwriteSplittingRuleConfiguration currentRuleConfig = new ReadwriteSplittingRuleConfiguration(new ArrayList<>(), new HashMap<>());
executor.setRule(mock(ReadwriteSplittingRule.class));
ReadwriteSplittingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- assertThat(currentRuleConfig.getDataSources().size(), is(1));
+ assertThat(toBeCreatedRuleConfig.getDataSources().size(), is(1));
}
private CreateReadwriteSplittingRuleStatement createSQLStatement(final String loadBalancerName) {
diff --git a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java
index fedad50fb12..3de3662a775 100644
--- a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java
+++ b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java
@@ -46,9 +46,7 @@ import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -94,33 +92,33 @@ class DropReadwriteSplittingRuleExecutorTest {
}
@Test
- void assertUpdateCurrentRuleConfiguration() {
+ void assertBuildToBeDroppedRuleConfiguration() {
ReadwriteSplittingRuleConfiguration ruleConfig = createCurrentRuleConfiguration();
ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
- assertTrue(executor.updateCurrentRuleConfiguration(createSQLStatement(), ruleConfig));
- assertThat(ruleConfig.getLoadBalancers().size(), is(0));
+ ReadwriteSplittingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement());
+ assertThat(actual.getLoadBalancers().size(), is(1));
}
@Test
- void assertUpdateCurrentRuleConfigurationWithInUsedLoadBalancer() {
+ void assertBuildToBeDroppedRuleConfigurationWithInUsedLoadBalancer() {
ReadwriteSplittingRuleConfiguration ruleConfig = createMultipleCurrentRuleConfigurations();
ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
- assertFalse(executor.updateCurrentRuleConfiguration(createSQLStatement(), ruleConfig));
- assertThat(ruleConfig.getLoadBalancers().size(), is(1));
+ ReadwriteSplittingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement());
+ assertThat(actual.getLoadBalancers().size(), is(0));
}
@Test
- void assertUpdateCurrentRuleConfigurationWithoutLoadBalancerName() {
+ void assertBuildToBeDroppedRuleConfigurationWithoutLoadBalancerName() {
ReadwriteSplittingRuleConfiguration ruleConfig = createCurrentRuleConfigurationWithoutLoadBalancerName();
ReadwriteSplittingRule rule = mock(ReadwriteSplittingRule.class);
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
- assertTrue(executor.updateCurrentRuleConfiguration(createSQLStatement(), ruleConfig));
- assertThat(ruleConfig.getLoadBalancers().size(), is(0));
+ ReadwriteSplittingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement());
+ assertThat(actual.getLoadBalancers().size(), is(1));
}
private DropReadwriteSplittingRuleStatement createSQLStatement() {
diff --git a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterDefaultShadowAlgorithmExecutor.java b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterDefaultShadowAlgorithmExecutor.java
index 6710d4ae894..4d830025ed5 100644
--- a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterDefaultShadowAlgorithmExecutor.java
+++ b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterDefaultShadowAlgorithmExecutor.java
@@ -88,12 +88,6 @@ public final class AlterDefaultShadowAlgorithmExecutor implements DatabaseRuleAl
return null;
}
- @Override
- public void updateCurrentRuleConfiguration(final ShadowRuleConfiguration currentRuleConfig, final ShadowRuleConfiguration toBeAlteredRuleConfig) {
- currentRuleConfig.getShadowAlgorithms().putAll(toBeAlteredRuleConfig.getShadowAlgorithms());
- currentRuleConfig.setDefaultShadowAlgorithmName(toBeAlteredRuleConfig.getDefaultShadowAlgorithmName());
- }
-
@Override
public Class<ShadowRule> getRuleClass() {
return ShadowRule.class;
diff --git a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterShadowRuleExecutor.java b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterShadowRuleExecutor.java
index 7fed68f825d..4efd3cd3402 100644
--- a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterShadowRuleExecutor.java
+++ b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/AlterShadowRuleExecutor.java
@@ -18,16 +18,14 @@
package org.apache.shardingsphere.shadow.distsql.handler.update;
import lombok.Setter;
+import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleAlterExecutor;
import org.apache.shardingsphere.distsql.handler.exception.algorithm.AlgorithmInUsedException;
import org.apache.shardingsphere.distsql.handler.exception.rule.DuplicateRuleException;
import org.apache.shardingsphere.distsql.handler.exception.rule.MissingRequiredRuleException;
import org.apache.shardingsphere.distsql.handler.required.DistSQLExecutorCurrentRuleRequired;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleAlterExecutor;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
-import org.apache.shardingsphere.shadow.api.config.datasource.ShadowDataSourceConfiguration;
-import org.apache.shardingsphere.shadow.api.config.table.ShadowTableConfiguration;
import org.apache.shardingsphere.shadow.distsql.handler.checker.ShadowRuleStatementChecker;
import org.apache.shardingsphere.shadow.distsql.handler.converter.ShadowRuleStatementConverter;
import org.apache.shardingsphere.shadow.distsql.handler.supporter.ShadowRuleStatementSupporter;
@@ -38,7 +36,6 @@ import org.apache.shardingsphere.shadow.rule.ShadowRule;
import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
import java.util.Collection;
-import java.util.Map;
/**
* Alter shadow rule executor.
@@ -88,21 +85,6 @@ public final class AlterShadowRuleExecutor implements DatabaseRuleAlterExecutor<
return result;
}
- @Override
- public void updateCurrentRuleConfiguration(final ShadowRuleConfiguration currentRuleConfig, final ShadowRuleConfiguration toBeAlteredRuleConfig) {
- updateDataSources(currentRuleConfig, toBeAlteredRuleConfig.getDataSources());
- updateTables(currentRuleConfig.getTables(), toBeAlteredRuleConfig.getTables());
- currentRuleConfig.getShadowAlgorithms().putAll(toBeAlteredRuleConfig.getShadowAlgorithms());
- }
-
- private void updateDataSources(final ShadowRuleConfiguration currentRuleConfig, final Collection<ShadowDataSourceConfiguration> toBeAlteredDataSources) {
- currentRuleConfig.getDataSources().addAll(toBeAlteredDataSources);
- }
-
- private void updateTables(final Map<String, ShadowTableConfiguration> currentTables, final Map<String, ShadowTableConfiguration> toBeAlteredTables) {
- toBeAlteredTables.forEach(currentTables::replace);
- }
-
@Override
public Class<ShadowRule> getRuleClass() {
return ShadowRule.class;
diff --git a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateDefaultShadowAlgorithmExecutor.java b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateDefaultShadowAlgorithmExecutor.java
index c9dee254764..f9df45b8b7b 100644
--- a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateDefaultShadowAlgorithmExecutor.java
+++ b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateDefaultShadowAlgorithmExecutor.java
@@ -17,11 +17,10 @@
package org.apache.shardingsphere.shadow.distsql.handler.update;
-import com.google.common.base.Strings;
import lombok.Setter;
+import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleCreateExecutor;
import org.apache.shardingsphere.distsql.handler.exception.algorithm.DuplicateAlgorithmException;
import org.apache.shardingsphere.distsql.handler.exception.algorithm.InvalidAlgorithmConfigurationException;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleCreateExecutor;
import org.apache.shardingsphere.distsql.segment.AlgorithmSegment;
import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
@@ -92,14 +91,6 @@ public final class CreateDefaultShadowAlgorithmExecutor implements DatabaseRuleC
new AlgorithmConfiguration(sqlStatement.getShadowAlgorithmSegment().getAlgorithmSegment().getName(), sqlStatement.getShadowAlgorithmSegment().getAlgorithmSegment().getProps()));
}
- @Override
- public void updateCurrentRuleConfiguration(final ShadowRuleConfiguration currentRuleConfig, final ShadowRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getShadowAlgorithms().putAll(toBeCreatedRuleConfig.getShadowAlgorithms());
- if (!Strings.isNullOrEmpty(toBeCreatedRuleConfig.getDefaultShadowAlgorithmName())) {
- currentRuleConfig.setDefaultShadowAlgorithmName(toBeCreatedRuleConfig.getDefaultShadowAlgorithmName());
- }
- }
-
@Override
public Class<ShadowRule> getRuleClass() {
return ShadowRule.class;
diff --git a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateShadowRuleExecutor.java b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateShadowRuleExecutor.java
index b6719e47641..b41b865768b 100644
--- a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateShadowRuleExecutor.java
+++ b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/CreateShadowRuleExecutor.java
@@ -89,13 +89,6 @@ public final class CreateShadowRuleExecutor implements DatabaseRuleCreateExecuto
return ShadowRuleStatementConverter.convert(segments);
}
- @Override
- public void updateCurrentRuleConfiguration(final ShadowRuleConfiguration currentRuleConfig, final ShadowRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getDataSources().addAll(toBeCreatedRuleConfig.getDataSources());
- currentRuleConfig.getShadowAlgorithms().putAll(toBeCreatedRuleConfig.getShadowAlgorithms());
- updateTables(currentRuleConfig.getTables(), toBeCreatedRuleConfig.getTables());
- }
-
private void updateTables(final Map<String, ShadowTableConfiguration> currentTables, final Map<String, ShadowTableConfiguration> toBeCreateTables) {
toBeCreateTables.forEach((key, value) -> currentTables.merge(key, value, ShadowRuleStatementSupporter::mergeConfiguration));
}
diff --git a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropDefaultShadowAlgorithmExecutor.java b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropDefaultShadowAlgorithmExecutor.java
index c459c48d028..94618c8581e 100644
--- a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropDefaultShadowAlgorithmExecutor.java
+++ b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropDefaultShadowAlgorithmExecutor.java
@@ -66,13 +66,6 @@ public final class DropDefaultShadowAlgorithmExecutor implements DatabaseRuleDro
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropDefaultShadowAlgorithmStatement sqlStatement, final ShadowRuleConfiguration currentRuleConfig) {
- currentRuleConfig.getShadowAlgorithms().remove(currentRuleConfig.getDefaultShadowAlgorithmName());
- currentRuleConfig.setDefaultShadowAlgorithmName(null);
- return currentRuleConfig.isEmpty();
- }
-
@Override
public Class<ShadowRule> getRuleClass() {
return ShadowRule.class;
diff --git a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowAlgorithmExecutor.java b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowAlgorithmExecutor.java
index 1f9147185e4..5fadaf46dad 100644
--- a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowAlgorithmExecutor.java
+++ b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowAlgorithmExecutor.java
@@ -93,15 +93,6 @@ public final class DropShadowAlgorithmExecutor implements DatabaseRuleDropExecut
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropShadowAlgorithmStatement sqlStatement, final ShadowRuleConfiguration currentRuleConfig) {
- Collection<String> algorithmNames = sqlStatement.getNames();
- algorithmNames.forEach(each -> currentRuleConfig.getShadowAlgorithms().remove(each));
- currentRuleConfig.getTables().forEach((key, value) -> value.getShadowAlgorithmNames().removeIf(algorithmNames::contains));
- getEmptyTableRules(currentRuleConfig.getTables()).forEach(each -> currentRuleConfig.getTables().remove(each));
- return false;
- }
-
private Collection<String> getEmptyTableRules(final Map<String, ShadowTableConfiguration> tables) {
return tables.entrySet().stream().filter(entry -> entry.getValue().getShadowAlgorithmNames().isEmpty() && entry.getValue().getDataSourceNames().isEmpty())
.map(Entry::getKey).collect(Collectors.toSet());
diff --git a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleExecutor.java b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleExecutor.java
index d4e45ad6242..de1b95a98ff 100644
--- a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleExecutor.java
+++ b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleExecutor.java
@@ -105,17 +105,6 @@ public final class DropShadowRuleExecutor implements DatabaseRuleDropExecutor<Dr
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropShadowRuleStatement sqlStatement, final ShadowRuleConfiguration currentRuleConfig) {
- for (String each : sqlStatement.getNames()) {
- dropRule(each);
- }
- currentRuleConfig.getTables().forEach((key, value) -> value.getDataSourceNames().removeIf(sqlStatement.getNames()::contains));
- currentRuleConfig.getTables().entrySet().removeIf(entry -> entry.getValue().getDataSourceNames().isEmpty());
- dropUnusedAlgorithm(currentRuleConfig);
- return currentRuleConfig.isEmpty();
- }
-
private void dropRule(final String ruleName) {
Optional<ShadowDataSourceConfiguration> dataSourceRuleConfig = rule.getConfiguration().getDataSources().stream().filter(each -> ruleName.equals(each.getName())).findAny();
dataSourceRuleConfig.ifPresent(optional -> rule.getConfiguration().getDataSources().remove(optional));
diff --git a/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropDefaultShadowAlgorithmExecutorTest.java b/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropDefaultShadowAlgorithmExecutorTest.java
index 6b87d60727d..d6fc548fcd4 100644
--- a/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropDefaultShadowAlgorithmExecutorTest.java
+++ b/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropDefaultShadowAlgorithmExecutorTest.java
@@ -30,7 +30,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
-import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
@@ -74,8 +76,8 @@ class DropDefaultShadowAlgorithmExecutorTest {
executor.checkBeforeUpdate(new DropDefaultShadowAlgorithmStatement(true));
DropDefaultShadowAlgorithmStatement sqlStatement = new DropDefaultShadowAlgorithmStatement(false);
assertTrue(executor.hasAnyOneToBeDropped(sqlStatement));
- executor.updateCurrentRuleConfiguration(sqlStatement, ruleConfig);
- assertNull(ruleConfig.getDefaultShadowAlgorithmName());
- assertTrue(ruleConfig.getShadowAlgorithms().isEmpty());
+ ShadowRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertFalse(toBeDroppedRuleConfig.getDefaultShadowAlgorithmName().isEmpty());
+ assertThat(toBeDroppedRuleConfig.getShadowAlgorithms().size(), is(1));
}
}
diff --git a/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowAlgorithmExecutorTest.java b/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowAlgorithmExecutorTest.java
index 490e5e61ef0..45b2b3fa8af 100644
--- a/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowAlgorithmExecutorTest.java
+++ b/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowAlgorithmExecutorTest.java
@@ -28,7 +28,8 @@ import org.junit.jupiter.api.Test;
import java.util.Arrays;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -60,8 +61,8 @@ class DropShadowAlgorithmExecutorTest {
executor.setRule(rule);
DropShadowAlgorithmStatement sqlStatement = createSQLStatement("shadow_algorithm");
executor.checkBeforeUpdate(sqlStatement);
- executor.updateCurrentRuleConfiguration(sqlStatement, ruleConfig);
- assertTrue(ruleConfig.getShadowAlgorithms().isEmpty());
+ ShadowRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertThat(toBeDroppedRuleConfig.getShadowAlgorithms().size(), is(1));
}
private DropShadowAlgorithmStatement createSQLStatement(final String... ruleName) {
diff --git a/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowRuleExecutorTest.java b/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowRuleExecutorTest.java
index 536bf8a301f..4e77551edee 100644
--- a/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowRuleExecutorTest.java
+++ b/features/shadow/distsql/handler/src/test/java/org/apache/shardingsphere/shadow/distsql/update/DropShadowRuleExecutorTest.java
@@ -37,7 +37,6 @@ import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -76,10 +75,10 @@ class DropShadowRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- assertTrue(executor.updateCurrentRuleConfiguration(sqlStatement, ruleConfig));
- assertTrue(ruleConfig.getDataSources().isEmpty());
- assertTrue(ruleConfig.getTables().isEmpty());
- assertTrue(ruleConfig.getShadowAlgorithms().isEmpty());
+ ShadowRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertThat(toBeDroppedRuleConfig.getDataSources().size(), is(1));
+ assertThat(toBeDroppedRuleConfig.getTables().size(), is(1));
+ assertThat(toBeDroppedRuleConfig.getShadowAlgorithms().size(), is(1));
}
@Test
@@ -90,10 +89,10 @@ class DropShadowRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- assertTrue(executor.updateCurrentRuleConfiguration(sqlStatement, ruleConfig));
- assertTrue(ruleConfig.getDataSources().isEmpty());
- assertTrue(ruleConfig.getTables().isEmpty());
- assertThat(ruleConfig.getShadowAlgorithms().size(), is(1));
+ ShadowRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertThat(toBeDroppedRuleConfig.getDataSources().size(), is(1));
+ assertThat(toBeDroppedRuleConfig.getTables().size(), is(1));
+ assertThat(toBeDroppedRuleConfig.getShadowAlgorithms().size(), is(1));
}
private DropShadowRuleStatement createSQLStatement(final String... ruleName) {
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterDefaultShardingStrategyExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterDefaultShardingStrategyExecutor.java
index 9e64bca622e..3145fcd4ed3 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterDefaultShardingStrategyExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterDefaultShardingStrategyExecutor.java
@@ -128,19 +128,6 @@ public final class AlterDefaultShardingStrategyExecutor implements DatabaseRuleA
return result;
}
- @Override
- public void updateCurrentRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeAlteredRuleConfig) {
- if (!toBeAlteredRuleConfig.getShardingAlgorithms().isEmpty()) {
- currentRuleConfig.getShardingAlgorithms().putAll(toBeAlteredRuleConfig.getShardingAlgorithms());
- }
- if (null != toBeAlteredRuleConfig.getDefaultTableShardingStrategy()) {
- currentRuleConfig.setDefaultTableShardingStrategy(toBeAlteredRuleConfig.getDefaultTableShardingStrategy());
- }
- if (null != toBeAlteredRuleConfig.getDefaultDatabaseShardingStrategy()) {
- currentRuleConfig.setDefaultDatabaseShardingStrategy(toBeAlteredRuleConfig.getDefaultDatabaseShardingStrategy());
- }
- }
-
@Override
public Class<ShardingRule> getRuleClass() {
return ShardingRule.class;
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableReferenceRuleExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableReferenceRuleExecutor.java
index e6ce5ce153b..98692786420 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableReferenceRuleExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableReferenceRuleExecutor.java
@@ -122,13 +122,6 @@ public final class AlterShardingTableReferenceRuleExecutor implements DatabaseRu
return null;
}
- @Override
- public void updateCurrentRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeAlteredRuleConfig) {
- Collection<String> toBeAlteredRuleNames = getToBeAlteredRuleNames(toBeAlteredRuleConfig);
- currentRuleConfig.getBindingTableGroups().removeIf(each -> toBeAlteredRuleNames.contains(each.getName()));
- currentRuleConfig.getBindingTableGroups().addAll(toBeAlteredRuleConfig.getBindingTableGroups());
- }
-
@Override
public Class<ShardingRule> getRuleClass() {
return ShardingRule.class;
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableRuleExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableRuleExecutor.java
index 2b3e33c3917..3263560a1a8 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableRuleExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/AlterShardingTableRuleExecutor.java
@@ -74,34 +74,6 @@ public final class AlterShardingTableRuleExecutor implements DatabaseRuleAlterEx
return result;
}
- @Override
- public void updateCurrentRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeAlteredRuleConfig) {
- removeRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- addRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- }
-
- private void removeRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeAlteredRuleConfig) {
- Collection<String> toBeAlteredLogicTableNames = getAlteredLogicalTableNames(toBeAlteredRuleConfig);
- toBeAlteredLogicTableNames.forEach(each -> {
- currentRuleConfig.getTables().removeIf(table -> table.getLogicTable().equalsIgnoreCase(each));
- currentRuleConfig.getAutoTables().removeIf(table -> table.getLogicTable().equalsIgnoreCase(each));
- });
- }
-
- private Collection<String> getAlteredLogicalTableNames(final ShardingRuleConfiguration toBeAlteredRuleConfig) {
- Collection<String> result = toBeAlteredRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toList());
- result.addAll(toBeAlteredRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toList()));
- return result;
- }
-
- private void addRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeAlteredRuleConfig) {
- currentRuleConfig.getTables().addAll(toBeAlteredRuleConfig.getTables());
- currentRuleConfig.getAutoTables().addAll(toBeAlteredRuleConfig.getAutoTables());
- currentRuleConfig.getShardingAlgorithms().putAll(toBeAlteredRuleConfig.getShardingAlgorithms());
- currentRuleConfig.getKeyGenerators().putAll(toBeAlteredRuleConfig.getKeyGenerators());
- currentRuleConfig.getAuditors().putAll(toBeAlteredRuleConfig.getAuditors());
- }
-
@Override
public Class<ShardingRule> getRuleClass() {
return ShardingRule.class;
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateDefaultShardingStrategyExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateDefaultShardingStrategyExecutor.java
index 38595632a38..977b1dc17f6 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateDefaultShardingStrategyExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateDefaultShardingStrategyExecutor.java
@@ -119,22 +119,6 @@ public final class CreateDefaultShardingStrategyExecutor implements DatabaseRule
}
}
- @Override
- public void updateCurrentRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeCreatedRuleConfig) {
- if (null != toBeCreatedRuleConfig.getDefaultTableShardingStrategy() && null == currentRuleConfig.getDefaultTableShardingStrategy()) {
- currentRuleConfig.setDefaultTableShardingStrategy(toBeCreatedRuleConfig.getDefaultTableShardingStrategy());
- if (!toBeCreatedRuleConfig.getShardingAlgorithms().isEmpty()) {
- currentRuleConfig.getShardingAlgorithms().putAll(toBeCreatedRuleConfig.getShardingAlgorithms());
- }
- }
- if (null != toBeCreatedRuleConfig.getDefaultDatabaseShardingStrategy() && null == currentRuleConfig.getDefaultDatabaseShardingStrategy()) {
- currentRuleConfig.setDefaultDatabaseShardingStrategy(toBeCreatedRuleConfig.getDefaultDatabaseShardingStrategy());
- if (!toBeCreatedRuleConfig.getShardingAlgorithms().isEmpty()) {
- currentRuleConfig.getShardingAlgorithms().putAll(toBeCreatedRuleConfig.getShardingAlgorithms());
- }
- }
- }
-
@Override
public Class<ShardingRule> getRuleClass() {
return ShardingRule.class;
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableReferenceRuleExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableReferenceRuleExecutor.java
index 0f3e977627a..ee312e60b70 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableReferenceRuleExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableReferenceRuleExecutor.java
@@ -113,11 +113,6 @@ public final class CreateShardingTableReferenceRuleExecutor implements DatabaseR
return sqlStatement.getRules().stream().map(TableReferenceRuleSegment::getName).filter(currentRuleNames::contains).collect(Collectors.toSet());
}
- @Override
- public void updateCurrentRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getBindingTableGroups().addAll(toBeCreatedRuleConfig.getBindingTableGroups());
- }
-
@Override
public Class<ShardingRule> getRuleClass() {
return ShardingRule.class;
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableRuleExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableRuleExecutor.java
index a52971b944b..7dbcdf6ceb8 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableRuleExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/CreateShardingTableRuleExecutor.java
@@ -59,15 +59,6 @@ public final class CreateShardingTableRuleExecutor implements DatabaseRuleCreate
return ShardingTableRuleStatementConverter.convert(segments);
}
- @Override
- public void updateCurrentRuleConfiguration(final ShardingRuleConfiguration currentRuleConfig, final ShardingRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getTables().addAll(toBeCreatedRuleConfig.getTables());
- currentRuleConfig.getAutoTables().addAll(toBeCreatedRuleConfig.getAutoTables());
- currentRuleConfig.getShardingAlgorithms().putAll(toBeCreatedRuleConfig.getShardingAlgorithms());
- currentRuleConfig.getKeyGenerators().putAll(toBeCreatedRuleConfig.getKeyGenerators());
- currentRuleConfig.getAuditors().putAll(toBeCreatedRuleConfig.getAuditors());
- }
-
private Collection<String> getDuplicatedRuleNames(final CreateShardingTableRuleStatement sqlStatement) {
Collection<String> currentShardingTables = null == rule ? Collections.emptyList() : getCurrentShardingTables();
return sqlStatement.getRules().stream().map(AbstractTableRuleSegment::getLogicTable).filter(currentShardingTables::contains).collect(Collectors.toSet());
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropDefaultShardingStrategyExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropDefaultShardingStrategyExecutor.java
index be2e87794c9..d5b0308625b 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropDefaultShardingStrategyExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropDefaultShardingStrategyExecutor.java
@@ -83,17 +83,6 @@ public final class DropDefaultShardingStrategyExecutor implements DatabaseRuleDr
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropDefaultShardingStrategyStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- if (sqlStatement.getDefaultType().equalsIgnoreCase(ShardingStrategyLevelType.TABLE.name())) {
- currentRuleConfig.setDefaultTableShardingStrategy(null);
- } else {
- currentRuleConfig.setDefaultDatabaseShardingStrategy(null);
- }
- UnusedAlgorithmFinder.findUnusedShardingAlgorithm(currentRuleConfig).forEach(each -> currentRuleConfig.getShardingAlgorithms().remove(each));
- return currentRuleConfig.isEmpty();
- }
-
@Override
public Class<ShardingRule> getRuleClass() {
return ShardingRule.class;
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAlgorithmExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAlgorithmExecutor.java
index a91ad39b6f9..d61cb16aeb2 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAlgorithmExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAlgorithmExecutor.java
@@ -104,14 +104,6 @@ public final class DropShardingAlgorithmExecutor implements DatabaseRuleDropExec
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropShardingAlgorithmStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- for (String each : sqlStatement.getNames()) {
- dropShardingAlgorithm(each);
- }
- return false;
- }
-
@Override
public boolean hasAnyOneToBeDropped(final DropShardingAlgorithmStatement sqlStatement) {
return !Collections.disjoint(getCurrentShardingAlgorithms(), sqlStatement.getNames());
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAuditorExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAuditorExecutor.java
index 1d348c95305..724ae459162 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAuditorExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingAuditorExecutor.java
@@ -86,12 +86,6 @@ public final class DropShardingAuditorExecutor implements DatabaseRuleDropExecut
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropShardingAuditorStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- currentRuleConfig.getAuditors().keySet().removeIf(sqlStatement.getNames()::contains);
- return false;
- }
-
@Override
public boolean hasAnyOneToBeDropped(final DropShardingAuditorStatement sqlStatement) {
return !Collections.disjoint(rule.getConfiguration().getAuditors().keySet(), sqlStatement.getNames());
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingKeyGeneratorExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingKeyGeneratorExecutor.java
index 7f5af539486..8e19b581dc0 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingKeyGeneratorExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingKeyGeneratorExecutor.java
@@ -87,12 +87,6 @@ public final class DropShardingKeyGeneratorExecutor implements DatabaseRuleDropE
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropShardingKeyGeneratorStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- currentRuleConfig.getKeyGenerators().keySet().removeIf(sqlStatement.getNames()::contains);
- return false;
- }
-
@Override
public boolean hasAnyOneToBeDropped(final DropShardingKeyGeneratorStatement sqlStatement) {
return !Collections.disjoint(rule.getConfiguration().getKeyGenerators().keySet(), sqlStatement.getNames());
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableReferenceExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableReferenceExecutor.java
index 38d538563f2..4c3ef858572 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableReferenceExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableReferenceExecutor.java
@@ -75,12 +75,6 @@ public final class DropShardingTableReferenceExecutor implements DatabaseRuleDro
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropShardingTableReferenceRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- currentRuleConfig.getBindingTableGroups().removeIf(each -> sqlStatement.getNames().stream().anyMatch(each.getName()::equalsIgnoreCase));
- return false;
- }
-
@Override
public boolean hasAnyOneToBeDropped(final DropShardingTableReferenceRuleStatement sqlStatement) {
return !Collections.disjoint(getCurrentShardingTableReferenceRuleNames(), sqlStatement.getNames());
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableRuleExecutor.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableRuleExecutor.java
index 696d6850832..3db6104beb7 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableRuleExecutor.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/update/DropShardingTableRuleExecutor.java
@@ -113,16 +113,6 @@ public final class DropShardingTableRuleExecutor implements DatabaseRuleDropExec
return result;
}
- @Override
- public boolean updateCurrentRuleConfiguration(final DropShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- Collection<String> toBeDroppedShardingTableNames = getToBeDroppedShardingTableNames(sqlStatement);
- toBeDroppedShardingTableNames.forEach(each -> dropShardingTable(currentRuleConfig, each));
- UnusedAlgorithmFinder.findUnusedShardingAlgorithm(currentRuleConfig).forEach(each -> currentRuleConfig.getShardingAlgorithms().remove(each));
- dropUnusedKeyGenerator(currentRuleConfig);
- dropUnusedAuditor(currentRuleConfig);
- return currentRuleConfig.isEmpty();
- }
-
private void dropShardingTable(final ShardingRuleConfiguration currentRuleConfig, final String tableName) {
currentRuleConfig.getTables().removeAll(currentRuleConfig.getTables().stream().filter(each -> tableName.equalsIgnoreCase(each.getLogicTable())).collect(Collectors.toList()));
currentRuleConfig.getAutoTables().removeAll(currentRuleConfig.getAutoTables().stream().filter(each -> tableName.equalsIgnoreCase(each.getLogicTable())).collect(Collectors.toList()));
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterDefaultShardingStrategyExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterDefaultShardingStrategyExecutorTest.java
index a499151d1af..09991cd9ebc 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterDefaultShardingStrategyExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterDefaultShardingStrategyExecutorTest.java
@@ -97,8 +97,7 @@ class AlterDefaultShardingStrategyExecutorTest {
AlterDefaultShardingStrategyStatement sqlStatement = new AlterDefaultShardingStrategyStatement("TABLE", "standard", "order_id", algorithm);
executor.checkBeforeUpdate(sqlStatement);
ShardingRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- StandardShardingStrategyConfiguration defaultTableShardingStrategy = (StandardShardingStrategyConfiguration) currentRuleConfig.getDefaultTableShardingStrategy();
+ StandardShardingStrategyConfiguration defaultTableShardingStrategy = (StandardShardingStrategyConfiguration) toBeAlteredRuleConfig.getDefaultTableShardingStrategy();
assertThat(defaultTableShardingStrategy.getShardingAlgorithmName(), is("default_table_order_id_algorithm"));
assertThat(defaultTableShardingStrategy.getShardingColumn(), is("order_id"));
}
@@ -113,9 +112,8 @@ class AlterDefaultShardingStrategyExecutorTest {
AlgorithmSegment databaseAlgorithmSegment = new AlgorithmSegment("inline", PropertiesBuilder.build(new Property("algorithm-expression", "ds_${user_id % 2}")));
AlterDefaultShardingStrategyStatement statement = new AlterDefaultShardingStrategyStatement("DATABASE", "standard", "user_id", databaseAlgorithmSegment);
executor.checkBeforeUpdate(statement);
- ShardingRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(statement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- StandardShardingStrategyConfiguration defaultDatabaseShardingStrategy = (StandardShardingStrategyConfiguration) currentRuleConfig.getDefaultDatabaseShardingStrategy();
+ ShardingRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(statement);
+ StandardShardingStrategyConfiguration defaultDatabaseShardingStrategy = (StandardShardingStrategyConfiguration) actual.getDefaultDatabaseShardingStrategy();
assertThat(defaultDatabaseShardingStrategy.getShardingAlgorithmName(), is("default_database_inline"));
assertThat(defaultDatabaseShardingStrategy.getShardingColumn(), is("user_id"));
}
@@ -130,9 +128,8 @@ class AlterDefaultShardingStrategyExecutorTest {
executor.setRule(rule);
AlterDefaultShardingStrategyStatement sqlStatement = new AlterDefaultShardingStrategyStatement("TABLE", "none", null, null);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- NoneShardingStrategyConfiguration defaultTableShardingStrategy = (NoneShardingStrategyConfiguration) currentRuleConfig.getDefaultTableShardingStrategy();
+ ShardingRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
+ NoneShardingStrategyConfiguration defaultTableShardingStrategy = (NoneShardingStrategyConfiguration) actual.getDefaultTableShardingStrategy();
assertThat(defaultTableShardingStrategy.getType(), is(""));
assertThat(defaultTableShardingStrategy.getShardingAlgorithmName(), is(""));
}
@@ -146,9 +143,8 @@ class AlterDefaultShardingStrategyExecutorTest {
executor.setRule(rule);
AlterDefaultShardingStrategyStatement sqlStatement = new AlterDefaultShardingStrategyStatement("DATABASE", "none", null, null);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- NoneShardingStrategyConfiguration defaultDatabaseShardingStrategy = (NoneShardingStrategyConfiguration) currentRuleConfig.getDefaultDatabaseShardingStrategy();
+ ShardingRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
+ NoneShardingStrategyConfiguration defaultDatabaseShardingStrategy = (NoneShardingStrategyConfiguration) actual.getDefaultDatabaseShardingStrategy();
assertThat(defaultDatabaseShardingStrategy.getType(), is(""));
assertThat(defaultDatabaseShardingStrategy.getShardingAlgorithmName(), is(""));
}
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableReferenceRuleExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableReferenceRuleExecutorTest.java
index 7729ac9cb45..4ab02f87c26 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableReferenceRuleExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableReferenceRuleExecutorTest.java
@@ -64,12 +64,11 @@ class AlterShardingTableReferenceRuleExecutorTest {
}
@Test
- void assertUpdate() {
- ShardingRuleConfiguration currentRuleConfig = createCurrentRuleConfiguration();
- executor.updateCurrentRuleConfiguration(currentRuleConfig, createToBeAlteredRuleConfig());
- assertThat(currentRuleConfig.getBindingTableGroups().size(), is(1));
- assertThat(currentRuleConfig.getBindingTableGroups().iterator().next().getName(), is("reference_0"));
- assertThat(currentRuleConfig.getBindingTableGroups().iterator().next().getReference(), is("t_order,t_order_item,t_1,t_2"));
+ void assertBuildToBeAlteredRuleConfiguration() {
+ ShardingRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(createSQLStatement("reference_0", "t_3,t_4"));
+ assertThat(actual.getBindingTableGroups().size(), is(1));
+ assertThat(actual.getBindingTableGroups().iterator().next().getName(), is("reference_0"));
+ assertThat(actual.getBindingTableGroups().iterator().next().getReference(), is("t_3,t_4"));
}
private AlterShardingTableReferenceRuleStatement createSQLStatement(final String name, final String reference) {
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableRuleExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableRuleExecutorTest.java
index c5745394a33..95cacc949d0 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableRuleExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/AlterShardingTableRuleExecutorTest.java
@@ -78,10 +78,9 @@ class AlterShardingTableRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- assertThat(currentRuleConfig.getTables().size(), is(1));
- ShardingTableRuleConfiguration tableRule = currentRuleConfig.getTables().iterator().next();
+ ShardingRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
+ assertThat(actual.getTables().size(), is(1));
+ ShardingTableRuleConfiguration tableRule = actual.getTables().iterator().next();
assertThat(tableRule.getLogicTable(), is("t_order"));
assertThat(tableRule.getActualDataNodes(), is("ds_${0..1}.t_order${0..1}"));
assertThat(tableRule.getTableShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
@@ -89,8 +88,8 @@ class AlterShardingTableRuleExecutorTest {
assertThat(tableRule.getTableShardingStrategy().getShardingAlgorithmName(), is("t_order_table_core.standard.fixture"));
assertThat(tableRule.getDatabaseShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
assertThat(tableRule.getDatabaseShardingStrategy().getShardingAlgorithmName(), is("t_order_database_inline"));
- assertThat(currentRuleConfig.getTables().size(), is(1));
- ShardingAutoTableRuleConfiguration autoTableRule = currentRuleConfig.getAutoTables().iterator().next();
+ assertThat(actual.getTables().size(), is(1));
+ ShardingAutoTableRuleConfiguration autoTableRule = actual.getAutoTables().iterator().next();
assertThat(autoTableRule.getLogicTable(), is("t_order_item"));
assertThat(autoTableRule.getActualDataSources(), is("ds_0,ds_1"));
assertThat(autoTableRule.getShardingStrategy().getShardingAlgorithmName(), is("t_order_item_foo.distsql.fixture"));
@@ -106,10 +105,9 @@ class AlterShardingTableRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- assertThat(currentRuleConfig.getTables().size(), is(1));
- ShardingTableRuleConfiguration tableRule = currentRuleConfig.getTables().iterator().next();
+ ShardingRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
+ assertThat(actual.getTables().size(), is(1));
+ ShardingTableRuleConfiguration tableRule = actual.getTables().iterator().next();
assertThat(tableRule.getLogicTable(), is("T_ORDER"));
assertThat(tableRule.getActualDataNodes(), is("ds_${0..1}.t_order${0..1}"));
assertThat(tableRule.getTableShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
@@ -117,8 +115,8 @@ class AlterShardingTableRuleExecutorTest {
assertThat(tableRule.getTableShardingStrategy().getShardingAlgorithmName(), is("t_order_table_core.standard.fixture"));
assertThat(tableRule.getDatabaseShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
assertThat(tableRule.getDatabaseShardingStrategy().getShardingAlgorithmName(), is("t_order_database_inline"));
- assertThat(currentRuleConfig.getTables().size(), is(1));
- ShardingAutoTableRuleConfiguration autoTableRule = currentRuleConfig.getAutoTables().iterator().next();
+ assertThat(actual.getTables().size(), is(1));
+ ShardingAutoTableRuleConfiguration autoTableRule = actual.getAutoTables().iterator().next();
assertThat(autoTableRule.getLogicTable(), is("T_ORDER_ITEM"));
assertThat(autoTableRule.getActualDataSources(), is("ds_0,ds_1"));
assertThat(autoTableRule.getShardingStrategy().getShardingAlgorithmName(), is("t_order_item_foo.distsql.fixture"));
@@ -134,10 +132,9 @@ class AlterShardingTableRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- assertThat(currentRuleConfig.getTables().size(), is(1));
- ShardingTableRuleConfiguration tableRule = currentRuleConfig.getTables().iterator().next();
+ ShardingRuleConfiguration actual = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
+ assertThat(actual.getTables().size(), is(1));
+ ShardingTableRuleConfiguration tableRule = actual.getTables().iterator().next();
assertThat(tableRule.getLogicTable(), is("t_order_item"));
assertThat(tableRule.getActualDataNodes(), is("ds_${0..1}.t_order${0..1}"));
assertThat(tableRule.getTableShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
@@ -145,8 +142,8 @@ class AlterShardingTableRuleExecutorTest {
assertThat(tableRule.getTableShardingStrategy().getShardingAlgorithmName(), is("t_order_item_table_core.standard.fixture"));
assertThat(tableRule.getDatabaseShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
assertThat(tableRule.getDatabaseShardingStrategy().getShardingAlgorithmName(), is("t_order_item_database_inline"));
- assertThat(currentRuleConfig.getTables().size(), is(1));
- ShardingAutoTableRuleConfiguration autoTableRule = currentRuleConfig.getAutoTables().iterator().next();
+ assertThat(actual.getTables().size(), is(1));
+ ShardingAutoTableRuleConfiguration autoTableRule = actual.getAutoTables().iterator().next();
assertThat(autoTableRule.getLogicTable(), is("t_order"));
assertThat(autoTableRule.getActualDataSources(), is("ds_0,ds_1"));
assertThat(autoTableRule.getShardingStrategy().getShardingAlgorithmName(), is("t_order_foo.distsql.fixture"));
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateDefaultShardingStrategyExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateDefaultShardingStrategyExecutorTest.java
index cc4047091cf..30773325bd0 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateDefaultShardingStrategyExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateDefaultShardingStrategyExecutorTest.java
@@ -104,9 +104,8 @@ class CreateDefaultShardingStrategyExecutorTest {
AlgorithmSegment algorithm = new AlgorithmSegment("order_id_algorithm", new Properties());
CreateDefaultShardingStrategyStatement sqlStatement = new CreateDefaultShardingStrategyStatement(false, "TABLE", "standard", "order_id", algorithm);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- StandardShardingStrategyConfiguration defaultTableShardingStrategy = (StandardShardingStrategyConfiguration) currentRuleConfig.getDefaultTableShardingStrategy();
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
+ StandardShardingStrategyConfiguration defaultTableShardingStrategy = (StandardShardingStrategyConfiguration) actual.getDefaultTableShardingStrategy();
assertThat(defaultTableShardingStrategy.getShardingAlgorithmName(), is("default_table_order_id_algorithm"));
assertThat(defaultTableShardingStrategy.getShardingColumn(), is("order_id"));
}
@@ -120,9 +119,8 @@ class CreateDefaultShardingStrategyExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(statement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(statement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- StandardShardingStrategyConfiguration defaultDatabaseShardingStrategy = (StandardShardingStrategyConfiguration) currentRuleConfig.getDefaultDatabaseShardingStrategy();
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(statement);
+ StandardShardingStrategyConfiguration defaultDatabaseShardingStrategy = (StandardShardingStrategyConfiguration) actual.getDefaultDatabaseShardingStrategy();
assertThat(defaultDatabaseShardingStrategy.getShardingAlgorithmName(), is("default_database_inline"));
assertThat(defaultDatabaseShardingStrategy.getShardingColumn(), is("user_id"));
}
@@ -138,39 +136,15 @@ class CreateDefaultShardingStrategyExecutorTest {
AlgorithmSegment algorithm = new AlgorithmSegment("order_id_algorithm", new Properties());
CreateDefaultShardingStrategyStatement sqlStatement = new CreateDefaultShardingStrategyStatement(false, "TABLE", "standard", "order_id", algorithm);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
algorithm = new AlgorithmSegment("user_id_algorithm", new Properties());
CreateDefaultShardingStrategyStatement statementWithIfNotExists = new CreateDefaultShardingStrategyStatement(true, "TABLE", "standard", "order_id", algorithm);
executor.checkBeforeUpdate(statementWithIfNotExists);
- toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(statementWithIfNotExists);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- StandardShardingStrategyConfiguration defaultTableShardingStrategy = (StandardShardingStrategyConfiguration) currentRuleConfig.getDefaultTableShardingStrategy();
- assertThat(defaultTableShardingStrategy.getShardingAlgorithmName(), is("default_table_order_id_algorithm"));
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(statementWithIfNotExists);
+ StandardShardingStrategyConfiguration defaultTableShardingStrategy = (StandardShardingStrategyConfiguration) actual.getDefaultTableShardingStrategy();
+ assertThat(defaultTableShardingStrategy.getShardingAlgorithmName(), is("default_table_user_id_algorithm"));
assertThat(defaultTableShardingStrategy.getShardingColumn(), is("order_id"));
}
- @Test
- void assertCreateDefaultDatabaseShardingStrategyWithIfNotExists() {
- AlgorithmSegment databaseAlgorithmSegment = new AlgorithmSegment("inline", PropertiesBuilder.build(new Property("algorithm-expression", "ds_${user_id % 2}")));
- CreateDefaultShardingStrategyStatement statement = new CreateDefaultShardingStrategyStatement(false, "DATABASE", "standard", "user_id", databaseAlgorithmSegment);
- ShardingRuleConfiguration currentRuleConfig = new ShardingRuleConfiguration();
- ShardingRule rule = mock(ShardingRule.class);
- when(rule.getConfiguration()).thenReturn(currentRuleConfig);
- executor.setRule(rule);
- executor.checkBeforeUpdate(statement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(statement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- databaseAlgorithmSegment = new AlgorithmSegment("inline", PropertiesBuilder.build(new Property("algorithm-expression", "ds_${order_id % 2}")));
- CreateDefaultShardingStrategyStatement statementWithIfNotExists = new CreateDefaultShardingStrategyStatement(true, "TABLE", "standard", "order_id", databaseAlgorithmSegment);
- executor.checkBeforeUpdate(statementWithIfNotExists);
- toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(statementWithIfNotExists);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- StandardShardingStrategyConfiguration defaultDatabaseShardingStrategy = (StandardShardingStrategyConfiguration) currentRuleConfig.getDefaultDatabaseShardingStrategy();
- assertThat(defaultDatabaseShardingStrategy.getShardingAlgorithmName(), is("default_database_inline"));
- assertThat(defaultDatabaseShardingStrategy.getShardingColumn(), is("user_id"));
- }
-
@Test
void assertCreateDefaultTableShardingStrategyWithNoneShardingStrategyType() {
ShardingRuleConfiguration currentRuleConfig = new ShardingRuleConfiguration();
@@ -181,9 +155,8 @@ class CreateDefaultShardingStrategyExecutorTest {
executor.setRule(rule);
CreateDefaultShardingStrategyStatement sqlStatement = new CreateDefaultShardingStrategyStatement(false, "TABLE", "none", null, null);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- NoneShardingStrategyConfiguration defaultTableShardingStrategy = (NoneShardingStrategyConfiguration) currentRuleConfig.getDefaultTableShardingStrategy();
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
+ NoneShardingStrategyConfiguration defaultTableShardingStrategy = (NoneShardingStrategyConfiguration) actual.getDefaultTableShardingStrategy();
assertThat(defaultTableShardingStrategy.getType(), is(""));
assertThat(defaultTableShardingStrategy.getShardingAlgorithmName(), is(""));
}
@@ -196,9 +169,8 @@ class CreateDefaultShardingStrategyExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- NoneShardingStrategyConfiguration defaultDatabaseShardingStrategy = (NoneShardingStrategyConfiguration) currentRuleConfig.getDefaultDatabaseShardingStrategy();
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
+ NoneShardingStrategyConfiguration defaultDatabaseShardingStrategy = (NoneShardingStrategyConfiguration) actual.getDefaultDatabaseShardingStrategy();
assertThat(defaultDatabaseShardingStrategy.getType(), is(""));
assertThat(defaultDatabaseShardingStrategy.getShardingAlgorithmName(), is(""));
}
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableReferenceRuleExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableReferenceRuleExecutorTest.java
index 84ad3a30e58..0a15ad5dec4 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableReferenceRuleExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableReferenceRuleExecutorTest.java
@@ -31,7 +31,6 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.Collection;
-import java.util.Iterator;
import java.util.LinkedList;
import static org.hamcrest.CoreMatchers.is;
@@ -80,12 +79,9 @@ class CreateShardingTableReferenceRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- Collection<ShardingTableReferenceRuleConfiguration> referenceRuleConfigs = currentRuleConfig.getBindingTableGroups();
- assertThat(referenceRuleConfigs.size(), is(1));
- Iterator<ShardingTableReferenceRuleConfiguration> iterator = referenceRuleConfigs.iterator();
- assertThat(iterator.next().getReference(), is("t_1,t_2"));
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
+ Collection<ShardingTableReferenceRuleConfiguration> referenceRuleConfigs = actual.getBindingTableGroups();
+ assertThat(referenceRuleConfigs.size(), is(0));
}
private ShardingRuleConfiguration getCurrentRuleConfig() {
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableRuleExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableRuleExecutorTest.java
index e4a12ce43d9..5d0d41f9c4c 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableRuleExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/CreateShardingTableRuleExecutorTest.java
@@ -91,40 +91,26 @@ class CreateShardingTableRuleExecutorTest {
}
@Test
- void assertUpdate() {
+ void assertBuildToBeCreatedRuleConfiguration() {
CreateShardingTableRuleStatement sqlStatement = new CreateShardingTableRuleStatement(false, Arrays.asList(createCompleteAutoTableRule(), createCompleteTableRule()));
ShardingRule rule = mock(ShardingRule.class);
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- ShardingRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- assertThat(currentRuleConfig.getTables().size(), is(2));
- Iterator<ShardingTableRuleConfiguration> tableRuleIterator = currentRuleConfig.getTables().iterator();
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
+ assertThat(actual.getTables().size(), is(1));
+ Iterator<ShardingTableRuleConfiguration> tableRuleIterator = actual.getTables().iterator();
ShardingTableRuleConfiguration tableRule = tableRuleIterator.next();
assertThat(tableRule.getTableShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
- assertThat(tableRule.getLogicTable(), is("t_order"));
- assertThat(tableRule.getActualDataNodes(), is("ds_${0..1}.t_order_${0..1}"));
- assertThat(((StandardShardingStrategyConfiguration) tableRule.getTableShardingStrategy()).getShardingColumn(), is("order_id"));
- assertThat(tableRule.getTableShardingStrategy().getShardingAlgorithmName(), is("t_order_algorithm"));
- tableRule = tableRuleIterator.next();
- assertThat(tableRule.getTableShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
assertThat(tableRule.getLogicTable(), is("t_order_input"));
assertThat(tableRule.getActualDataNodes(), is("ds_${0..1}.t_order_${0..1}"));
assertThat(((StandardShardingStrategyConfiguration) tableRule.getTableShardingStrategy()).getShardingColumn(), is("product_id"));
assertThat(tableRule.getTableShardingStrategy().getShardingAlgorithmName(), is("t_order_input_table_core.standard.fixture"));
assertThat(tableRule.getDatabaseShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
assertThat(tableRule.getDatabaseShardingStrategy().getShardingAlgorithmName(), is("t_order_input_database_inline"));
- assertThat(currentRuleConfig.getTables().size(), is(2));
- Iterator<ShardingAutoTableRuleConfiguration> autoTableIterator = currentRuleConfig.getAutoTables().iterator();
+ assertThat(actual.getTables().size(), is(1));
+ Iterator<ShardingAutoTableRuleConfiguration> autoTableIterator = actual.getAutoTables().iterator();
ShardingAutoTableRuleConfiguration autoTableRule = autoTableIterator.next();
- assertThat(autoTableRule.getLogicTable(), is("t_order_item"));
- assertThat(autoTableRule.getActualDataSources(), is("ds_0"));
- assertThat(autoTableRule.getShardingStrategy().getShardingAlgorithmName(), is("t_order_mod_test"));
- assertThat(((StandardShardingStrategyConfiguration) autoTableRule.getShardingStrategy()).getShardingColumn(), is("order_id"));
- assertThat(autoTableRule.getKeyGenerateStrategy().getColumn(), is("product_id"));
- assertThat(autoTableRule.getKeyGenerateStrategy().getKeyGeneratorName(), is("product_id_DISTSQL.FIXTURE"));
- autoTableRule = autoTableIterator.next();
assertThat(autoTableRule.getLogicTable(), is("t_order_item_input"));
assertThat(autoTableRule.getActualDataSources(), is("logic_ds"));
assertThat(autoTableRule.getShardingStrategy().getShardingAlgorithmName(), is("t_order_item_input_foo.distsql.fixture"));
@@ -209,33 +195,20 @@ class CreateShardingTableRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(statementWithIfNotExists);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, executor.buildToBeCreatedRuleConfiguration(statementWithIfNotExists));
- assertThat(currentRuleConfig.getTables().size(), is(2));
- Iterator<ShardingTableRuleConfiguration> tableRuleIterator = currentRuleConfig.getTables().iterator();
+ ShardingRuleConfiguration actual = executor.buildToBeCreatedRuleConfiguration(statementWithIfNotExists);
+ assertThat(actual.getTables().size(), is(1));
+ Iterator<ShardingTableRuleConfiguration> tableRuleIterator = actual.getTables().iterator();
ShardingTableRuleConfiguration tableRule = tableRuleIterator.next();
assertThat(tableRule.getTableShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
- assertThat(tableRule.getLogicTable(), is("t_order"));
- assertThat(tableRule.getActualDataNodes(), is("ds_${0..1}.t_order_${0..1}"));
- assertThat(((StandardShardingStrategyConfiguration) tableRule.getTableShardingStrategy()).getShardingColumn(), is("order_id"));
- assertThat(tableRule.getTableShardingStrategy().getShardingAlgorithmName(), is("t_order_algorithm"));
- tableRule = tableRuleIterator.next();
- assertThat(tableRule.getTableShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
assertThat(tableRule.getLogicTable(), is("t_order_input"));
assertThat(tableRule.getActualDataNodes(), is("ds_${0..1}.t_order_${0..1}"));
assertThat(((StandardShardingStrategyConfiguration) tableRule.getTableShardingStrategy()).getShardingColumn(), is("product_id"));
assertThat(tableRule.getTableShardingStrategy().getShardingAlgorithmName(), is("t_order_input_table_core.standard.fixture"));
assertThat(tableRule.getDatabaseShardingStrategy(), instanceOf(StandardShardingStrategyConfiguration.class));
assertThat(tableRule.getDatabaseShardingStrategy().getShardingAlgorithmName(), is("t_order_input_database_inline"));
- assertThat(currentRuleConfig.getTables().size(), is(2));
- Iterator<ShardingAutoTableRuleConfiguration> autoTableIterator = currentRuleConfig.getAutoTables().iterator();
+ assertThat(actual.getTables().size(), is(1));
+ Iterator<ShardingAutoTableRuleConfiguration> autoTableIterator = actual.getAutoTables().iterator();
ShardingAutoTableRuleConfiguration autoTableRule = autoTableIterator.next();
- assertThat(autoTableRule.getLogicTable(), is("t_order_item"));
- assertThat(autoTableRule.getActualDataSources(), is("ds_0"));
- assertThat(autoTableRule.getShardingStrategy().getShardingAlgorithmName(), is("t_order_mod_test"));
- assertThat(((StandardShardingStrategyConfiguration) autoTableRule.getShardingStrategy()).getShardingColumn(), is("order_id"));
- assertThat(autoTableRule.getKeyGenerateStrategy().getColumn(), is("product_id"));
- assertThat(autoTableRule.getKeyGenerateStrategy().getKeyGeneratorName(), is("product_id_DISTSQL.FIXTURE"));
- autoTableRule = autoTableIterator.next();
assertThat(autoTableRule.getLogicTable(), is("t_order_item_input"));
assertThat(autoTableRule.getActualDataSources(), is("logic_ds"));
assertThat(autoTableRule.getShardingStrategy().getShardingAlgorithmName(), is("t_order_item_input_foo.distsql.fixture"));
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropDefaultShardingStrategyExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropDefaultShardingStrategyExecutorTest.java
index ff20655b508..17e4d28af4f 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropDefaultShardingStrategyExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropDefaultShardingStrategyExecutorTest.java
@@ -34,10 +34,9 @@ import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -70,28 +69,34 @@ class DropDefaultShardingStrategyExecutorTest {
}
@Test
- void assertUpdateCurrentRuleConfiguration() {
- ShardingRuleConfiguration currentRuleConfig = createCurrentRuleConfiguration();
- executor.updateCurrentRuleConfiguration(createSQLStatement("Database"), currentRuleConfig);
- assertNull(currentRuleConfig.getDefaultDatabaseShardingStrategy());
- assertTrue(currentRuleConfig.getShardingAlgorithms().isEmpty());
+ void asserBuildToBeDroppedRuleConfiguration() {
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+ executor.setRule(rule);
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("Database"));
+ assertNotNull(actual.getDefaultDatabaseShardingStrategy());
+ assertThat(actual.getShardingAlgorithms().size(), is(1));
}
@Test
- void assertUpdateCurrentRuleConfigurationWithInUsedAlgorithm() {
- ShardingRuleConfiguration currentRuleConfig = createMultipleCurrentRuleConfiguration();
- executor.updateCurrentRuleConfiguration(createSQLStatement("Table"), currentRuleConfig);
- assertNull(currentRuleConfig.getDefaultTableShardingStrategy());
- assertThat(currentRuleConfig.getShardingAlgorithms().size(), is(1));
+ void asserBuildToBeDroppedRuleConfigurationWithInUsedAlgorithm() {
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+ executor.setRule(rule);
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("Table"));
+ assertNull(actual.getDefaultTableShardingStrategy());
+ assertThat(actual.getShardingAlgorithms().size(), is(0));
}
@Test
void assertUpdateMultipleStrategies() {
- ShardingRuleConfiguration currentRuleConfig = createMultipleCurrentRuleConfiguration();
- assertFalse(executor.updateCurrentRuleConfiguration(createSQLStatement("Database"), currentRuleConfig));
- assertTrue(executor.updateCurrentRuleConfiguration(createSQLStatement("Table"), currentRuleConfig));
- assertNull(currentRuleConfig.getDefaultTableShardingStrategy());
- assertTrue(currentRuleConfig.getShardingAlgorithms().isEmpty());
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+ executor.setRule(rule);
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("Database"));
+ assertNull(actual.getDefaultTableShardingStrategy());
+ actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("Table"));
+ assertThat(actual.getShardingAlgorithms().size(), is(1));
}
private DropDefaultShardingStrategyStatement createSQLStatement(final String defaultType) {
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAlgorithmExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAlgorithmExecutorTest.java
index b274b579b30..37eb51c223d 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAlgorithmExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAlgorithmExecutorTest.java
@@ -38,7 +38,6 @@ import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
@@ -88,7 +87,7 @@ class DropShardingAlgorithmExecutorTest {
}
@Test
- void assertUpdateCurrentRuleConfiguration() {
+ void assertBuildToBeDroppedRuleConfiguration() {
String toBeDroppedAlgorithmName = "t_test";
ShardingRuleConfiguration currentRuleConfig = createCurrentRuleConfiguration();
assertThat(currentRuleConfig.getShardingAlgorithms().size(), is(3));
@@ -96,25 +95,9 @@ class DropShardingAlgorithmExecutorTest {
ShardingRule rule = mock(ShardingRule.class);
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
- executor.updateCurrentRuleConfiguration(createSQLStatement(toBeDroppedAlgorithmName), currentRuleConfig);
- assertThat(currentRuleConfig.getShardingAlgorithms().size(), is(2));
- assertFalse(currentRuleConfig.getShardingAlgorithms().containsKey(toBeDroppedAlgorithmName));
- assertTrue(currentRuleConfig.getShardingAlgorithms().containsKey("t_order_db_inline"));
- }
-
- @Test
- void assertUpdateCurrentRuleConfigurationWithIfExists() {
- String toBeDroppedAlgorithmName = "t_test";
- ShardingRuleConfiguration currentRuleConfig = createCurrentRuleConfiguration();
- assertThat(currentRuleConfig.getShardingAlgorithms().size(), is(3));
- assertTrue(currentRuleConfig.getShardingAlgorithms().containsKey(toBeDroppedAlgorithmName));
- ShardingRule rule = mock(ShardingRule.class);
- when(rule.getConfiguration()).thenReturn(currentRuleConfig);
- executor.setRule(rule);
- executor.updateCurrentRuleConfiguration(createSQLStatementWithIfExists(toBeDroppedAlgorithmName), currentRuleConfig);
- assertThat(currentRuleConfig.getShardingAlgorithms().size(), is(2));
- assertFalse(currentRuleConfig.getShardingAlgorithms().containsKey(toBeDroppedAlgorithmName));
- assertTrue(currentRuleConfig.getShardingAlgorithms().containsKey("t_order_db_inline"));
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement(toBeDroppedAlgorithmName));
+ assertThat(actual.getShardingAlgorithms().size(), is(1));
+ assertTrue(actual.getShardingAlgorithms().containsKey(toBeDroppedAlgorithmName));
}
private DropShardingAlgorithmStatement createSQLStatement(final String algorithmName) {
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAuditorExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAuditorExecutorTest.java
index 84736c04b4e..787f47b25dd 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAuditorExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingAuditorExecutorTest.java
@@ -35,7 +35,7 @@ import java.util.Collections;
import java.util.Properties;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -72,8 +72,11 @@ class DropShardingAuditorExecutorTest {
void assertDropSpecifiedAuditor() {
ShardingRuleConfiguration currentRuleConfig = new ShardingRuleConfiguration();
currentRuleConfig.getAuditors().put("sharding_key_required_auditor", new AlgorithmConfiguration("DML_SHARDING_CONDITIONS", new Properties()));
- executor.updateCurrentRuleConfiguration(createSQLStatement("sharding_key_required_auditor"), currentRuleConfig);
- assertTrue(currentRuleConfig.getAuditors().isEmpty());
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(currentRuleConfig);
+ executor.setRule(rule);
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("sharding_key_required_auditor"));
+ assertFalse(actual.getAuditors().isEmpty());
}
@Test
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingKeyGeneratorExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingKeyGeneratorExecutorTest.java
index 2353d2628be..6451e8f4388 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingKeyGeneratorExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingKeyGeneratorExecutorTest.java
@@ -31,10 +31,10 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.Collections;
-import java.util.Properties;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -69,10 +69,11 @@ class DropShardingKeyGeneratorExecutorTest {
@Test
void assertDropSpecifiedKeyGenerator() {
DropShardingKeyGeneratorStatement sqlStatement = new DropShardingKeyGeneratorStatement(false, Collections.singleton("uuid_key_generator"));
- ShardingRuleConfiguration currentRuleConfig = new ShardingRuleConfiguration();
- currentRuleConfig.getKeyGenerators().put("uuid_key_generator", new AlgorithmConfiguration("uuid", new Properties()));
- new DropShardingKeyGeneratorExecutor().updateCurrentRuleConfiguration(sqlStatement, currentRuleConfig);
- assertTrue(currentRuleConfig.getKeyGenerators().isEmpty());
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(new ShardingRuleConfiguration());
+ executor.setRule(rule);
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertThat(actual.getKeyGenerators().size(), is(1));
}
@Test
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableReferenceExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableReferenceExecutorTest.java
index 9cbd5a74346..36a49839c1d 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableReferenceExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableReferenceExecutorTest.java
@@ -107,9 +107,9 @@ class DropShardingTableReferenceExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- executor.updateCurrentRuleConfiguration(sqlStatement, currentRuleConfig);
- assertThat(currentRuleConfig.getBindingTableGroups().size(), is(1));
- assertThat(currentRuleConfig.getBindingTableGroups().iterator().next().getReference(), is("t_order,t_order_item"));
+ ShardingRuleConfiguration toBeDroppedRuleConfig = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertThat(toBeDroppedRuleConfig.getBindingTableGroups().size(), is(1));
+ assertThat(toBeDroppedRuleConfig.getBindingTableGroups().iterator().next().getName(), is("reference_1"));
}
@Test
@@ -121,7 +121,7 @@ class DropShardingTableReferenceExecutorTest {
when(rule.getConfiguration()).thenReturn(currentRuleConfig);
executor.setRule(rule);
executor.checkBeforeUpdate(sqlStatement);
- executor.updateCurrentRuleConfiguration(sqlStatement, currentRuleConfig);
- assertTrue(currentRuleConfig.getBindingTableGroups().isEmpty());
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertThat(actual.getBindingTableGroups().size(), is(2));
}
}
diff --git a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableRuleExecutorTest.java b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableRuleExecutorTest.java
index 7c3e44275b1..c0805e49492 100644
--- a/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableRuleExecutorTest.java
+++ b/features/sharding/distsql/handler/src/test/java/org/apache/shardingsphere/sharding/distsql/update/DropShardingTableRuleExecutorTest.java
@@ -88,31 +88,36 @@ class DropShardingTableRuleExecutorTest {
@Test
void assertUpdate() {
- ShardingRuleConfiguration currentRuleConfig = createCurrentRuleConfiguration();
- assertFalse(new DropShardingTableRuleExecutor().updateCurrentRuleConfiguration(createSQLStatement("t_order"), currentRuleConfig));
- assertTrue(new DropShardingTableRuleExecutor().updateCurrentRuleConfiguration(createSQLStatement("t_order"), new ShardingRuleConfiguration()));
- assertFalse(getShardingTables(currentRuleConfig).contains("t_order"));
- assertTrue(getBindingTables(currentRuleConfig).contains("t_order_item"));
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+ executor.setRule(rule);
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("t_order"));
+ assertTrue(getShardingTables(actual).contains("t_order"));
+ assertFalse(getBindingTables(actual).contains("t_order_item"));
}
@Test
void assertUpdateWithDifferentCase() {
- ShardingRuleConfiguration currentRuleConfig = createCurrentRuleConfiguration();
- new DropShardingTableRuleExecutor().updateCurrentRuleConfiguration(createSQLStatement("T_ORDER"), currentRuleConfig);
- assertFalse(getShardingTables(currentRuleConfig).contains("t_order"));
- assertTrue(getBindingTables(currentRuleConfig).contains("t_order_item"));
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+ executor.setRule(rule);
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(createSQLStatement("T_ORDER"));
+ assertTrue(getShardingTables(actual).contains("t_order"));
+ assertFalse(getBindingTables(actual).contains("t_order_item"));
}
@Test
void assertDropRuleAndUnusedAlgorithm() {
- ShardingRuleConfiguration currentRuleConfig = createCurrentRuleConfiguration();
+ ShardingRule rule = mock(ShardingRule.class);
+ when(rule.getConfiguration()).thenReturn(createCurrentRuleConfiguration());
+ executor.setRule(rule);
DropShardingTableRuleStatement sqlStatement = createSQLStatement("t_order");
- new DropShardingTableRuleExecutor().updateCurrentRuleConfiguration(sqlStatement, currentRuleConfig);
- assertFalse(getShardingTables(currentRuleConfig).contains("t_order"));
- assertTrue(getBindingTables(currentRuleConfig).contains("t_order_item"));
- assertThat(currentRuleConfig.getShardingAlgorithms().size(), is(2));
- assertThat(currentRuleConfig.getKeyGenerators().size(), is(1));
- assertThat(currentRuleConfig.getAuditors().size(), is(1));
+ ShardingRuleConfiguration actual = executor.buildToBeDroppedRuleConfiguration(sqlStatement);
+ assertTrue(getShardingTables(actual).contains("t_order"));
+ assertFalse(getBindingTables(actual).contains("t_order_item"));
+ assertThat(actual.getShardingAlgorithms().size(), is(2));
+ assertThat(actual.getKeyGenerators().size(), is(1));
+ assertThat(actual.getAuditors().size(), is(1));
}
private DropShardingTableRuleStatement createSQLStatement(final String tableName) {
diff --git a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/DistSQLUpdateExecuteEngine.java b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/DistSQLUpdateExecuteEngine.java
index 496d8ac0737..2040d9d9f92 100644
--- a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/DistSQLUpdateExecuteEngine.java
+++ b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/DistSQLUpdateExecuteEngine.java
@@ -20,8 +20,6 @@ package org.apache.shardingsphere.distsql.handler.engine.update;
import org.apache.shardingsphere.distsql.handler.aware.DistSQLExecutorAwareSetter;
import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.engine.database.DatabaseRuleDefinitionExecuteEngine;
import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.engine.global.GlobalRuleDefinitionExecuteEngine;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.engine.legacy.LegacyDatabaseRuleDefinitionExecuteEngine;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.engine.legacy.LegacyGlobalRuleDefinitionExecuteEngine;
import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleDefinitionExecutor;
import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.global.GlobalRuleDefinitionExecutor;
import org.apache.shardingsphere.distsql.handler.required.DistSQLExecutorRequiredChecker;
@@ -71,38 +69,14 @@ public final class DistSQLUpdateExecuteEngine {
private void executeRuleDefinitionUpdate() {
Optional<DatabaseRuleDefinitionExecutor> databaseExecutor = TypedSPILoader.findService(DatabaseRuleDefinitionExecutor.class, sqlStatement.getClass());
if (databaseExecutor.isPresent()) {
- executeDatabaseRuleDefinitionUpdate(databaseExecutor.get());
+ new DatabaseRuleDefinitionExecuteEngine((DatabaseRuleDefinitionStatement) sqlStatement, contextManager,
+ contextManager.getDatabase(databaseName), databaseExecutor.get()).executeUpdate();
} else {
- executeGlobalRuleDefinitionUpdate(TypedSPILoader.getService(GlobalRuleDefinitionExecutor.class, sqlStatement.getClass()));
+ new GlobalRuleDefinitionExecuteEngine((GlobalRuleDefinitionStatement) sqlStatement,
+ contextManager, TypedSPILoader.getService(GlobalRuleDefinitionExecutor.class, sqlStatement.getClass())).executeUpdate();
}
}
- @SuppressWarnings("rawtypes")
- private void executeDatabaseRuleDefinitionUpdate(final DatabaseRuleDefinitionExecutor executor) {
- if (isNormalRuleUpdater()) {
- new DatabaseRuleDefinitionExecuteEngine((DatabaseRuleDefinitionStatement) sqlStatement, contextManager, contextManager.getDatabase(databaseName), executor).executeUpdate();
- } else {
- // TODO Remove when metadata structure adjustment completed. #25485
- new LegacyDatabaseRuleDefinitionExecuteEngine((DatabaseRuleDefinitionStatement) sqlStatement, contextManager, contextManager.getDatabase(databaseName), executor).executeUpdate();
- }
- }
-
- @SuppressWarnings("rawtypes")
- private void executeGlobalRuleDefinitionUpdate(final GlobalRuleDefinitionExecutor executor) {
- if (isNormalRuleUpdater()) {
- new GlobalRuleDefinitionExecuteEngine((GlobalRuleDefinitionStatement) sqlStatement, contextManager, executor).executeUpdate();
- } else {
- // TODO Remove when metadata structure adjustment completed. #25485
- new LegacyGlobalRuleDefinitionExecuteEngine((GlobalRuleDefinitionStatement) sqlStatement, contextManager, executor).executeUpdate();
- }
- }
-
- // TODO Remove when metadata structure adjustment completed. #25485
- private boolean isNormalRuleUpdater() {
- String modeType = contextManager.getInstanceContext().getModeConfiguration().getType();
- return "Cluster".equals(modeType) || "Standalone".equals(modeType);
- }
-
@SuppressWarnings({"rawtypes", "unchecked"})
private void executeNormalUpdate() throws SQLException {
DistSQLUpdateExecutor executor = TypedSPILoader.getService(DistSQLUpdateExecutor.class, sqlStatement.getClass());
diff --git a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/legacy/LegacyDatabaseRuleDefinitionExecuteEngine.java b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/legacy/LegacyDatabaseRuleDefinitionExecuteEngine.java
deleted file mode 100644
index b1d984d666a..00000000000
--- a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/legacy/LegacyDatabaseRuleDefinitionExecuteEngine.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.engine.legacy;
-
-import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.distsql.handler.required.DistSQLExecutorRequiredChecker;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleAlterExecutor;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleCreateExecutor;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleDefinitionExecutor;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleDropExecutor;
-import org.apache.shardingsphere.distsql.statement.rdl.rule.database.DatabaseRuleDefinitionStatement;
-import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import org.apache.shardingsphere.infra.config.rule.decorator.RuleConfigurationDecorator;
-import org.apache.shardingsphere.infra.exception.core.external.sql.type.generic.UnsupportedSQLOperationException;
-import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
-import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
-import org.apache.shardingsphere.mode.manager.ContextManager;
-import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-// TODO Remove when metadata structure adjustment completed. #25485
-/**
- * Legacy rule definition execute engine.
- */
-@RequiredArgsConstructor
-public final class LegacyDatabaseRuleDefinitionExecuteEngine {
-
- private final DatabaseRuleDefinitionStatement sqlStatement;
-
- private final ContextManager contextManager;
-
- private final ShardingSphereDatabase database;
-
- @SuppressWarnings("rawtypes")
- private final DatabaseRuleDefinitionExecutor executor;
-
- /**
- * Execute update.
- */
- @SuppressWarnings("unchecked")
- public void executeUpdate() {
- executor.setDatabase(database);
- Optional<ShardingSphereRule> rule = database.getRuleMetaData().findSingleRule(executor.getRuleClass());
- executor.setRule(rule.orElse(null));
- checkBeforeUpdate();
- RuleConfiguration currentRuleConfig = rule.map(ShardingSphereRule::getConfiguration).orElse(null);
- if (getRefreshStatus(sqlStatement, executor)) {
- contextManager.getInstanceContext().getModeContextManager().alterRuleConfiguration(database.getName(), processSQLStatement(database, sqlStatement, executor, currentRuleConfig));
- }
- }
-
- @SuppressWarnings("unchecked")
- private void checkBeforeUpdate() {
- new DistSQLExecutorRequiredChecker(executor).check(sqlStatement, contextManager, database);
- executor.checkBeforeUpdate(sqlStatement);
- }
-
- @SuppressWarnings({"unchecked", "rawtypes"})
- private boolean getRefreshStatus(final SQLStatement sqlStatement, final DatabaseRuleDefinitionExecutor<?, ?> executor) {
- return !(executor instanceof DatabaseRuleDropExecutor) || ((DatabaseRuleDropExecutor) executor).hasAnyOneToBeDropped(sqlStatement);
- }
-
- @SuppressWarnings("rawtypes")
- private Collection<RuleConfiguration> processSQLStatement(final ShardingSphereDatabase database, final DatabaseRuleDefinitionStatement sqlStatement,
- final DatabaseRuleDefinitionExecutor executor, final RuleConfiguration currentRuleConfig) {
- Collection<RuleConfiguration> result = new LinkedList<>(database.getRuleMetaData().getConfigurations());
- if (executor instanceof DatabaseRuleCreateExecutor) {
- if (null != currentRuleConfig) {
- result.remove(currentRuleConfig);
- }
- RuleConfiguration createdRuleConfig = processCreate(sqlStatement, (DatabaseRuleCreateExecutor) executor, currentRuleConfig);
- result.add(decorateRuleConfiguration(database, createdRuleConfig));
- } else if (executor instanceof DatabaseRuleAlterExecutor) {
- result.remove(currentRuleConfig);
- RuleConfiguration alteredRuleConfig = processAlter(sqlStatement, (DatabaseRuleAlterExecutor) executor, currentRuleConfig);
- result.add(decorateRuleConfiguration(database, alteredRuleConfig));
- } else if (executor instanceof DatabaseRuleDropExecutor) {
- processDrop(database, result, sqlStatement, (DatabaseRuleDropExecutor) executor, currentRuleConfig);
- } else {
- throw new UnsupportedSQLOperationException(String.format("Cannot support RDL executor type `%s`", executor.getClass().getName()));
- }
- return result;
- }
-
- @SuppressWarnings({"rawtypes", "unchecked"})
- private RuleConfiguration processCreate(final DatabaseRuleDefinitionStatement sqlStatement, final DatabaseRuleCreateExecutor executor, final RuleConfiguration currentRuleConfig) {
- RuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- if (null == currentRuleConfig) {
- return toBeCreatedRuleConfig;
- }
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeCreatedRuleConfig);
- return currentRuleConfig;
- }
-
- @SuppressWarnings({"rawtypes", "unchecked"})
- private RuleConfiguration processAlter(final DatabaseRuleDefinitionStatement sqlStatement, final DatabaseRuleAlterExecutor executor, final RuleConfiguration currentRuleConfig) {
- RuleConfiguration toBeAlteredRuleConfig = executor.buildToBeAlteredRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentRuleConfig, toBeAlteredRuleConfig);
- return currentRuleConfig;
- }
-
- @SuppressWarnings({"rawtypes", "unchecked"})
- private void processDrop(final ShardingSphereDatabase database, final Collection<RuleConfiguration> configs, final DatabaseRuleDefinitionStatement sqlStatement,
- final DatabaseRuleDropExecutor executor, final RuleConfiguration currentRuleConfig) {
- if (!executor.hasAnyOneToBeDropped(sqlStatement)) {
- return;
- }
- if (executor.updateCurrentRuleConfiguration(sqlStatement, currentRuleConfig)) {
- configs.remove(currentRuleConfig);
- }
- executor.operate(sqlStatement, database);
- }
-
- @SuppressWarnings("unchecked")
- private RuleConfiguration decorateRuleConfiguration(final ShardingSphereDatabase database, final RuleConfiguration ruleConfig) {
- return TypedSPILoader.findService(RuleConfigurationDecorator.class, ruleConfig.getClass()).map(optional -> optional.decorate(database.getName(),
- database.getResourceMetaData().getStorageUnits().entrySet().stream()
- .collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new)),
- database.getRuleMetaData().getRules(), ruleConfig)).orElse(ruleConfig);
- }
-}
diff --git a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/legacy/LegacyGlobalRuleDefinitionExecuteEngine.java b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/legacy/LegacyGlobalRuleDefinitionExecuteEngine.java
deleted file mode 100644
index 4a885325f5b..00000000000
--- a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/engine/legacy/LegacyGlobalRuleDefinitionExecuteEngine.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.engine.legacy;
-
-import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.global.GlobalRuleDefinitionExecutor;
-import org.apache.shardingsphere.distsql.statement.rdl.rule.global.GlobalRuleDefinitionStatement;
-import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
-import org.apache.shardingsphere.mode.manager.ContextManager;
-
-import java.util.Collection;
-import java.util.LinkedList;
-
-// TODO Remove when metadata structure adjustment completed. #25485
-/**
- * Legacy global rule definition execute engine.
- */
-@RequiredArgsConstructor
-public final class LegacyGlobalRuleDefinitionExecuteEngine {
-
- private final GlobalRuleDefinitionStatement sqlStatement;
-
- private final ContextManager contextManager;
-
- @SuppressWarnings("rawtypes")
- private final GlobalRuleDefinitionExecutor executor;
-
- /**
- * Execute update.
- */
- @SuppressWarnings("unchecked")
- public void executeUpdate() {
- ShardingSphereRule rule = contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getSingleRule(executor.getRuleClass());
- executor.setRule(rule);
- executor.checkBeforeUpdate(sqlStatement);
- contextManager.getInstanceContext().getModeContextManager().alterGlobalRuleConfiguration(processUpdate(sqlStatement, executor, rule.getConfiguration()));
- }
-
- @SuppressWarnings({"rawtypes", "unchecked"})
- private Collection<RuleConfiguration> processUpdate(final GlobalRuleDefinitionStatement sqlStatement, final GlobalRuleDefinitionExecutor executor, final RuleConfiguration currentRuleConfig) {
- Collection<RuleConfiguration> ruleConfigs = contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getConfigurations();
- Collection<RuleConfiguration> result = new LinkedList<>(ruleConfigs);
- result.remove(currentRuleConfig);
- result.add(executor.buildToBeAlteredRuleConfiguration(sqlStatement));
- return result;
- }
-}
diff --git a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleAlterExecutor.java b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleAlterExecutor.java
index 4e013546a0e..277ae74cb74 100644
--- a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleAlterExecutor.java
+++ b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleAlterExecutor.java
@@ -46,13 +46,4 @@ public interface DatabaseRuleAlterExecutor<T extends SQLStatement, R extends Sha
* @return to be dropped rule configuration
*/
C buildToBeDroppedRuleConfiguration(C toBeAlteredRuleConfig);
-
- /**
- * Update current rule configuration.
- *
- * @param currentRuleConfig current rule configuration to be updated
- * @param toBeAlteredRuleConfig to be altered rule configuration
- */
- // TODO should remove after legacy metadata removed
- void updateCurrentRuleConfiguration(C currentRuleConfig, C toBeAlteredRuleConfig);
}
diff --git a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleCreateExecutor.java b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleCreateExecutor.java
index 2714e3534a4..719ef762b93 100644
--- a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleCreateExecutor.java
+++ b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleCreateExecutor.java
@@ -37,13 +37,4 @@ public interface DatabaseRuleCreateExecutor<T extends SQLStatement, R extends Sh
* @return to be created rule configuration
*/
C buildToBeCreatedRuleConfiguration(T sqlStatement);
-
- /**
- * Update current rule configuration.
- *
- * @param currentRuleConfig current rule configuration to be updated
- * @param toBeCreatedRuleConfig to be created rule configuration
- */
- // TODO should remove after legacy metadata removed
- void updateCurrentRuleConfiguration(C currentRuleConfig, C toBeCreatedRuleConfig);
}
diff --git a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleDropExecutor.java b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleDropExecutor.java
index 17b02dcaf38..87a1112c6a9 100644
--- a/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleDropExecutor.java
+++ b/infra/distsql-handler/src/main/java/org/apache/shardingsphere/distsql/handler/engine/update/rdl/rule/spi/database/DatabaseRuleDropExecutor.java
@@ -18,7 +18,6 @@
package org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
@@ -52,16 +51,6 @@ public interface DatabaseRuleDropExecutor<T extends SQLStatement, R extends Shar
return null;
}
- /**
- * Update current rule configuration.
- *
- * @param sqlStatement SQL statement
- * @param currentRuleConfig current rule configuration to be updated
- * @return current rule configuration is empty or not
- */
- // TODO remove this method after remove Compatible_Cluster mode
- boolean updateCurrentRuleConfiguration(T sqlStatement, C currentRuleConfig);
-
/**
* Whether there is dropped data.
*
@@ -71,14 +60,4 @@ public interface DatabaseRuleDropExecutor<T extends SQLStatement, R extends Shar
default boolean hasAnyOneToBeDropped(final T sqlStatement) {
return true;
}
-
- // TODO Remove when metadata structure adjustment completed. #25485
- /**
- * Drop rule configuration operate.
- *
- * @param sqlStatement SQL statement
- * @param database database
- */
- default void operate(final T sqlStatement, final ShardingSphereDatabase database) {
- }
}
diff --git a/jdbc/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java b/jdbc/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java
index ebc17b7ef57..815180645d5 100644
--- a/jdbc/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java
+++ b/jdbc/src/main/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManager.java
@@ -22,6 +22,7 @@ import com.google.common.collect.LinkedHashMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import lombok.Getter;
+import org.apache.shardingsphere.authority.rule.AuthorityRule;
import org.apache.shardingsphere.driver.jdbc.adapter.executor.ForceExecuteTemplate;
import org.apache.shardingsphere.driver.jdbc.adapter.invocation.MethodInvocationRecorder;
import org.apache.shardingsphere.driver.jdbc.core.ShardingSphereSavepoint;
@@ -117,7 +118,8 @@ public final class DriverDatabaseConnectionManager implements DatabaseConnection
Map<String, DataSourcePoolProperties> propsMap = persistService.getDataSourceUnitService().load(actualDatabaseName);
Preconditions.checkState(!propsMap.isEmpty(), "Can not get data source properties from meta data.");
DataSourcePoolProperties propsSample = propsMap.values().iterator().next();
- Collection<ShardingSphereUser> users = persistService.getGlobalRuleService().loadUsers();
+ Collection<ShardingSphereUser> users = contextManager.getMetaDataContexts().getMetaData()
+ .getGlobalRuleMetaData().getSingleRule(AuthorityRule.class).getConfiguration().getUsers();
Collection<InstanceMetaData> instances = contextManager.getInstanceContext().getAllClusterInstances(InstanceType.PROXY, rule.getLabels()).values();
return DataSourcePoolCreator.create(createDataSourcePoolPropertiesMap(instances, users, propsSample, actualDatabaseName), true);
}
diff --git a/jdbc/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java b/jdbc/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java
index 51a97656508..314c485d143 100644
--- a/jdbc/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java
+++ b/jdbc/src/test/java/org/apache/shardingsphere/driver/jdbc/core/connection/DriverDatabaseConnectionManagerTest.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.driver.jdbc.core.connection;
import com.zaxxer.hikari.HikariDataSource;
+import org.apache.shardingsphere.authority.rule.AuthorityRule;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
import org.apache.shardingsphere.infra.datasource.pool.creator.DataSourcePoolCreator;
import org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
@@ -26,7 +27,6 @@ import org.apache.shardingsphere.infra.instance.metadata.InstanceType;
import org.apache.shardingsphere.infra.instance.metadata.proxy.ProxyInstanceMetaData;
import org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
-import org.apache.shardingsphere.infra.metadata.user.ShardingSphereUser;
import org.apache.shardingsphere.metadata.persist.MetaDataPersistService;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
@@ -80,7 +80,8 @@ class DriverDatabaseConnectionManagerTest {
MetaDataPersistService persistService = mockMetaDataPersistService();
when(result.getMetaDataContexts().getPersistService()).thenReturn(persistService);
when(result.getMetaDataContexts().getMetaData().getGlobalRuleMetaData()).thenReturn(
- new RuleMetaData(Arrays.asList(mock(TransactionRule.class, RETURNS_DEEP_STUBS), mock(TrafficRule.class, RETURNS_DEEP_STUBS))));
+ new RuleMetaData(Arrays.asList(mock(AuthorityRule.class, RETURNS_DEEP_STUBS), mock(TransactionRule.class, RETURNS_DEEP_STUBS),
+ mock(TrafficRule.class, RETURNS_DEEP_STUBS))));
when(result.getInstanceContext().getAllClusterInstances(InstanceType.PROXY, Arrays.asList("OLTP", "OLAP"))).thenReturn(
Collections.singletonMap("foo_id", new ProxyInstanceMetaData("foo_id", "127.0.0.1@3307", "foo_version")));
Map<String, DataSource> trafficDataSourceMap = mockTrafficDataSourceMap();
@@ -107,7 +108,6 @@ class DriverDatabaseConnectionManagerTest {
MetaDataPersistService result = mock(MetaDataPersistService.class, RETURNS_DEEP_STUBS);
when(result.getDataSourceUnitService().load(DefaultDatabase.LOGIC_NAME))
.thenReturn(Collections.singletonMap(DefaultDatabase.LOGIC_NAME, new DataSourcePoolProperties(HikariDataSource.class.getName(), createProperties())));
- when(result.getGlobalRuleService().loadUsers()).thenReturn(Collections.singletonList(new ShardingSphereUser("root", "root", "localhost")));
return result;
}
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DatabaseBasedPersistService.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DatabaseBasedPersistService.java
index a7aa980cf96..0232d5a79fa 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DatabaseBasedPersistService.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DatabaseBasedPersistService.java
@@ -17,12 +17,9 @@
package org.apache.shardingsphere.metadata.persist.service.config.database;
-import org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
/**
* Database based persist service.
@@ -48,24 +45,23 @@ public interface DatabaseBasedPersistService<T> {
T load(String databaseName);
/**
- * Load configuration.
+ * Load configurations.
*
* @param databaseName database name
* @param name name
* @return configurations
*/
- default T load(final String databaseName, final String name) {
+ default T load(String databaseName, String name) {
return null;
}
/**
- * Delete rule.
+ * Delete configurations.
*
* @param databaseName database name
- * @param ruleName rule name
+ * @param name name
*/
- default void delete(final String databaseName, final String ruleName) {
- }
+ void delete(String databaseName, String name);
/**
* Delete configurations.
@@ -74,9 +70,7 @@ public interface DatabaseBasedPersistService<T> {
* @param configs configurations
* @return meta data versions
*/
- default Collection<MetaDataVersion> deleteConfig(final String databaseName, final T configs) {
- return Collections.emptyList();
- }
+ Collection<MetaDataVersion> deleteConfig(String databaseName, T configs);
/**
* Persist configurations.
@@ -85,17 +79,5 @@ public interface DatabaseBasedPersistService<T> {
* @param configs configurations
* @return meta data versions
*/
- default Collection<MetaDataVersion> persistConfig(final String databaseName, final T configs) {
- return Collections.emptyList();
- }
-
- /**
- * TODO remove this after meta data refactor completed
- * Append data source properties map.
- *
- * @param databaseName database name
- * @param toBeAppendedPropsMap data source pool properties map to be appended
- */
- default void append(final String databaseName, final Map<String, DataSourcePoolProperties> toBeAppendedPropsMap) {
- }
+ Collection<MetaDataVersion> persistConfig(String databaseName, T configs);
}
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java
index 37b612b394b..335fc04f1ac 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceNodePersistService.java
@@ -58,33 +58,6 @@ public final class DataSourceNodePersistService implements DatabaseBasedPersistS
}
}
- @Override
- public Collection<MetaDataVersion> deleteConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
- Collection<MetaDataVersion> result = new LinkedList<>();
- for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
- String delKey = DatabaseMetaDataNode.getDataSourceNode(databaseName, entry.getKey());
- repository.delete(delKey);
- result.add(new MetaDataVersion(delKey));
- }
- return result;
- }
-
- @Override
- public Collection<MetaDataVersion> persistConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
- Collection<MetaDataVersion> result = new LinkedList<>();
- for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
- List<String> versions = repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceNodeVersionsNode(databaseName, entry.getKey()));
- String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION : String.valueOf(Integer.parseInt(versions.get(0)) + 1);
- repository.persist(DatabaseMetaDataNode.getDataSourceNodeWithVersion(databaseName, entry.getKey(), nextActiveVersion),
- YamlEngine.marshal(new YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
- if (Strings.isNullOrEmpty(getDataSourceActiveVersion(databaseName, entry.getKey()))) {
- repository.persist(DatabaseMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName, entry.getKey()), DEFAULT_VERSION);
- }
- result.add(new MetaDataVersion(DatabaseMetaDataNode.getDataSourceNode(databaseName, entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()), nextActiveVersion));
- }
- return result;
- }
-
@SuppressWarnings("unchecked")
@Override
public Map<String, DataSourcePoolProperties> load(final String databaseName) {
@@ -110,8 +83,35 @@ public final class DataSourceNodePersistService implements DatabaseBasedPersistS
}
@Override
- public void append(final String databaseName, final Map<String, DataSourcePoolProperties> toBeAppendedPropsMap) {
- persist(databaseName, toBeAppendedPropsMap);
+ public void delete(final String databaseName, final String name) {
+ repository.delete(DatabaseMetaDataNode.getDataSourceNode(databaseName, name));
+ }
+
+ @Override
+ public Collection<MetaDataVersion> deleteConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
+ Collection<MetaDataVersion> result = new LinkedList<>();
+ for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
+ String delKey = DatabaseMetaDataNode.getDataSourceNode(databaseName, entry.getKey());
+ repository.delete(delKey);
+ result.add(new MetaDataVersion(delKey));
+ }
+ return result;
+ }
+
+ @Override
+ public Collection<MetaDataVersion> persistConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
+ Collection<MetaDataVersion> result = new LinkedList<>();
+ for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
+ List<String> versions = repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceNodeVersionsNode(databaseName, entry.getKey()));
+ String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION : String.valueOf(Integer.parseInt(versions.get(0)) + 1);
+ repository.persist(DatabaseMetaDataNode.getDataSourceNodeWithVersion(databaseName, entry.getKey(), nextActiveVersion),
+ YamlEngine.marshal(new YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
+ if (Strings.isNullOrEmpty(getDataSourceActiveVersion(databaseName, entry.getKey()))) {
+ repository.persist(DatabaseMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName, entry.getKey()), DEFAULT_VERSION);
+ }
+ result.add(new MetaDataVersion(DatabaseMetaDataNode.getDataSourceNode(databaseName, entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()), nextActiveVersion));
+ }
+ return result;
}
private String getDataSourceActiveVersion(final String databaseName, final String dataSourceName) {
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java
index bf7f285e23e..d3729c2c5d8 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/datasource/DataSourceUnitPersistService.java
@@ -58,33 +58,6 @@ public final class DataSourceUnitPersistService implements DatabaseBasedPersistS
}
}
- @Override
- public Collection<MetaDataVersion> deleteConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
- Collection<MetaDataVersion> result = new LinkedList<>();
- for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
- String delKey = DatabaseMetaDataNode.getDataSourceUnitNode(databaseName, entry.getKey());
- repository.delete(delKey);
- result.add(new MetaDataVersion(delKey));
- }
- return result;
- }
-
- @Override
- public Collection<MetaDataVersion> persistConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
- Collection<MetaDataVersion> result = new LinkedList<>();
- for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
- List<String> versions = repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceUnitVersionsNode(databaseName, entry.getKey()));
- String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION : String.valueOf(Integer.parseInt(versions.get(0)) + 1);
- repository.persist(DatabaseMetaDataNode.getDataSourceUnitNodeWithVersion(databaseName, entry.getKey(), nextActiveVersion),
- YamlEngine.marshal(new YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
- if (Strings.isNullOrEmpty(getDataSourceActiveVersion(databaseName, entry.getKey()))) {
- repository.persist(DatabaseMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName, entry.getKey()), DEFAULT_VERSION);
- }
- result.add(new MetaDataVersion(DatabaseMetaDataNode.getDataSourceUnitNode(databaseName, entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()), nextActiveVersion));
- }
- return result;
- }
-
@SuppressWarnings("unchecked")
@Override
public Map<String, DataSourcePoolProperties> load(final String databaseName) {
@@ -110,8 +83,35 @@ public final class DataSourceUnitPersistService implements DatabaseBasedPersistS
}
@Override
- public void append(final String databaseName, final Map<String, DataSourcePoolProperties> toBeAppendedPropsMap) {
- persist(databaseName, toBeAppendedPropsMap);
+ public void delete(final String databaseName, final String name) {
+ repository.delete(DatabaseMetaDataNode.getDataSourceUnitNode(databaseName, name));
+ }
+
+ @Override
+ public Collection<MetaDataVersion> deleteConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
+ Collection<MetaDataVersion> result = new LinkedList<>();
+ for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
+ String delKey = DatabaseMetaDataNode.getDataSourceUnitNode(databaseName, entry.getKey());
+ repository.delete(delKey);
+ result.add(new MetaDataVersion(delKey));
+ }
+ return result;
+ }
+
+ @Override
+ public Collection<MetaDataVersion> persistConfig(final String databaseName, final Map<String, DataSourcePoolProperties> dataSourceConfigs) {
+ Collection<MetaDataVersion> result = new LinkedList<>();
+ for (Entry<String, DataSourcePoolProperties> entry : dataSourceConfigs.entrySet()) {
+ List<String> versions = repository.getChildrenKeys(DatabaseMetaDataNode.getDataSourceUnitVersionsNode(databaseName, entry.getKey()));
+ String nextActiveVersion = versions.isEmpty() ? DEFAULT_VERSION : String.valueOf(Integer.parseInt(versions.get(0)) + 1);
+ repository.persist(DatabaseMetaDataNode.getDataSourceUnitNodeWithVersion(databaseName, entry.getKey(), nextActiveVersion),
+ YamlEngine.marshal(new YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
+ if (Strings.isNullOrEmpty(getDataSourceActiveVersion(databaseName, entry.getKey()))) {
+ repository.persist(DatabaseMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName, entry.getKey()), DEFAULT_VERSION);
+ }
+ result.add(new MetaDataVersion(DatabaseMetaDataNode.getDataSourceUnitNode(databaseName, entry.getKey()), getDataSourceActiveVersion(databaseName, entry.getKey()), nextActiveVersion));
+ }
+ return result;
}
private String getDataSourceActiveVersion(final String databaseName, final String dataSourceName) {
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java
index 1fd019483db..66ce8e195e4 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/rule/DatabaseRulePersistService.java
@@ -62,6 +62,17 @@ public final class DatabaseRulePersistService extends AbstractPersistService imp
}
}
+ @Override
+ public Collection<RuleConfiguration> load(final String databaseName) {
+ Collection<YamlDataNode> dataNodes = getDataNodes(DatabaseMetaDataNode.getRulesNode(databaseName));
+ return dataNodes.isEmpty() ? Collections.emptyList() : new YamlDataNodeRuleConfigurationSwapperEngine().swapToRuleConfigurations(dataNodes);
+ }
+
+ @Override
+ public void delete(final String databaseName, final String name) {
+ repository.delete(DatabaseMetaDataNode.getDatabaseRuleNode(databaseName, name));
+ }
+
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public Collection<MetaDataVersion> persistConfig(final String databaseName, final Collection<RuleConfiguration> configs) {
@@ -91,10 +102,6 @@ public final class DatabaseRulePersistService extends AbstractPersistService imp
return result;
}
- private String getActiveVersion(final String databaseName, final String ruleName, final String key) {
- return repository.getDirectly(DatabaseMetaDataNode.getDatabaseRuleActiveVersionNode(databaseName, ruleName, key));
- }
-
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public Collection<MetaDataVersion> deleteConfig(final String databaseName, final Collection<RuleConfiguration> configs) {
@@ -112,11 +119,6 @@ public final class DatabaseRulePersistService extends AbstractPersistService imp
return result;
}
- @Override
- public void delete(final String databaseName, final String ruleName) {
- repository.delete(DatabaseMetaDataNode.getDatabaseRuleNode(databaseName, ruleName));
- }
-
private Collection<MetaDataVersion> deleteDataNodes(final String databaseName, final String ruleName, final Collection<YamlDataNode> dataNodes) {
Collection<MetaDataVersion> result = new LinkedList<>();
for (YamlDataNode each : dataNodes) {
@@ -127,9 +129,7 @@ public final class DatabaseRulePersistService extends AbstractPersistService imp
return result;
}
- @Override
- public Collection<RuleConfiguration> load(final String databaseName) {
- Collection<YamlDataNode> dataNodes = getDataNodes(DatabaseMetaDataNode.getRulesNode(databaseName));
- return dataNodes.isEmpty() ? Collections.emptyList() : new YamlDataNodeRuleConfigurationSwapperEngine().swapToRuleConfigurations(dataNodes);
+ private String getActiveVersion(final String databaseName, final String ruleName, final String key) {
+ return repository.getDirectly(DatabaseMetaDataNode.getDatabaseRuleActiveVersionNode(databaseName, ruleName, key));
}
}
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalPersistService.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalPersistService.java
index 858bf14445c..4b2bf0a3200 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalPersistService.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalPersistService.java
@@ -18,11 +18,9 @@
package org.apache.shardingsphere.metadata.persist.service.config.global;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import org.apache.shardingsphere.infra.metadata.user.ShardingSphereUser;
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import java.util.Collection;
-import java.util.Collections;
/**
* Global persist service.
@@ -62,14 +60,4 @@ public interface GlobalPersistService<T> {
default RuleConfiguration load(final String ruleName) {
return null;
}
-
- /**
- * TODO remove this after meta data refactor completed
- * Load all users.
- *
- * @return collection of user
- */
- default Collection<ShardingSphereUser> loadUsers() {
- return Collections.emptyList();
- }
}
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalRulePersistService.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalRulePersistService.java
index f30dd33d8e4..cd69b80dc71 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalRulePersistService.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/global/GlobalRulePersistService.java
@@ -18,9 +18,7 @@
package org.apache.shardingsphere.metadata.persist.service.config.global;
import com.google.common.base.Strings;
-import org.apache.shardingsphere.authority.config.AuthorityRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import org.apache.shardingsphere.infra.metadata.user.ShardingSphereUser;
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.datanode.YamlDataNode;
import org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlDataNodeGlobalRuleConfigurationSwapper;
@@ -35,7 +33,6 @@ import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.Optional;
/**
* Global rule persist service.
@@ -105,17 +102,4 @@ public final class GlobalRulePersistService extends AbstractPersistService imple
Collection<YamlDataNode> dataNodes = getDataNodes(GlobalNode.getGlobalRuleNode(ruleName));
return new YamlDataNodeGlobalRuleConfigurationSwapperEngine().swapSingleRuleToRuleConfiguration(ruleName, dataNodes).orElse(null);
}
-
- /**
- * TODO Avoid load all keys.
- * Load all users.
- *
- * @return collection of user
- */
- @Override
- public Collection<ShardingSphereUser> loadUsers() {
- Optional<AuthorityRuleConfiguration> authorityRuleConfig = load().stream()
- .filter(AuthorityRuleConfiguration.class::isInstance).map(AuthorityRuleConfiguration.class::cast).findFirst();
- return authorityRuleConfig.isPresent() ? authorityRuleConfig.get().getUsers() : Collections.emptyList();
- }
}
diff --git a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java
index c08e3651dbc..b2d0d62dd9b 100644
--- a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java
+++ b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutor.java
@@ -164,12 +164,6 @@ public final class LoadSingleTableExecutor implements DatabaseRuleCreateExecutor
return result;
}
- @Override
- public void updateCurrentRuleConfiguration(final SingleRuleConfiguration currentRuleConfig, final SingleRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.getTables().clear();
- currentRuleConfig.getTables().addAll(toBeCreatedRuleConfig.getTables());
- }
-
@Override
public Class<SingleRule> getRuleClass() {
return SingleRule.class;
diff --git a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java
index 9f47d3731f8..c4be736b3b8 100644
--- a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java
+++ b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutor.java
@@ -61,11 +61,6 @@ public final class SetDefaultSingleTableStorageUnitExecutor implements DatabaseR
return result;
}
- @Override
- public void updateCurrentRuleConfiguration(final SingleRuleConfiguration currentRuleConfig, final SingleRuleConfiguration toBeCreatedRuleConfig) {
- currentRuleConfig.setDefaultDataSource(toBeCreatedRuleConfig.getDefaultDataSource().orElse(null));
- }
-
@Override
public Class<SingleRule> getRuleClass() {
return SingleRule.class;
diff --git a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/UnloadSingleTableExecutor.java b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/UnloadSingleTableExecutor.java
index 8ff44831a2b..221249978a5 100644
--- a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/UnloadSingleTableExecutor.java
+++ b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/UnloadSingleTableExecutor.java
@@ -106,12 +106,6 @@ public final class UnloadSingleTableExecutor implements DatabaseRuleAlterExecuto
return null;
}
- @Override
- public void updateCurrentRuleConfiguration(final SingleRuleConfiguration currentRuleConfig, final SingleRuleConfiguration toBeAlteredRuleConfig) {
- currentRuleConfig.getTables().clear();
- currentRuleConfig.getTables().addAll(toBeAlteredRuleConfig.getTables());
- }
-
private String extractTableName(final String tableNode) {
List<String> segments = Splitter.on(".").trimResults().splitToList(tableNode);
return segments.get(segments.size() - 1);
diff --git a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java
index 37703990a8f..b952bf2a689 100644
--- a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java
+++ b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableExecutorTest.java
@@ -97,9 +97,8 @@ class LoadSingleTableExecutorTest {
SingleRule rule = mock(SingleRule.class);
when(rule.getConfiguration()).thenReturn(currentConfig);
executor.setRule(rule);
- SingleRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- executor.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
- Iterator<String> iterator = currentConfig.getTables().iterator();
+ SingleRuleConfiguration toBeCreatedConfig = executor.buildToBeCreatedRuleConfiguration(sqlStatement);
+ Iterator<String> iterator = toBeCreatedConfig.getTables().iterator();
assertThat(iterator.next(), is("ds_0.foo"));
assertThat(iterator.next(), is("ds_0.bar"));
}
diff --git a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
index 25f28aec0c5..3a23239f4dd 100644
--- a/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
+++ b/kernel/single/distsql/handler/src/test/java/org/apache/shardingsphere/single/distsql/handler/update/SetDefaultSingleTableStorageUnitExecutorTest.java
@@ -56,26 +56,13 @@ class SetDefaultSingleTableStorageUnitExecutorTest {
assertThat(toBeCreatedRuleConfig.getDefaultDataSource().get(), is("foo_ds"));
}
- @Test
- void assertUpdate() {
- SingleRuleConfiguration currentConfig = new SingleRuleConfiguration();
- SingleRule rule = mock(SingleRule.class);
- when(rule.getConfiguration()).thenReturn(currentConfig);
- executor.setRule(rule);
- SingleRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement("foo_ds"));
- executor.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
- assertTrue(currentConfig.getDefaultDataSource().isPresent());
- assertThat(currentConfig.getDefaultDataSource().get(), is("foo_ds"));
- }
-
@Test
void assertRandom() {
SingleRuleConfiguration currentConfig = new SingleRuleConfiguration();
SingleRule rule = mock(SingleRule.class);
when(rule.getConfiguration()).thenReturn(currentConfig);
executor.setRule(rule);
- SingleRuleConfiguration toBeCreatedRuleConfig = executor.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement(null));
- executor.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
+ executor.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement(null));
assertFalse(currentConfig.getDefaultDataSource().isPresent());
}
}
diff --git a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneModeContextManager.java b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneModeContextManager.java
index 0ea6ebda8f6..e44a9b80da4 100644
--- a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneModeContextManager.java
+++ b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneModeContextManager.java
@@ -34,6 +34,7 @@ import org.apache.shardingsphere.infra.rule.attribute.datanode.MutableDataNodeRu
import org.apache.shardingsphere.infra.rule.scope.GlobalRule;
import org.apache.shardingsphere.infra.rule.scope.GlobalRule.GlobalRuleChangedType;
import org.apache.shardingsphere.infra.spi.type.ordered.cache.OrderedServicesCache;
+import org.apache.shardingsphere.metadata.persist.service.config.database.DatabaseBasedPersistService;
import org.apache.shardingsphere.metadata.persist.service.config.global.GlobalPersistService;
import org.apache.shardingsphere.metadata.persist.service.database.DatabaseMetaDataBasedPersistService;
import org.apache.shardingsphere.mode.event.DataChangedEvent;
@@ -217,8 +218,8 @@ public final class StandaloneModeContextManager implements ModeContextManager, C
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getSchemas()
.forEach((schemaName, schema) -> contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService()
.persist(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(), schemaName, schema));
- contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().append(
- contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(), toBeRegisteredProps);
+ DatabaseBasedPersistService<Map<String, DataSourcePoolProperties>> dataSourceService = contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService();
+ contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(dataSourceService.persistConfig(databaseName, toBeRegisteredProps));
clearServiceCache();
}
@@ -229,8 +230,8 @@ public final class StandaloneModeContextManager implements ModeContextManager, C
contextManager.getMetaDataContexts().getMetaData().getDatabases().putAll(contextManager.getConfigurationContextManager().createChangedDatabases(databaseName, true, switchingResource, null));
contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule) each).refresh(contextManager.getMetaDataContexts().getMetaData().getDatabases(), GlobalRuleChangedType.DATABASE_CHANGED));
- contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().append(
- contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(), toBeUpdatedProps);
+ DatabaseBasedPersistService<Map<String, DataSourcePoolProperties>> dataSourceService = contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService();
+ contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(dataSourceService.persistConfig(databaseName, toBeUpdatedProps));
switchingResource.closeStaleDataSources();
clearServiceCache();
}
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/fixture/FixtureDatabaseRuleCreateExecutor.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/fixture/FixtureDatabaseRuleCreateExecutor.java
index 008b617ea86..c10efe9a0c4 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/fixture/FixtureDatabaseRuleCreateExecutor.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/fixture/FixtureDatabaseRuleCreateExecutor.java
@@ -33,10 +33,6 @@ public final class FixtureDatabaseRuleCreateExecutor implements DatabaseRuleCrea
return new MockedRuleConfiguration("");
}
- @Override
- public void updateCurrentRuleConfiguration(final MockedRuleConfiguration currentRuleConfig, final MockedRuleConfiguration toBeCreatedRuleConfig) {
- }
-
@Override
public void setRule(final MockedRule rule) {
}