This is an automated email from the ASF dual-hosted git repository.
jianglongtao 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 672b8a8f241 Remove useless config item after drop rule item (#26811)
672b8a8f241 is described below
commit 672b8a8f241b799d34a8d892b1913411ce90cfe0
Author: ChenJiaHao <[email protected]>
AuthorDate: Fri Jul 7 18:23:02 2023 +0800
Remove useless config item after drop rule item (#26811)
* Remove useless config item after drop rule item
* Fix code style
* Fix UT
---
.../DropCompatibleEncryptRuleStatementUpdater.java | 23 ++++++++-
.../update/DropEncryptRuleStatementUpdater.java | 10 ++--
.../update/DropMaskRuleStatementUpdater.java | 21 ++++----
...DropReadwriteSplittingRuleStatementUpdater.java | 42 ++++++----------
...ReadwriteSplittingRuleStatementUpdaterTest.java | 22 +++++----
.../shadow/api/config/ShadowRuleConfiguration.java | 2 +-
.../update/DropShadowRuleStatementUpdater.java | 57 +++++++++-------------
7 files changed, 92 insertions(+), 85 deletions(-)
diff --git
a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropCompatibleEncryptRuleStatementUpdater.java
b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropCompatibleEncryptRuleStatementUpdater.java
index 4cbfe621518..c679f31fc19 100644
---
a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropCompatibleEncryptRuleStatementUpdater.java
+++
b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropCompatibleEncryptRuleStatementUpdater.java
@@ -19,6 +19,7 @@ package
org.apache.shardingsphere.encrypt.distsql.handler.update;
import
org.apache.shardingsphere.distsql.handler.update.RuleDefinitionDropUpdater;
import
org.apache.shardingsphere.encrypt.api.config.CompatibleEncryptRuleConfiguration;
+import
org.apache.shardingsphere.encrypt.api.config.rule.EncryptColumnItemRuleConfiguration;
import
org.apache.shardingsphere.encrypt.api.config.rule.EncryptTableRuleConfiguration;
import
org.apache.shardingsphere.encrypt.distsql.parser.statement.DropEncryptRuleStatement;
import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
@@ -29,6 +30,8 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
/**
* Drop encrypt rule statement updater.
@@ -56,11 +59,29 @@ public final class
DropCompatibleEncryptRuleStatementUpdater implements RuleDefi
Map<String, AlgorithmConfiguration> toBeDroppedEncryptors = new
HashMap<>();
for (String each : sqlStatement.getTables()) {
toBeDroppedTables.add(new EncryptTableRuleConfiguration(each,
Collections.emptyList()));
+ dropRule(currentRuleConfig, each);
}
- // TODO find unused encryptor
+ findUnusedEncryptors(currentRuleConfig).forEach(each ->
toBeDroppedEncryptors.put(each, currentRuleConfig.getEncryptors().get(each)));
return new CompatibleEncryptRuleConfiguration(toBeDroppedTables,
toBeDroppedEncryptors);
}
+ private void dropRule(final CompatibleEncryptRuleConfiguration
currentRuleConfig, final String ruleName) {
+ Optional<EncryptTableRuleConfiguration> encryptTableRuleConfig =
currentRuleConfig.getTables().stream().filter(each ->
each.getName().equals(ruleName)).findAny();
+ encryptTableRuleConfig.ifPresent(optional ->
currentRuleConfig.getTables().remove(encryptTableRuleConfig.get()));
+ }
+
+ private static Collection<String> findUnusedEncryptors(final
CompatibleEncryptRuleConfiguration currentRuleConfig) {
+ Collection<String> inUsedEncryptors =
currentRuleConfig.getTables().stream().flatMap(each ->
each.getColumns().stream()).map(optional ->
optional.getCipher().getEncryptorName())
+ .collect(Collectors.toSet());
+
inUsedEncryptors.addAll(currentRuleConfig.getTables().stream().flatMap(each ->
each.getColumns().stream())
+ .map(optional ->
optional.getAssistedQuery().map(EncryptColumnItemRuleConfiguration::getEncryptorName).orElse(""))
+ .collect(Collectors.toSet()));
+
inUsedEncryptors.addAll(currentRuleConfig.getTables().stream().flatMap(each ->
each.getColumns().stream())
+ .map(optional ->
optional.getLikeQuery().map(EncryptColumnItemRuleConfiguration::getEncryptorName).orElse(""))
+ .collect(Collectors.toSet()));
+ return currentRuleConfig.getEncryptors().keySet().stream().filter(each
-> !inUsedEncryptors.contains(each)).collect(Collectors.toSet());
+ }
+
@Override
public boolean updateCurrentRuleConfiguration(final
DropEncryptRuleStatement sqlStatement, final CompatibleEncryptRuleConfiguration
currentRuleConfig) {
return delegate.updateCurrentRuleConfiguration(sqlStatement,
currentRuleConfig.convertToEncryptRuleConfiguration());
diff --git
a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleStatementUpdater.java
b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleStatementUpdater.java
index 22243af992c..2fb0ac68148 100644
---
a/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleStatementUpdater.java
+++
b/features/encrypt/distsql/handler/src/main/java/org/apache/shardingsphere/encrypt/distsql/handler/update/DropEncryptRuleStatementUpdater.java
@@ -67,8 +67,9 @@ public final class DropEncryptRuleStatementUpdater implements
RuleDefinitionDrop
Map<String, AlgorithmConfiguration> toBeDroppedEncryptors = new
HashMap<>();
for (String each : sqlStatement.getTables()) {
toBeDroppedTables.add(new EncryptTableRuleConfiguration(each,
Collections.emptyList()));
+ dropRule(currentRuleConfig, each);
}
- // TODO find unused encryptor
+ findUnusedEncryptors(currentRuleConfig).forEach(each ->
toBeDroppedEncryptors.put(each, currentRuleConfig.getEncryptors().get(each)));
return new EncryptRuleConfiguration(toBeDroppedTables,
toBeDroppedEncryptors);
}
@@ -85,6 +86,10 @@ public final class DropEncryptRuleStatementUpdater
implements RuleDefinitionDrop
}
private void dropUnusedEncryptor(final EncryptRuleConfiguration
currentRuleConfig) {
+ findUnusedEncryptors(currentRuleConfig).forEach(each ->
currentRuleConfig.getEncryptors().remove(each));
+ }
+
+ private static Collection<String> findUnusedEncryptors(final
EncryptRuleConfiguration currentRuleConfig) {
Collection<String> inUsedEncryptors =
currentRuleConfig.getTables().stream().flatMap(each ->
each.getColumns().stream()).map(optional ->
optional.getCipher().getEncryptorName())
.collect(Collectors.toSet());
inUsedEncryptors.addAll(currentRuleConfig.getTables().stream().flatMap(each ->
each.getColumns().stream())
@@ -93,8 +98,7 @@ public final class DropEncryptRuleStatementUpdater implements
RuleDefinitionDrop
inUsedEncryptors.addAll(currentRuleConfig.getTables().stream().flatMap(each ->
each.getColumns().stream())
.map(optional ->
optional.getLikeQuery().map(EncryptColumnItemRuleConfiguration::getEncryptorName).orElse(""))
.collect(Collectors.toSet()));
- Collection<String> unusedEncryptors =
currentRuleConfig.getEncryptors().keySet().stream().filter(each ->
!inUsedEncryptors.contains(each)).collect(Collectors.toSet());
- unusedEncryptors.forEach(each ->
currentRuleConfig.getEncryptors().remove(each));
+ return currentRuleConfig.getEncryptors().keySet().stream().filter(each
-> !inUsedEncryptors.contains(each)).collect(Collectors.toSet());
}
@Override
diff --git
a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleStatementUpdater.java
b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleStatementUpdater.java
index bf51369c941..4aba86e523d 100644
---
a/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleStatementUpdater.java
+++
b/features/mask/distsql/handler/src/main/java/org/apache/shardingsphere/mask/distsql/handler/update/DropMaskRuleStatementUpdater.java
@@ -29,7 +29,7 @@ import
org.apache.shardingsphere.mask.distsql.parser.statement.DropMaskRuleState
import java.util.Collection;
import java.util.Collections;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Optional;
@@ -64,18 +64,12 @@ public final class DropMaskRuleStatementUpdater implements
RuleDefinitionDropUpd
@Override
public MaskRuleConfiguration buildToBeDroppedRuleConfiguration(final
MaskRuleConfiguration currentRuleConfig, final DropMaskRuleStatement
sqlStatement) {
Collection<MaskTableRuleConfiguration> toBeDroppedTables = new
LinkedList<>();
+ Map<String, AlgorithmConfiguration> toBeDroppedAlgorithms = new
LinkedHashMap<>();
for (String each : sqlStatement.getTables()) {
toBeDroppedTables.add(new MaskTableRuleConfiguration(each,
Collections.emptyList()));
+ dropRule(currentRuleConfig, each);
}
- Collection<MaskColumnRuleConfiguration> columns =
currentRuleConfig.getTables().stream().filter(each ->
!sqlStatement.getTables().contains(each.getName()))
- .flatMap(each ->
each.getColumns().stream()).collect(Collectors.toList());
- Collection<String> inUsedAlgorithmNames =
columns.stream().map(MaskColumnRuleConfiguration::getMaskAlgorithm).collect(Collectors.toSet());
- Map<String, AlgorithmConfiguration> toBeDroppedAlgorithms = new
HashMap<>();
- for (String each : currentRuleConfig.getMaskAlgorithms().keySet()) {
- if (!inUsedAlgorithmNames.contains(each)) {
- toBeDroppedAlgorithms.put(each,
currentRuleConfig.getMaskAlgorithms().get(each));
- }
- }
+ findUnusedAlgorithms(currentRuleConfig).forEach(each ->
toBeDroppedAlgorithms.put(each,
currentRuleConfig.getMaskAlgorithms().get(each)));
return new MaskRuleConfiguration(toBeDroppedTables,
toBeDroppedAlgorithms);
}
@@ -92,10 +86,13 @@ public final class DropMaskRuleStatementUpdater implements
RuleDefinitionDropUpd
}
private void dropUnusedAlgorithm(final MaskRuleConfiguration
currentRuleConfig) {
+ findUnusedAlgorithms(currentRuleConfig).forEach(each ->
currentRuleConfig.getMaskAlgorithms().remove(each));
+ }
+
+ private static Collection<String> findUnusedAlgorithms(final
MaskRuleConfiguration currentRuleConfig) {
Collection<String> inUsedAlgorithms =
currentRuleConfig.getTables().stream().flatMap(each ->
each.getColumns().stream()).map(MaskColumnRuleConfiguration::getMaskAlgorithm)
.collect(Collectors.toSet());
- Collection<String> unusedAlgorithms =
currentRuleConfig.getMaskAlgorithms().keySet().stream().filter(each ->
!inUsedAlgorithms.contains(each)).collect(Collectors.toSet());
- unusedAlgorithms.forEach(each ->
currentRuleConfig.getMaskAlgorithms().remove(each));
+ return
currentRuleConfig.getMaskAlgorithms().keySet().stream().filter(each ->
!inUsedAlgorithms.contains(each)).collect(Collectors.toSet());
}
@Override
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdater.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdater.java
index c9245276362..2209f0c184e 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdater.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdater.java
@@ -17,11 +17,11 @@
package org.apache.shardingsphere.readwritesplitting.distsql.handler.update;
-import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.datanode.DataNode;
import
org.apache.shardingsphere.distsql.handler.exception.rule.MissingRequiredRuleException;
import
org.apache.shardingsphere.distsql.handler.exception.rule.RuleInUsedException;
import
org.apache.shardingsphere.distsql.handler.update.RuleDefinitionDropUpdater;
+import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.rule.identifier.type.DataNodeContainedRule;
import
org.apache.shardingsphere.infra.rule.identifier.type.DataSourceContainedRule;
@@ -38,9 +38,7 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
-import java.util.Objects;
import java.util.Optional;
-import java.util.Set;
import java.util.stream.Collectors;
/**
@@ -99,20 +97,12 @@ public final class
DropReadwriteSplittingRuleStatementUpdater implements RuleDef
public ReadwriteSplittingRuleConfiguration
buildToBeDroppedRuleConfiguration(final ReadwriteSplittingRuleConfiguration
currentRuleConfig, final DropReadwriteSplittingRuleStatement sqlStatement) {
Collection<ReadwriteSplittingDataSourceRuleConfiguration>
toBeDroppedDataSources = new LinkedList<>();
Map<String, AlgorithmConfiguration> toBeDroppedLoadBalancers = new
HashMap<>();
- sqlStatement.getNames().forEach(each -> toBeDroppedDataSources.add(new
ReadwriteSplittingDataSourceRuleConfiguration(each, null, null, null)));
- compareAndGetToBeDroppedLoadBalancers(currentRuleConfig,
sqlStatement.getNames(), toBeDroppedLoadBalancers);
- return new ReadwriteSplittingRuleConfiguration(toBeDroppedDataSources,
toBeDroppedLoadBalancers);
- }
-
- private void compareAndGetToBeDroppedLoadBalancers(final
ReadwriteSplittingRuleConfiguration currentRuleConfig, final Collection<String>
toBeDroppedDataSourceNames,
- final Map<String,
AlgorithmConfiguration> toBeDroppedLoadBalancers) {
- Set<String> inUsedLoadBalancers =
currentRuleConfig.getDataSources().stream().filter(dataSource ->
!toBeDroppedDataSourceNames.contains(dataSource.getName()))
-
.map(ReadwriteSplittingDataSourceRuleConfiguration::getLoadBalancerName).collect(Collectors.toSet());
- for (String each : currentRuleConfig.getLoadBalancers().keySet()) {
- if (!inUsedLoadBalancers.contains(each)) {
- toBeDroppedLoadBalancers.put(each, null);
- }
+ for (String each : sqlStatement.getNames()) {
+ toBeDroppedDataSources.add(new
ReadwriteSplittingDataSourceRuleConfiguration(each, null, null, null));
+ dropRule(currentRuleConfig, each);
}
+ findUnusedLoadBalancers(currentRuleConfig).forEach(each ->
toBeDroppedLoadBalancers.put(each,
currentRuleConfig.getLoadBalancers().get(each)));
+ return new ReadwriteSplittingRuleConfiguration(toBeDroppedDataSources,
toBeDroppedLoadBalancers);
}
@Override
@@ -120,22 +110,22 @@ public final class
DropReadwriteSplittingRuleStatementUpdater implements RuleDef
for (String each : sqlStatement.getNames()) {
dropRule(currentRuleConfig, each);
}
+ dropUnusedLoadBalancer(currentRuleConfig);
return currentRuleConfig.getDataSources().isEmpty();
}
private void dropRule(final ReadwriteSplittingRuleConfiguration
currentRuleConfig, final String ruleName) {
Optional<ReadwriteSplittingDataSourceRuleConfiguration>
dataSourceRuleConfig = currentRuleConfig.getDataSources().stream().filter(each
-> ruleName.equals(each.getName())).findAny();
- dataSourceRuleConfig.ifPresent(optional -> {
- currentRuleConfig.getDataSources().remove(optional);
- if (null != optional.getLoadBalancerName() &&
isLoadBalancerNotInUse(currentRuleConfig, optional.getLoadBalancerName())) {
-
currentRuleConfig.getLoadBalancers().remove(optional.getLoadBalancerName());
- }
- });
+ dataSourceRuleConfig.ifPresent(optional ->
currentRuleConfig.getDataSources().remove(optional));
+ }
+
+ private void dropUnusedLoadBalancer(final
ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ findUnusedLoadBalancers(currentRuleConfig).forEach(each ->
currentRuleConfig.getLoadBalancers().remove(each));
}
- private boolean isLoadBalancerNotInUse(final
ReadwriteSplittingRuleConfiguration currentRuleConfig, final String
toBeDroppedLoadBalancerName) {
- return
currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getLoadBalancerName)
-
.filter(Objects::nonNull).noneMatch(toBeDroppedLoadBalancerName::equals);
+ private static Collection<String> findUnusedLoadBalancers(final
ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ Collection<String> inUsedAlgorithms =
currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getLoadBalancerName).collect(Collectors.toSet());
+ return
currentRuleConfig.getLoadBalancers().keySet().stream().filter(each ->
!inUsedAlgorithms.contains(each)).collect(Collectors.toSet());
}
@Override
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdaterTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdaterTest.java
index 27b97b8551e..dd71799604b 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdaterTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleStatementUpdaterTest.java
@@ -36,6 +36,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Arrays;
import java.util.Collections;
+import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Properties;
@@ -89,7 +90,7 @@ class DropReadwriteSplittingRuleStatementUpdaterTest {
void assertUpdateCurrentRuleConfiguration() {
ReadwriteSplittingRuleConfiguration ruleConfig =
createCurrentRuleConfiguration();
assertTrue(updater.updateCurrentRuleConfiguration(createSQLStatement(),
ruleConfig));
- assertThat(ruleConfig.getLoadBalancers().size(), is(1));
+ assertThat(ruleConfig.getLoadBalancers().size(), is(0));
}
@Test
@@ -103,7 +104,7 @@ class DropReadwriteSplittingRuleStatementUpdaterTest {
void assertUpdateCurrentRuleConfigurationWithoutLoadBalancerName() {
ReadwriteSplittingRuleConfiguration ruleConfig =
createCurrentRuleConfigurationWithoutLoadBalancerName();
assertTrue(updater.updateCurrentRuleConfiguration(createSQLStatement(),
ruleConfig));
- assertThat(ruleConfig.getLoadBalancers().size(), is(1));
+ assertThat(ruleConfig.getLoadBalancers().size(), is(0));
}
private DropReadwriteSplittingRuleStatement createSQLStatement() {
@@ -112,24 +113,27 @@ class DropReadwriteSplittingRuleStatementUpdaterTest {
private ReadwriteSplittingRuleConfiguration
createCurrentRuleConfiguration() {
ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
new ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds",
- "", Collections.emptyList(), "TEST");
- Map<String, AlgorithmConfiguration> loadBalancers =
Collections.singletonMap("readwrite_ds", new AlgorithmConfiguration("TEST", new
Properties()));
+ "", Collections.emptyList(), "readwrite_ds");
+ Map<String, AlgorithmConfiguration> loadBalancers = new
LinkedHashMap<>();
+ loadBalancers.put("readwrite_ds", new AlgorithmConfiguration("TEST",
new Properties()));
return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceRuleConfig)), loadBalancers);
}
private ReadwriteSplittingRuleConfiguration
createCurrentRuleConfigurationWithoutLoadBalancerName() {
ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
new ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds",
- "", Collections.emptyList(), null);
- Map<String, AlgorithmConfiguration> loadBalancers =
Collections.singletonMap("readwrite_ds", new AlgorithmConfiguration("TEST", new
Properties()));
+ "", new LinkedList<>(), null);
+ Map<String, AlgorithmConfiguration> loadBalancers = new
LinkedHashMap<>();
+ loadBalancers.put("readwrite_ds", new AlgorithmConfiguration("TEST",
new Properties()));
return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceRuleConfig)), loadBalancers);
}
private ReadwriteSplittingRuleConfiguration
createMultipleCurrentRuleConfigurations() {
ReadwriteSplittingDataSourceRuleConfiguration fooDataSourceRuleConfig
= new ReadwriteSplittingDataSourceRuleConfiguration("foo_ds",
- "", Collections.emptyList(), "TEST");
+ "", new LinkedList<>(), "TEST");
ReadwriteSplittingDataSourceRuleConfiguration barDataSourceRuleConfig
= new ReadwriteSplittingDataSourceRuleConfiguration("bar_ds",
- "", Collections.emptyList(), "TEST");
- Map<String, AlgorithmConfiguration> loadBalancers =
Collections.singletonMap("foo_ds", new AlgorithmConfiguration("TEST", new
Properties()));
+ "", new LinkedList<>(), "TEST");
+ Map<String, AlgorithmConfiguration> loadBalancers = new
LinkedHashMap<>();
+ loadBalancers.put("TEST", new AlgorithmConfiguration("TEST", new
Properties()));
return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Arrays.asList(fooDataSourceRuleConfig, barDataSourceRuleConfig)),
loadBalancers);
}
}
diff --git
a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/api/config/ShadowRuleConfiguration.java
b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/api/config/ShadowRuleConfiguration.java
index 6ce7850a3db..d81b26d56a7 100644
---
a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/api/config/ShadowRuleConfiguration.java
+++
b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/api/config/ShadowRuleConfiguration.java
@@ -47,6 +47,6 @@ public final class ShadowRuleConfiguration implements
DatabaseRuleConfiguration,
@Override
public boolean isEmpty() {
- return dataSources.isEmpty() && tables.isEmpty() && null ==
defaultShadowAlgorithmName;
+ return dataSources.isEmpty() || tables.isEmpty();
}
}
diff --git
a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleStatementUpdater.java
b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleStatementUpdater.java
index 9ad4e3f5cac..5d115ffbe60 100644
---
a/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleStatementUpdater.java
+++
b/features/shadow/distsql/handler/src/main/java/org/apache/shardingsphere/shadow/distsql/handler/update/DropShadowRuleStatementUpdater.java
@@ -19,7 +19,6 @@ package
org.apache.shardingsphere.shadow.distsql.handler.update;
import
org.apache.shardingsphere.distsql.handler.exception.rule.MissingRequiredRuleException;
import
org.apache.shardingsphere.distsql.handler.update.RuleDefinitionDropUpdater;
-import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.util.exception.ShardingSpherePreconditions;
import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
@@ -29,12 +28,12 @@ import
org.apache.shardingsphere.shadow.distsql.handler.checker.ShadowRuleStatem
import
org.apache.shardingsphere.shadow.distsql.parser.statement.DropShadowRuleStatement;
import java.util.Collection;
-import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.stream.Collectors;
/**
@@ -73,38 +72,20 @@ public final class DropShadowRuleStatementUpdater
implements RuleDefinitionDropU
@Override
public ShadowRuleConfiguration buildToBeDroppedRuleConfiguration(final
ShadowRuleConfiguration currentRuleConfig, final DropShadowRuleStatement
sqlStatement) {
- Collection<ShadowDataSourceConfiguration> toBeDroppedDataSources = new
LinkedList<>();
- Map<String, ShadowTableConfiguration> toBeDroppedTables = new
LinkedHashMap<>();
- Map<String, AlgorithmConfiguration> toBeDroppedShadowAlgorithms = new
HashMap<>();
+ ShadowRuleConfiguration result = new ShadowRuleConfiguration();
for (String each : sqlStatement.getNames()) {
- compareAndGetToBeDroppedRule(currentRuleConfig,
toBeDroppedDataSources, toBeDroppedTables, toBeDroppedShadowAlgorithms, each,
sqlStatement.getNames());
+ result.getDataSources().add(new
ShadowDataSourceConfiguration(each, null, null));
+ dropRule(currentRuleConfig, each);
}
- ShadowRuleConfiguration result = new ShadowRuleConfiguration();
- result.setDataSources(toBeDroppedDataSources);
- result.setTables(toBeDroppedTables);
- result.setShadowAlgorithms(toBeDroppedShadowAlgorithms);
- return result;
- }
-
- private void compareAndGetToBeDroppedRule(final ShadowRuleConfiguration
currentRuleConfig, final Collection<ShadowDataSourceConfiguration>
toBeDroppedDataSources,
- final Map<String,
ShadowTableConfiguration> toBeDroppedTables, final Map<String,
AlgorithmConfiguration> toBeDroppedShadowAlgorithms,
- final String
toBeDroppedDataSourceName, final Collection<String> toBeDroppedDataSourceNames)
{
- toBeDroppedDataSources.add(new
ShadowDataSourceConfiguration(toBeDroppedDataSourceName, null, null));
+ currentRuleConfig.getTables().forEach((key, value) ->
value.getDataSourceNames().removeIf(sqlStatement.getNames()::contains));
for (Entry<String, ShadowTableConfiguration> each :
currentRuleConfig.getTables().entrySet()) {
- if
(toBeDroppedDataSourceNames.containsAll(each.getValue().getDataSourceNames())) {
- toBeDroppedTables.put(each.getKey(), each.getValue());
- }
- }
- Collection<String> inUsedAlgorithms =
currentRuleConfig.getTables().entrySet().stream().filter(each ->
!toBeDroppedTables.containsKey(each.getKey()))
- .flatMap(entry ->
entry.getValue().getShadowAlgorithmNames().stream()).collect(Collectors.toSet());
- if (null != currentRuleConfig.getDefaultShadowAlgorithmName()) {
-
inUsedAlgorithms.add(currentRuleConfig.getDefaultShadowAlgorithmName());
- }
- for (String each : currentRuleConfig.getShadowAlgorithms().keySet()) {
- if (!inUsedAlgorithms.contains(each)) {
- toBeDroppedShadowAlgorithms.put(each,
currentRuleConfig.getShadowAlgorithms().get(each));
+ if (each.getValue().getDataSourceNames().isEmpty()) {
+ result.getTables().put(each.getKey(), each.getValue());
}
}
+ currentRuleConfig.getTables().entrySet().removeIf(entry ->
entry.getValue().getDataSourceNames().isEmpty());
+ findUnusedAlgorithms(currentRuleConfig).forEach(each ->
result.getShadowAlgorithms().put(each,
currentRuleConfig.getShadowAlgorithms().get(each)));
+ return result;
}
@Override
@@ -115,7 +96,7 @@ public final class DropShadowRuleStatementUpdater implements
RuleDefinitionDropU
if
(!toBeDroppedDataSourceNames.containsAll(each.getValue().getDataSourceNames()))
{
List<String> currentDataSources = new
LinkedList<>(each.getValue().getDataSourceNames());
currentDataSources.removeAll(toBeDroppedDataSourceNames);
- tables.put(each.getKey(), new
ShadowTableConfiguration(currentDataSources, null));
+ tables.put(each.getKey(), new
ShadowTableConfiguration(currentDataSources,
each.getValue().getShadowAlgorithmNames()));
}
}
ShadowRuleConfiguration result = new ShadowRuleConfiguration();
@@ -125,20 +106,30 @@ public final class DropShadowRuleStatementUpdater
implements RuleDefinitionDropU
@Override
public boolean updateCurrentRuleConfiguration(final
DropShadowRuleStatement sqlStatement, final ShadowRuleConfiguration
currentRuleConfig) {
- currentRuleConfig.getDataSources().removeIf(each ->
sqlStatement.getNames().contains(each.getName()));
+ for (String each : sqlStatement.getNames()) {
+ dropRule(currentRuleConfig, 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.getDataSources().isEmpty() ||
currentRuleConfig.getTables().isEmpty();
}
+ private void dropRule(final ShadowRuleConfiguration currentRuleConfig,
final String ruleName) {
+ Optional<ShadowDataSourceConfiguration> dataSourceRuleConfig =
currentRuleConfig.getDataSources().stream().filter(each ->
ruleName.equals(each.getName())).findAny();
+ dataSourceRuleConfig.ifPresent(optional ->
currentRuleConfig.getDataSources().remove(optional));
+ }
+
private void dropUnusedAlgorithm(final ShadowRuleConfiguration
currentRuleConfig) {
+ findUnusedAlgorithms(currentRuleConfig).forEach(each ->
currentRuleConfig.getShadowAlgorithms().remove(each));
+ }
+
+ private static Collection<String> findUnusedAlgorithms(final
ShadowRuleConfiguration currentRuleConfig) {
Collection<String> inUsedAlgorithms =
currentRuleConfig.getTables().entrySet().stream().flatMap(entry ->
entry.getValue().getShadowAlgorithmNames().stream()).collect(Collectors.toSet());
if (null != currentRuleConfig.getDefaultShadowAlgorithmName()) {
inUsedAlgorithms.add(currentRuleConfig.getDefaultShadowAlgorithmName());
}
- Collection<String> unusedAlgorithms =
currentRuleConfig.getShadowAlgorithms().keySet().stream().filter(each ->
!inUsedAlgorithms.contains(each)).collect(Collectors.toSet());
- unusedAlgorithms.forEach(each ->
currentRuleConfig.getShadowAlgorithms().remove(each));
+ return
currentRuleConfig.getShadowAlgorithms().keySet().stream().filter(each ->
!inUsedAlgorithms.contains(each)).collect(Collectors.toSet());
}
@Override
