This is an automated email from the ASF dual-hosted git repository.
wuweijie 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 3b2176a Refactor RDLBackendHandler.findRuleConfiguration() (#10948)
3b2176a is described below
commit 3b2176af8e9bf7c031e03ecaa89a49a42fd5fcc0
Author: Liang Zhang <[email protected]>
AuthorDate: Wed Jun 23 19:48:39 2021 +0800
Refactor RDLBackendHandler.findRuleConfiguration() (#10948)
---
.../AlterDatabaseDiscoveryRuleBackendHandler.java | 25 +++++++---------
.../rdl/impl/AlterEncryptRuleBackendHandler.java | 10 +++----
.../AlterReadwriteSplittingRuleBackendHandler.java | 10 +++----
...terShardingBindingTableRulesBackendHandler.java | 12 ++++----
...rShardingBroadcastTableRulesBackendHandler.java | 6 ++--
.../impl/AlterShardingTableRuleBackendHandler.java | 35 ++++++++++------------
.../CreateDatabaseDiscoveryRuleBackendHandler.java | 10 +++----
.../rdl/impl/CreateEncryptRuleBackendHandler.java | 10 +++----
...CreateReadwriteSplittingRuleBackendHandler.java | 21 +++++++------
...ateShardingBindingTableRulesBackendHandler.java | 10 +++----
...eShardingBroadcastTableRulesBackendHandler.java | 2 +-
.../CreateShardingTableRuleBackendHandler.java | 18 +++++------
.../DropDatabaseDiscoveryRuleBackendHandler.java | 18 +++++------
.../rdl/impl/DropEncryptRuleBackendHandler.java | 14 ++++-----
.../DropReadwriteSplittingRuleBackendHandler.java | 16 +++++-----
...ropShardingBindingTableRulesBackendHandler.java | 4 +--
...pShardingBroadcastTableRulesBackendHandler.java | 4 +--
.../impl/DropShardingTableRuleBackendHandler.java | 28 ++++++++---------
.../text/distsql/rdl/impl/RDLBackendHandler.java | 27 ++++-------------
19 files changed, 127 insertions(+), 153 deletions(-)
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterDatabaseDiscoveryRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterDatabaseDiscoveryRuleBackendHandler.java
index 0ca0f2c..47fc35a 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterDatabaseDiscoveryRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterDatabaseDiscoveryRuleBackendHandler.java
@@ -55,7 +55,7 @@ public final class AlterDatabaseDiscoveryRuleBackendHandler
extends RDLBackendHa
@Override
public void before(final String schemaName, final
AlterDatabaseDiscoveryRuleStatement sqlStatement) {
- Optional<DatabaseDiscoveryRuleConfiguration> ruleConfig =
getDatabaseDiscoveryRuleConfiguration(schemaName);
+ Optional<DatabaseDiscoveryRuleConfiguration> ruleConfig =
findRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
if (!ruleConfig.isPresent()) {
throw new DatabaseDiscoveryRulesNotExistedException(schemaName,
getAlteredRuleNames(sqlStatement));
}
@@ -64,22 +64,21 @@ public final class AlterDatabaseDiscoveryRuleBackendHandler
extends RDLBackendHa
@Override
public void doExecute(final String schemaName, final
AlterDatabaseDiscoveryRuleStatement sqlStatement) {
- DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfiguration
= getDatabaseDiscoveryRuleConfiguration(schemaName).get();
+ DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfig =
findRuleConfiguration(schemaName,
DatabaseDiscoveryRuleConfiguration.class).get();
DatabaseDiscoveryRuleConfiguration
alteredDatabaseDiscoveryRuleConfiguration = new
YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singletonList(DatabaseDiscoveryRuleStatementConverter.convert(sqlStatement.getRules()))).stream()
.map(each -> (DatabaseDiscoveryRuleConfiguration)
each).findFirst().get();
- drop(sqlStatement, databaseDiscoveryRuleConfiguration);
-
databaseDiscoveryRuleConfiguration.getDataSources().addAll(alteredDatabaseDiscoveryRuleConfiguration.getDataSources());
-
databaseDiscoveryRuleConfiguration.getDiscoveryTypes().putAll(alteredDatabaseDiscoveryRuleConfiguration.getDiscoveryTypes());
+ drop(sqlStatement, databaseDiscoveryRuleConfig);
+
databaseDiscoveryRuleConfig.getDataSources().addAll(alteredDatabaseDiscoveryRuleConfiguration.getDataSources());
+
databaseDiscoveryRuleConfig.getDiscoveryTypes().putAll(alteredDatabaseDiscoveryRuleConfiguration.getDiscoveryTypes());
}
- private void drop(final AlterDatabaseDiscoveryRuleStatement sqlStatement,
- final DatabaseDiscoveryRuleConfiguration
databaseDiscoveryRuleConfiguration) {
+ private void drop(final AlterDatabaseDiscoveryRuleStatement sqlStatement,
final DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfig) {
getAlteredRuleNames(sqlStatement).forEach(each -> {
- DatabaseDiscoveryDataSourceRuleConfiguration
databaseDiscoveryDataSourceRuleConfiguration =
databaseDiscoveryRuleConfiguration.getDataSources()
+ DatabaseDiscoveryDataSourceRuleConfiguration
databaseDiscoveryDataSourceRuleConfiguration =
databaseDiscoveryRuleConfig.getDataSources()
.stream().filter(dataSource ->
dataSource.getName().equals(each)).findAny().get();
-
databaseDiscoveryRuleConfiguration.getDataSources().remove(databaseDiscoveryDataSourceRuleConfiguration);
-
databaseDiscoveryRuleConfiguration.getDiscoveryTypes().remove(databaseDiscoveryDataSourceRuleConfiguration.getDiscoveryTypeName());
+
databaseDiscoveryRuleConfig.getDataSources().remove(databaseDiscoveryDataSourceRuleConfiguration);
+
databaseDiscoveryRuleConfig.getDiscoveryTypes().remove(databaseDiscoveryDataSourceRuleConfiguration.getDiscoveryTypeName());
});
}
@@ -111,15 +110,13 @@ public final class
AlterDatabaseDiscoveryRuleBackendHandler extends RDLBackendHa
private void checkDiscoveryType(final AlterDatabaseDiscoveryRuleStatement
statement) {
Collection<String> invalidDiscoveryTypes =
statement.getRules().stream().map(DatabaseDiscoveryRuleSegment::getDiscoveryTypeName).distinct()
- .filter(each ->
!TypedSPIRegistry.findRegisteredService(DatabaseDiscoveryType.class, each, new
Properties()).isPresent())
- .collect(Collectors.toList());
+ .filter(each ->
!TypedSPIRegistry.findRegisteredService(DatabaseDiscoveryType.class, each, new
Properties()).isPresent()).collect(Collectors.toList());
if (!invalidDiscoveryTypes.isEmpty()) {
throw new
InvalidDatabaseDiscoveryTypesException(invalidDiscoveryTypes);
}
}
private Collection<String> getAlteredRuleNames(final
AlterDatabaseDiscoveryRuleStatement sqlStatement) {
- return sqlStatement.getRules()
-
.stream().map(DatabaseDiscoveryRuleSegment::getName).collect(Collectors.toList());
+ return
sqlStatement.getRules().stream().map(DatabaseDiscoveryRuleSegment::getName).collect(Collectors.toList());
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterEncryptRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterEncryptRuleBackendHandler.java
index 2d49d3a..31ba668 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterEncryptRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterEncryptRuleBackendHandler.java
@@ -53,7 +53,7 @@ public final class AlterEncryptRuleBackendHandler extends
RDLBackendHandler<Alte
@Override
public void before(final String schemaName, final
AlterEncryptRuleStatement sqlStatement) {
- Optional<EncryptRuleConfiguration> ruleConfig =
getEncryptRuleConfiguration(schemaName);
+ Optional<EncryptRuleConfiguration> ruleConfig =
findRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
if (!ruleConfig.isPresent()) {
throw new EncryptRulesNotExistedException(schemaName,
getAlteredRuleNames(sqlStatement));
}
@@ -62,13 +62,13 @@ public final class AlterEncryptRuleBackendHandler extends
RDLBackendHandler<Alte
@Override
public void doExecute(final String schemaName, final
AlterEncryptRuleStatement sqlStatement) {
- EncryptRuleConfiguration encryptRuleConfiguration =
getEncryptRuleConfiguration(schemaName).get();
+ EncryptRuleConfiguration encryptRuleConfig =
findRuleConfiguration(schemaName, EncryptRuleConfiguration.class).get();
EncryptRuleConfiguration alteredEncryptRuleConfiguration = new
YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singletonList(EncryptRuleStatementConverter.convert(sqlStatement.getRules()))).stream()
.map(each -> (EncryptRuleConfiguration)
each).findFirst().get();
- drop(sqlStatement, encryptRuleConfiguration);
-
encryptRuleConfiguration.getTables().addAll(alteredEncryptRuleConfiguration.getTables());
-
encryptRuleConfiguration.getEncryptors().putAll(alteredEncryptRuleConfiguration.getEncryptors());
+ drop(sqlStatement, encryptRuleConfig);
+
encryptRuleConfig.getTables().addAll(alteredEncryptRuleConfiguration.getTables());
+
encryptRuleConfig.getEncryptors().putAll(alteredEncryptRuleConfiguration.getEncryptors());
}
private void drop(final AlterEncryptRuleStatement sqlStatement, final
EncryptRuleConfiguration encryptRuleConfiguration) {
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterReadwriteSplittingRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterReadwriteSplittingRuleBackendHandler.java
index 842a006..c174578 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterReadwriteSplittingRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterReadwriteSplittingRuleBackendHandler.java
@@ -56,7 +56,7 @@ public final class AlterReadwriteSplittingRuleBackendHandler
extends RDLBackendH
@Override
public void before(final String schemaName, final
AlterReadwriteSplittingRuleStatement sqlStatement) {
- Optional<ReadwriteSplittingRuleConfiguration> ruleConfig =
getReadwriteSplittingRuleConfiguration(schemaName);
+ Optional<ReadwriteSplittingRuleConfiguration> ruleConfig =
findRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
if (!ruleConfig.isPresent()) {
throw new ReadwriteSplittingRulesNotExistedException(schemaName,
getAlteredRuleNames(sqlStatement));
}
@@ -68,10 +68,10 @@ public final class
AlterReadwriteSplittingRuleBackendHandler extends RDLBackendH
ReadwriteSplittingRuleConfiguration alterReadwriteSplittingRuleConfig
= new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singletonList(ReadwriteSplittingRuleStatementConverter.convert(sqlStatement))).stream()
.map(each -> (ReadwriteSplittingRuleConfiguration)
each).findFirst().get();
- ReadwriteSplittingRuleConfiguration
readwriteSplittingRuleConfiguration =
getReadwriteSplittingRuleConfiguration(schemaName).get();
- drop(sqlStatement, readwriteSplittingRuleConfiguration);
-
readwriteSplittingRuleConfiguration.getDataSources().addAll(alterReadwriteSplittingRuleConfig.getDataSources());
-
readwriteSplittingRuleConfiguration.getLoadBalancers().putAll(alterReadwriteSplittingRuleConfig.getLoadBalancers());
+ ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfig =
findRuleConfiguration(schemaName,
ReadwriteSplittingRuleConfiguration.class).get();
+ drop(sqlStatement, readwriteSplittingRuleConfig);
+
readwriteSplittingRuleConfig.getDataSources().addAll(alterReadwriteSplittingRuleConfig.getDataSources());
+
readwriteSplittingRuleConfig.getLoadBalancers().putAll(alterReadwriteSplittingRuleConfig.getLoadBalancers());
}
private void drop(final AlterReadwriteSplittingRuleStatement sqlStatement,
final ReadwriteSplittingRuleConfiguration ruleConfig) {
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBindingTableRulesBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBindingTableRulesBackendHandler.java
index ee3fb9c..44f93a7 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBindingTableRulesBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBindingTableRulesBackendHandler.java
@@ -44,7 +44,7 @@ public final class
AlterShardingBindingTableRulesBackendHandler extends RDLBacke
@Override
public void before(final String schemaName, final
AlterShardingBindingTableRulesStatement sqlStatement) {
- if (!getShardingRuleConfiguration(schemaName).isPresent()) {
+ if (!findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).isPresent()) {
throw new ShardingBindingTableRulesNotExistsException(schemaName);
}
Collection<String> invalidBindingTables = new HashSet<>();
@@ -68,15 +68,15 @@ public final class
AlterShardingBindingTableRulesBackendHandler extends RDLBacke
@Override
public void doExecute(final String schemaName, final
AlterShardingBindingTableRulesStatement sqlStatement) {
-
getShardingRuleConfiguration(schemaName).get().getBindingTableGroups().clear();
-
getShardingRuleConfiguration(schemaName).get().getBindingTableGroups().addAll(ShardingRuleStatementConverter.convert(sqlStatement).getBindingTables());
+ findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get().getBindingTableGroups().clear();
+ findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get().getBindingTableGroups().addAll(ShardingRuleStatementConverter.convert(sqlStatement).getBindingTables());
}
private Collection<String> getLogicTables(final String schemaName) {
- ShardingRuleConfiguration shardingRuleConfiguration =
getShardingRuleConfiguration(schemaName).get();
+ ShardingRuleConfiguration shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class).get();
Collection<String> result = new HashSet<>();
-
result.addAll(shardingRuleConfiguration.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
-
result.addAll(shardingRuleConfiguration.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+
result.addAll(shardingRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+
result.addAll(shardingRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
return result;
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBroadcastTableRulesBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBroadcastTableRulesBackendHandler.java
index dce3b9b..07d032e 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBroadcastTableRulesBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingBroadcastTableRulesBackendHandler.java
@@ -35,7 +35,7 @@ public final class
AlterShardingBroadcastTableRulesBackendHandler extends RDLBac
@Override
public void before(final String schemaName, final
AlterShardingBroadcastTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> shardingRuleConfig =
getShardingRuleConfiguration(schemaName);
+ Optional<ShardingRuleConfiguration> shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
if (!shardingRuleConfig.isPresent()) {
throw new
ShardingBroadcastTableRulesNotExistsException(schemaName);
}
@@ -43,7 +43,7 @@ public final class
AlterShardingBroadcastTableRulesBackendHandler extends RDLBac
@Override
public void doExecute(final String schemaName, final
AlterShardingBroadcastTableRulesStatement sqlStatement) {
-
getShardingRuleConfiguration(schemaName).get().getBroadcastTables().clear();
-
getShardingRuleConfiguration(schemaName).get().getBroadcastTables().addAll(sqlStatement.getTables());
+ findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get().getBroadcastTables().clear();
+ findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get().getBroadcastTables().addAll(sqlStatement.getTables());
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingTableRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingTableRuleBackendHandler.java
index 8ea95be..a951dac 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingTableRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/AlterShardingTableRuleBackendHandler.java
@@ -70,23 +70,21 @@ public final class AlterShardingTableRuleBackendHandler
extends RDLBackendHandle
throw new DuplicateTablesException(duplicateTables);
}
Collection<String> alteredTables = getAlteredTables(sqlStatement);
- if (!getShardingRuleConfiguration(schemaName).isPresent()) {
+ if (!findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).isPresent()) {
throw new ShardingTableRuleNotExistedException(schemaName,
alteredTables);
}
- Collection<String> existTables =
getShardingTables(getShardingRuleConfiguration(schemaName).get());
+ Collection<String> existTables =
getShardingTables(findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get());
Collection<String> notExistTables = alteredTables.stream().filter(each
-> !existTables.contains(each)).collect(Collectors.toList());
if (!notExistTables.isEmpty()) {
throw new ShardingTableRuleNotExistedException(schemaName,
notExistTables);
}
Collection<String> invalidTableAlgorithms =
sqlStatement.getRules().stream().map(each ->
each.getTableStrategy().getName()).distinct()
- .filter(each ->
!TypedSPIRegistry.findRegisteredService(ShardingAlgorithm.class, each, new
Properties()).isPresent())
- .collect(Collectors.toList());
+ .filter(each ->
!TypedSPIRegistry.findRegisteredService(ShardingAlgorithm.class, each, new
Properties()).isPresent()).collect(Collectors.toList());
if (!invalidTableAlgorithms.isEmpty()) {
throw new
InvalidShardingAlgorithmsException(invalidTableAlgorithms);
}
Collection<String> invalidKeyGenerators =
getKeyGenerators(sqlStatement).stream()
- .filter(each ->
!TypedSPIRegistry.findRegisteredService(KeyGenerateAlgorithm.class, each, new
Properties()).isPresent())
- .collect(Collectors.toList());
+ .filter(each ->
!TypedSPIRegistry.findRegisteredService(KeyGenerateAlgorithm.class, each, new
Properties()).isPresent()).collect(Collectors.toList());
if (!invalidKeyGenerators.isEmpty()) {
throw new InvalidKeyGeneratorsException(invalidKeyGenerators);
}
@@ -94,24 +92,23 @@ public final class AlterShardingTableRuleBackendHandler
extends RDLBackendHandle
@Override
public void doExecute(final String schemaName, final
AlterShardingTableRuleStatement sqlStatement) {
- ShardingRuleConfiguration alteredShardingRuleConfiguration = new
YamlRuleConfigurationSwapperEngine()
+ ShardingRuleConfiguration alteredShardingRuleConfig = new
YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singletonList(ShardingRuleStatementConverter.convert(sqlStatement))).stream()
.map(each -> (ShardingRuleConfiguration)
each).findFirst().get();
- ShardingRuleConfiguration shardingRuleConfiguration =
getShardingRuleConfiguration(schemaName).get();
- drop(shardingRuleConfiguration, sqlStatement);
-
shardingRuleConfiguration.getAutoTables().addAll(alteredShardingRuleConfiguration.getAutoTables());
-
shardingRuleConfiguration.getShardingAlgorithms().putAll(alteredShardingRuleConfiguration.getShardingAlgorithms());
-
shardingRuleConfiguration.getKeyGenerators().putAll(alteredShardingRuleConfiguration.getKeyGenerators());
+ ShardingRuleConfiguration shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class).get();
+ drop(shardingRuleConfig, sqlStatement);
+
shardingRuleConfig.getAutoTables().addAll(alteredShardingRuleConfig.getAutoTables());
+
shardingRuleConfig.getShardingAlgorithms().putAll(alteredShardingRuleConfig.getShardingAlgorithms());
+
shardingRuleConfig.getKeyGenerators().putAll(alteredShardingRuleConfig.getKeyGenerators());
}
- private void drop(final ShardingRuleConfiguration
shardingRuleConfiguration, final AlterShardingTableRuleStatement sqlStatement) {
+ private void drop(final ShardingRuleConfiguration shardingRuleConfig,
final AlterShardingTableRuleStatement sqlStatement) {
getAlteredTables(sqlStatement).stream().forEach(each -> {
- ShardingAutoTableRuleConfiguration
shardingAutoTableRuleConfiguration = shardingRuleConfiguration.getAutoTables()
- .stream().filter(tableRule ->
each.equals(tableRule.getLogicTable())).findAny().get();
-
shardingRuleConfiguration.getAutoTables().remove(shardingAutoTableRuleConfiguration);
-
shardingRuleConfiguration.getShardingAlgorithms().remove(shardingAutoTableRuleConfiguration.getShardingStrategy().getShardingAlgorithmName());
- if
(Objects.nonNull(shardingAutoTableRuleConfiguration.getKeyGenerateStrategy())) {
-
shardingRuleConfiguration.getKeyGenerators().remove(shardingAutoTableRuleConfiguration.getKeyGenerateStrategy().getKeyGeneratorName());
+ ShardingAutoTableRuleConfiguration shardingAutoTableRuleConfig =
shardingRuleConfig.getAutoTables().stream().filter(tableRule ->
each.equals(tableRule.getLogicTable())).findAny().get();
+
shardingRuleConfig.getAutoTables().remove(shardingAutoTableRuleConfig);
+
shardingRuleConfig.getShardingAlgorithms().remove(shardingAutoTableRuleConfig.getShardingStrategy().getShardingAlgorithmName());
+ if
(Objects.nonNull(shardingAutoTableRuleConfig.getKeyGenerateStrategy())) {
+
shardingRuleConfig.getKeyGenerators().remove(shardingAutoTableRuleConfig.getKeyGenerateStrategy().getKeyGeneratorName());
}
});
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateDatabaseDiscoveryRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateDatabaseDiscoveryRuleBackendHandler.java
index b7a8834..91aec3b 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateDatabaseDiscoveryRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateDatabaseDiscoveryRuleBackendHandler.java
@@ -68,17 +68,17 @@ public final class
CreateDatabaseDiscoveryRuleBackendHandler extends RDLBackendH
DatabaseDiscoveryRuleConfiguration
createdDatabaseDiscoveryRuleConfiguration = new
YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singleton(yamlDatabaseDiscoveryRuleConfig))
.stream().filter(each -> each instanceof
DatabaseDiscoveryRuleConfiguration).findAny().map(each ->
(DatabaseDiscoveryRuleConfiguration) each).get();
- if (getDatabaseDiscoveryRuleConfiguration(schemaName).isPresent()) {
- DatabaseDiscoveryRuleConfiguration
existDatabaseDiscoveryRuleConfiguration =
getDatabaseDiscoveryRuleConfiguration(schemaName).get();
-
existDatabaseDiscoveryRuleConfiguration.getDataSources().addAll(createdDatabaseDiscoveryRuleConfiguration.getDataSources());
-
existDatabaseDiscoveryRuleConfiguration.getDiscoveryTypes().putAll(createdDatabaseDiscoveryRuleConfiguration.getDiscoveryTypes());
+ if (findRuleConfiguration(schemaName,
DatabaseDiscoveryRuleConfiguration.class).isPresent()) {
+ DatabaseDiscoveryRuleConfiguration
existDatabaseDiscoveryRuleConfig = findRuleConfiguration(schemaName,
DatabaseDiscoveryRuleConfiguration.class).get();
+
existDatabaseDiscoveryRuleConfig.getDataSources().addAll(createdDatabaseDiscoveryRuleConfiguration.getDataSources());
+
existDatabaseDiscoveryRuleConfig.getDiscoveryTypes().putAll(createdDatabaseDiscoveryRuleConfiguration.getDiscoveryTypes());
} else {
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdDatabaseDiscoveryRuleConfiguration);
}
}
private void checkDuplicateRuleNames(final String schemaName, final
CreateDatabaseDiscoveryRuleStatement sqlStatement) {
- Optional<DatabaseDiscoveryRuleConfiguration> optional =
getDatabaseDiscoveryRuleConfiguration(schemaName);
+ Optional<DatabaseDiscoveryRuleConfiguration> optional =
findRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
if (optional.isPresent()) {
Collection<String> existRuleNames = getRuleNames(optional.get());
Collection<String> duplicateRuleNames =
sqlStatement.getRules().stream()
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateEncryptRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateEncryptRuleBackendHandler.java
index 747f45b..1dd74a5 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateEncryptRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateEncryptRuleBackendHandler.java
@@ -66,17 +66,17 @@ public final class CreateEncryptRuleBackendHandler extends
RDLBackendHandler<Cre
EncryptRuleConfiguration createdEncryptRuleConfiguration = new
YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singleton(yamlEncryptRuleConfiguration))
.stream().filter(each -> each instanceof
EncryptRuleConfiguration).findAny().map(each -> (EncryptRuleConfiguration)
each).get();
- if (getEncryptRuleConfiguration(schemaName).isPresent()) {
- EncryptRuleConfiguration existEncryptRuleConfiguration =
getEncryptRuleConfiguration(schemaName).get();
-
existEncryptRuleConfiguration.getTables().addAll(createdEncryptRuleConfiguration.getTables());
-
existEncryptRuleConfiguration.getEncryptors().putAll(createdEncryptRuleConfiguration.getEncryptors());
+ if (findRuleConfiguration(schemaName,
EncryptRuleConfiguration.class).isPresent()) {
+ EncryptRuleConfiguration existEncryptRuleConfig =
findRuleConfiguration(schemaName, EncryptRuleConfiguration.class).get();
+
existEncryptRuleConfig.getTables().addAll(createdEncryptRuleConfiguration.getTables());
+
existEncryptRuleConfig.getEncryptors().putAll(createdEncryptRuleConfiguration.getEncryptors());
} else {
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdEncryptRuleConfiguration);
}
}
private void checkDuplicateRuleNames(final String schemaName, final
CreateEncryptRuleStatement sqlStatement) {
- Optional<EncryptRuleConfiguration> optional =
getEncryptRuleConfiguration(schemaName);
+ Optional<EncryptRuleConfiguration> optional =
findRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
if (optional.isPresent()) {
Collection<String> existRuleNames = getRuleNames(optional.get());
Collection<String> duplicateRuleNames =
sqlStatement.getRules().stream()
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateReadwriteSplittingRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateReadwriteSplittingRuleBackendHandler.java
index 6c049a9..abdb411 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateReadwriteSplittingRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateReadwriteSplittingRuleBackendHandler.java
@@ -64,25 +64,24 @@ public final class
CreateReadwriteSplittingRuleBackendHandler extends RDLBackend
@Override
public void doExecute(final String schemaName, final
CreateReadwriteSplittingRuleStatement sqlStatement) {
- YamlReadwriteSplittingRuleConfiguration
yamlReadwriteSplittingRuleConfiguration =
ReadwriteSplittingRuleStatementConverter.convert(sqlStatement);
- ReadwriteSplittingRuleConfiguration
createdReadwriteSplittingRuleConfiguration = new
YamlRuleConfigurationSwapperEngine()
-
.swapToRuleConfigurations(Collections.singleton(yamlReadwriteSplittingRuleConfiguration))
+ YamlReadwriteSplittingRuleConfiguration
yamlReadwriteSplittingRuleConfig =
ReadwriteSplittingRuleStatementConverter.convert(sqlStatement);
+ ReadwriteSplittingRuleConfiguration
createdReadwriteSplittingRuleConfig = new YamlRuleConfigurationSwapperEngine()
+
.swapToRuleConfigurations(Collections.singleton(yamlReadwriteSplittingRuleConfig))
.stream().filter(each -> each instanceof
ReadwriteSplittingRuleConfiguration).findAny().map(each ->
(ReadwriteSplittingRuleConfiguration) each).get();
- if (getReadwriteSplittingRuleConfiguration(schemaName).isPresent()) {
- ReadwriteSplittingRuleConfiguration
existReadwriteSplittingRuleConfiguration =
getReadwriteSplittingRuleConfiguration(schemaName).get();
-
existReadwriteSplittingRuleConfiguration.getDataSources().addAll(createdReadwriteSplittingRuleConfiguration.getDataSources());
-
existReadwriteSplittingRuleConfiguration.getLoadBalancers().putAll(createdReadwriteSplittingRuleConfiguration.getLoadBalancers());
+ if (findRuleConfiguration(schemaName,
ReadwriteSplittingRuleConfiguration.class).isPresent()) {
+ ReadwriteSplittingRuleConfiguration
existReadwriteSplittingRuleConfig = findRuleConfiguration(schemaName,
ReadwriteSplittingRuleConfiguration.class).get();
+
existReadwriteSplittingRuleConfig.getDataSources().addAll(createdReadwriteSplittingRuleConfig.getDataSources());
+
existReadwriteSplittingRuleConfig.getLoadBalancers().putAll(createdReadwriteSplittingRuleConfig.getLoadBalancers());
} else {
-
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdReadwriteSplittingRuleConfiguration);
+
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdReadwriteSplittingRuleConfig);
}
}
private void checkDuplicateRuleNames(final String schemaName, final
CreateReadwriteSplittingRuleStatement sqlStatement) {
- Optional<ReadwriteSplittingRuleConfiguration> optional =
getReadwriteSplittingRuleConfiguration(schemaName);
+ Optional<ReadwriteSplittingRuleConfiguration> optional =
findRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
if (optional.isPresent()) {
Collection<String> existRuleNames = getRuleNames(optional.get());
- Collection<String> duplicateRuleNames = sqlStatement.getRules()
-
.stream().map(ReadwriteSplittingRuleSegment::getName).filter(existRuleNames::contains).collect(Collectors.toList());
+ Collection<String> duplicateRuleNames =
sqlStatement.getRules().stream().map(ReadwriteSplittingRuleSegment::getName).filter(existRuleNames::contains).collect(Collectors.toList());
if (!duplicateRuleNames.isEmpty()) {
throw new DuplicateRuleNamesException(schemaName,
duplicateRuleNames);
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBindingTableRulesBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBindingTableRulesBackendHandler.java
index d2706fb..dfa53ea 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBindingTableRulesBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBindingTableRulesBackendHandler.java
@@ -46,7 +46,7 @@ public final class
CreateShardingBindingTableRulesBackendHandler extends RDLBack
@Override
public void before(final String schemaName, final
CreateShardingBindingTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> shardingRuleConfig =
getShardingRuleConfiguration(schemaName);
+ Optional<ShardingRuleConfiguration> shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
if (!shardingRuleConfig.isPresent()) {
throw new ShardingBindingTableRulesNotExistsException(schemaName);
}
@@ -89,14 +89,14 @@ public final class
CreateShardingBindingTableRulesBackendHandler extends RDLBack
@Override
public void doExecute(final String schemaName, final
CreateShardingBindingTableRulesStatement sqlStatement) {
YamlShardingRuleConfiguration yamlShardingRuleConfiguration =
ShardingRuleStatementConverter.convert(sqlStatement);
-
getShardingRuleConfiguration(schemaName).get().getBindingTableGroups().addAll(yamlShardingRuleConfiguration.getBindingTables());
+ findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get().getBindingTableGroups().addAll(yamlShardingRuleConfiguration.getBindingTables());
}
private Collection<String> getLogicTables(final String schemaName) {
- ShardingRuleConfiguration shardingRuleConfiguration =
getShardingRuleConfiguration(schemaName).get();
+ ShardingRuleConfiguration shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class).get();
Collection<String> result = new HashSet<>();
-
result.addAll(shardingRuleConfiguration.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
-
result.addAll(shardingRuleConfiguration.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+
result.addAll(shardingRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+
result.addAll(shardingRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
return result;
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBroadcastTableRulesBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBroadcastTableRulesBackendHandler.java
index d8df68f..59f96c0 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBroadcastTableRulesBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingBroadcastTableRulesBackendHandler.java
@@ -40,7 +40,7 @@ public final class
CreateShardingBroadcastTableRulesBackendHandler extends RDLBa
@Override
public void doExecute(final String schemaName, final
CreateShardingBroadcastTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> shardingRuleConfig =
getShardingRuleConfiguration(schemaName);
+ Optional<ShardingRuleConfiguration> shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
if (!shardingRuleConfig.isPresent()) {
ShardingRuleConfiguration shardingRuleConfiguration = new
ShardingRuleConfiguration();
shardingRuleConfiguration.setBroadcastTables(sqlStatement.getTables());
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingTableRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingTableRuleBackendHandler.java
index f09ccbb..6755b38 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingTableRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/CreateShardingTableRuleBackendHandler.java
@@ -91,22 +91,22 @@ public final class CreateShardingTableRuleBackendHandler
extends RDLBackendHandl
@Override
public void doExecute(final String schemaName, final
CreateShardingTableRuleStatement sqlStatement) {
- ShardingRuleConfiguration shardingRuleConfiguration =
(ShardingRuleConfiguration) new YamlRuleConfigurationSwapperEngine()
+ ShardingRuleConfiguration shardingRuleConfig =
(ShardingRuleConfiguration) new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singleton(ShardingRuleStatementConverter.convert(sqlStatement))).iterator().next();
- Optional<ShardingRuleConfiguration> existShardingRuleConfiguration =
getShardingRuleConfiguration(schemaName);
- if (existShardingRuleConfiguration.isPresent()) {
-
existShardingRuleConfiguration.get().getAutoTables().addAll(shardingRuleConfiguration.getAutoTables());
-
existShardingRuleConfiguration.get().getShardingAlgorithms().putAll(shardingRuleConfiguration.getShardingAlgorithms());
-
existShardingRuleConfiguration.get().getKeyGenerators().putAll(shardingRuleConfiguration.getKeyGenerators());
+ Optional<ShardingRuleConfiguration> existShardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
+ if (existShardingRuleConfig.isPresent()) {
+
existShardingRuleConfig.get().getAutoTables().addAll(shardingRuleConfig.getAutoTables());
+
existShardingRuleConfig.get().getShardingAlgorithms().putAll(shardingRuleConfig.getShardingAlgorithms());
+
existShardingRuleConfig.get().getKeyGenerators().putAll(shardingRuleConfig.getKeyGenerators());
} else {
-
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(shardingRuleConfiguration);
+
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(shardingRuleConfig);
}
}
private Collection<String> getAllTables(final String schemaName) {
Collection<String> result =
Sets.newHashSet(ProxyContext.getInstance().getMetaData(schemaName).getSchema().getAllTableNames());
- if (getShardingRuleConfiguration(schemaName).isPresent()) {
-
result.addAll(getShardingTables(getShardingRuleConfiguration(schemaName).get()));
+ if (findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).isPresent()) {
+ result.addAll(getShardingTables(findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get()));
}
return result;
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropDatabaseDiscoveryRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropDatabaseDiscoveryRuleBackendHandler.java
index 4ea7813..0661ad1 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropDatabaseDiscoveryRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropDatabaseDiscoveryRuleBackendHandler.java
@@ -39,7 +39,7 @@ public final class DropDatabaseDiscoveryRuleBackendHandler
extends RDLBackendHan
@Override
public void before(final String schemaName, final
DropDatabaseDiscoveryRuleStatement sqlStatement) {
- Optional<DatabaseDiscoveryRuleConfiguration> ruleConfig =
getDatabaseDiscoveryRuleConfiguration(schemaName);
+ Optional<DatabaseDiscoveryRuleConfiguration> ruleConfig =
findRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
if (!ruleConfig.isPresent()) {
throw new DatabaseDiscoveryRulesNotExistedException(schemaName,
sqlStatement.getRuleNames());
}
@@ -48,20 +48,20 @@ public final class DropDatabaseDiscoveryRuleBackendHandler
extends RDLBackendHan
@Override
public void doExecute(final String schemaName, final
DropDatabaseDiscoveryRuleStatement sqlStatement) {
- DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfiguration
= getDatabaseDiscoveryRuleConfiguration(schemaName).get();
+ DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfig =
findRuleConfiguration(schemaName,
DatabaseDiscoveryRuleConfiguration.class).get();
sqlStatement.getRuleNames().forEach(each -> {
- DatabaseDiscoveryDataSourceRuleConfiguration
databaseDiscoveryDataSourceRuleConfiguration =
databaseDiscoveryRuleConfiguration.getDataSources()
+ DatabaseDiscoveryDataSourceRuleConfiguration
databaseDiscoveryDataSourceRuleConfiguration =
databaseDiscoveryRuleConfig.getDataSources()
.stream().filter(dataSource ->
dataSource.getName().equals(each)).findAny().get();
-
databaseDiscoveryRuleConfiguration.getDataSources().remove(databaseDiscoveryDataSourceRuleConfiguration);
-
databaseDiscoveryRuleConfiguration.getDiscoveryTypes().remove(databaseDiscoveryDataSourceRuleConfiguration.getDiscoveryTypeName());
+
databaseDiscoveryRuleConfig.getDataSources().remove(databaseDiscoveryDataSourceRuleConfiguration);
+
databaseDiscoveryRuleConfig.getDiscoveryTypes().remove(databaseDiscoveryDataSourceRuleConfiguration.getDiscoveryTypeName());
});
- if (databaseDiscoveryRuleConfiguration.getDataSources().isEmpty()) {
-
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(databaseDiscoveryRuleConfiguration);
+ if (databaseDiscoveryRuleConfig.getDataSources().isEmpty()) {
+
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(databaseDiscoveryRuleConfig);
}
}
- private void check(final String schemaName, final
DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfiguration, final
DropDatabaseDiscoveryRuleStatement sqlStatement) {
- Collection<String> existRuleNames =
databaseDiscoveryRuleConfiguration.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ private void check(final String schemaName, final
DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfig, final
DropDatabaseDiscoveryRuleStatement sqlStatement) {
+ Collection<String> existRuleNames =
databaseDiscoveryRuleConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getName).collect(Collectors.toList());
Collection<String> notExistedRuleNames =
sqlStatement.getRuleNames().stream().filter(each ->
!existRuleNames.contains(each)).collect(Collectors.toList());
if (!notExistedRuleNames.isEmpty()) {
throw new DatabaseDiscoveryRulesNotExistedException(schemaName,
notExistedRuleNames);
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropEncryptRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropEncryptRuleBackendHandler.java
index b6f0c43..b693232 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropEncryptRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropEncryptRuleBackendHandler.java
@@ -39,7 +39,7 @@ public final class DropEncryptRuleBackendHandler extends
RDLBackendHandler<DropE
@Override
public void before(final String schemaName, final DropEncryptRuleStatement
sqlStatement) {
- Optional<EncryptRuleConfiguration> ruleConfig =
getEncryptRuleConfiguration(schemaName);
+ Optional<EncryptRuleConfiguration> ruleConfig =
findRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
if (!ruleConfig.isPresent()) {
throw new EncryptRulesNotExistedException(schemaName,
sqlStatement.getTables());
}
@@ -48,15 +48,15 @@ public final class DropEncryptRuleBackendHandler extends
RDLBackendHandler<DropE
@Override
public void doExecute(final String schemaName, final
DropEncryptRuleStatement sqlStatement) {
- EncryptRuleConfiguration encryptRuleConfiguration =
getEncryptRuleConfiguration(schemaName).get();
+ EncryptRuleConfiguration encryptRuleConfig =
findRuleConfiguration(schemaName, EncryptRuleConfiguration.class).get();
sqlStatement.getTables().forEach(each -> {
- EncryptTableRuleConfiguration encryptTableRuleConfiguration =
encryptRuleConfiguration.getTables()
+ EncryptTableRuleConfiguration encryptTableRuleConfiguration =
encryptRuleConfig.getTables()
.stream().filter(tableRule ->
tableRule.getName().equals(each)).findAny().get();
-
encryptRuleConfiguration.getTables().remove(encryptTableRuleConfiguration);
- encryptTableRuleConfiguration.getColumns().forEach(column ->
encryptRuleConfiguration.getEncryptors().remove(column.getEncryptorName()));
+
encryptRuleConfig.getTables().remove(encryptTableRuleConfiguration);
+ encryptTableRuleConfiguration.getColumns().forEach(column ->
encryptRuleConfig.getEncryptors().remove(column.getEncryptorName()));
});
- if (encryptRuleConfiguration.getTables().isEmpty()) {
-
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(encryptRuleConfiguration);
+ if (encryptRuleConfig.getTables().isEmpty()) {
+
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(encryptRuleConfig);
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropReadwriteSplittingRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropReadwriteSplittingRuleBackendHandler.java
index bc2b098..ba08f67 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropReadwriteSplittingRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropReadwriteSplittingRuleBackendHandler.java
@@ -39,7 +39,7 @@ public final class DropReadwriteSplittingRuleBackendHandler
extends RDLBackendHa
@Override
public void before(final String schemaName, final
DropReadwriteSplittingRuleStatement sqlStatement) {
- Optional<ReadwriteSplittingRuleConfiguration> optional =
getReadwriteSplittingRuleConfiguration(schemaName);
+ Optional<ReadwriteSplittingRuleConfiguration> optional =
findRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
if (!optional.isPresent()) {
throw new ReadwriteSplittingRulesNotExistedException(schemaName,
sqlStatement.getRuleNames());
}
@@ -52,15 +52,15 @@ public final class DropReadwriteSplittingRuleBackendHandler
extends RDLBackendHa
@Override
public void doExecute(final String schemaName, final
DropReadwriteSplittingRuleStatement sqlStatement) {
- ReadwriteSplittingRuleConfiguration
readwriteSplittingRuleConfiguration =
getReadwriteSplittingRuleConfiguration(schemaName).get();
+ ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfig =
findRuleConfiguration(schemaName,
ReadwriteSplittingRuleConfiguration.class).get();
sqlStatement.getRuleNames().forEach(each -> {
- ReadwriteSplittingDataSourceRuleConfiguration
readwriteSplittingDataSourceRuleConfiguration =
readwriteSplittingRuleConfiguration
- .getDataSources().stream().filter(dataSource ->
each.equals(dataSource.getName())).findAny().get();
-
readwriteSplittingRuleConfiguration.getDataSources().remove(readwriteSplittingDataSourceRuleConfiguration);
-
readwriteSplittingRuleConfiguration.getLoadBalancers().remove(readwriteSplittingDataSourceRuleConfiguration.getLoadBalancerName());
+ ReadwriteSplittingDataSourceRuleConfiguration
readwriteSplittingDataSourceRuleConfig
+ =
readwriteSplittingRuleConfig.getDataSources().stream().filter(dataSource ->
each.equals(dataSource.getName())).findAny().get();
+
readwriteSplittingRuleConfig.getDataSources().remove(readwriteSplittingDataSourceRuleConfig);
+
readwriteSplittingRuleConfig.getLoadBalancers().remove(readwriteSplittingDataSourceRuleConfig.getLoadBalancerName());
});
- if (readwriteSplittingRuleConfiguration.getDataSources().isEmpty()) {
-
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(readwriteSplittingRuleConfiguration);
+ if (readwriteSplittingRuleConfig.getDataSources().isEmpty()) {
+
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(readwriteSplittingRuleConfig);
}
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBindingTableRulesBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBindingTableRulesBackendHandler.java
index 995d266..927ace6 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBindingTableRulesBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBindingTableRulesBackendHandler.java
@@ -35,7 +35,7 @@ public final class
DropShardingBindingTableRulesBackendHandler extends RDLBacken
@Override
public void before(final String schemaName, final
DropShardingBindingTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> shardingRuleConfiguration =
getShardingRuleConfiguration(schemaName);
+ Optional<ShardingRuleConfiguration> shardingRuleConfiguration =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
if (!shardingRuleConfiguration.isPresent() ||
shardingRuleConfiguration.get().getBindingTableGroups().isEmpty()) {
throw new ShardingBindingTableRulesNotExistsException(schemaName);
}
@@ -43,6 +43,6 @@ public final class
DropShardingBindingTableRulesBackendHandler extends RDLBacken
@Override
public void doExecute(final String schemaName, final
DropShardingBindingTableRulesStatement sqlStatement) {
-
getShardingRuleConfiguration(schemaName).get().getBindingTableGroups().clear();
+ findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get().getBindingTableGroups().clear();
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBroadcastTableRulesBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBroadcastTableRulesBackendHandler.java
index 24b467f..f0a5b11 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBroadcastTableRulesBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingBroadcastTableRulesBackendHandler.java
@@ -35,7 +35,7 @@ public final class
DropShardingBroadcastTableRulesBackendHandler extends RDLBack
@Override
public void before(final String schemaName, final
DropShardingBroadcastTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> shardingRuleConfiguration =
getShardingRuleConfiguration(schemaName);
+ Optional<ShardingRuleConfiguration> shardingRuleConfiguration =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
if (!shardingRuleConfiguration.isPresent() ||
shardingRuleConfiguration.get().getBroadcastTables().isEmpty()) {
throw new
ShardingBroadcastTableRulesNotExistsException(schemaName);
}
@@ -43,6 +43,6 @@ public final class
DropShardingBroadcastTableRulesBackendHandler extends RDLBack
@Override
public void doExecute(final String schemaName, final
DropShardingBroadcastTableRulesStatement sqlStatement) {
-
getShardingRuleConfiguration(schemaName).get().getBroadcastTables().clear();
+ findRuleConfiguration(schemaName,
ShardingRuleConfiguration.class).get().getBroadcastTables().clear();
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingTableRuleBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingTableRuleBackendHandler.java
index 0cd193e..e6c7729 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingTableRuleBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/DropShardingTableRuleBackendHandler.java
@@ -44,7 +44,7 @@ public final class DropShardingTableRuleBackendHandler
extends RDLBackendHandler
@Override
public void before(final String schemaName, final
DropShardingTableRuleStatement sqlStatement) {
Collection<String> tableNames =
sqlStatement.getTableNames().stream().map(each ->
each.getIdentifier().getValue()).collect(Collectors.toList());
- Optional<ShardingRuleConfiguration> shardingRuleConfig =
getShardingRuleConfiguration(schemaName);
+ Optional<ShardingRuleConfiguration> shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
if (!shardingRuleConfig.isPresent()) {
throw new ShardingTableRuleNotExistedException(schemaName,
tableNames);
}
@@ -62,9 +62,9 @@ public final class DropShardingTableRuleBackendHandler
extends RDLBackendHandler
@Override
public void doExecute(final String schemaName, final
DropShardingTableRuleStatement sqlStatement) {
- ShardingRuleConfiguration shardingRuleConfiguration =
getShardingRuleConfiguration(schemaName).get();
+ ShardingRuleConfiguration shardingRuleConfig =
findRuleConfiguration(schemaName, ShardingRuleConfiguration.class).get();
for (String each : getDroppedTables(sqlStatement)) {
- dropShardingTable(shardingRuleConfiguration, each);
+ dropShardingTable(shardingRuleConfig, each);
}
}
@@ -72,23 +72,21 @@ public final class DropShardingTableRuleBackendHandler
extends RDLBackendHandler
return sqlStatement.getTableNames().stream().map(each ->
each.getIdentifier().getValue()).collect(Collectors.toList());
}
- private Collection<String> getShardingTables(final
ShardingRuleConfiguration shardingRuleConfiguration) {
+ private Collection<String> getShardingTables(final
ShardingRuleConfiguration shardingRuleConfig) {
Collection<String> result = new LinkedList<>();
-
result.addAll(shardingRuleConfiguration.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toList()));
-
result.addAll(shardingRuleConfiguration.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toList()));
+
result.addAll(shardingRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toList()));
+
result.addAll(shardingRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toList()));
return result;
}
- private void dropShardingTable(final ShardingRuleConfiguration
shardingRuleConfiguration, final String tableName) {
-
shardingRuleConfiguration.getTables().removeAll(shardingRuleConfiguration.getTables()
- .stream().filter(each ->
tableName.equalsIgnoreCase(each.getLogicTable())).collect(Collectors.toList()));
-
shardingRuleConfiguration.getAutoTables().removeAll(shardingRuleConfiguration.getAutoTables()
- .stream().filter(each ->
tableName.equalsIgnoreCase(each.getLogicTable())).collect(Collectors.toList()));
+ private void dropShardingTable(final ShardingRuleConfiguration
shardingRuleConfig, final String tableName) {
+
shardingRuleConfig.getTables().removeAll(shardingRuleConfig.getTables().stream().filter(each
->
tableName.equalsIgnoreCase(each.getLogicTable())).collect(Collectors.toList()));
+
shardingRuleConfig.getAutoTables().removeAll(shardingRuleConfig.getAutoTables().stream().filter(each
->
tableName.equalsIgnoreCase(each.getLogicTable())).collect(Collectors.toList()));
}
- private Collection<String> getBindingTables(final
ShardingRuleConfiguration shardingRuleConfiguration) {
- Collection<String> bindTables = new LinkedHashSet<>();
- shardingRuleConfiguration.getBindingTableGroups().forEach(each ->
bindTables.addAll(Splitter.on(",").splitToList(each)));
- return bindTables;
+ private Collection<String> getBindingTables(final
ShardingRuleConfiguration shardingRuleConfig) {
+ Collection<String> result = new LinkedHashSet<>();
+ shardingRuleConfig.getBindingTableGroups().forEach(each ->
result.addAll(Splitter.on(",").splitToList(each)));
+ return result;
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/RDLBackendHandler.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/RDLBackendHandler.java
index eda8ffe..bb15d90 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/RDLBackendHandler.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/RDLBackendHandler.java
@@ -17,17 +17,14 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import
org.apache.shardingsphere.dbdiscovery.api.config.DatabaseDiscoveryRuleConfiguration;
-import org.apache.shardingsphere.encrypt.api.config.EncryptRuleConfiguration;
import
org.apache.shardingsphere.governance.core.registry.config.event.rule.RuleConfigurationsAlteredSQLNotificationEvent;
+import org.apache.shardingsphere.infra.config.scope.SchemaRuleConfiguration;
import org.apache.shardingsphere.infra.eventbus.ShardingSphereEventBus;
import
org.apache.shardingsphere.proxy.backend.communication.jdbc.connection.BackendConnection;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import
org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import
org.apache.shardingsphere.proxy.backend.text.SchemaRequiredBackendHandler;
-import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import java.util.Collection;
@@ -63,24 +60,10 @@ public abstract class RDLBackendHandler<T extends
SQLStatement> extends SchemaRe
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations()));
}
- protected final Optional<ReadwriteSplittingRuleConfiguration>
getReadwriteSplittingRuleConfiguration(final String schemaName) {
- return
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().stream()
- .filter(each -> each instanceof
ReadwriteSplittingRuleConfiguration).map(each ->
(ReadwriteSplittingRuleConfiguration) each).findFirst();
- }
-
- protected final Optional<EncryptRuleConfiguration>
getEncryptRuleConfiguration(final String schemaName) {
- return
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().stream()
- .filter(each -> each instanceof
EncryptRuleConfiguration).map(each -> (EncryptRuleConfiguration)
each).findFirst();
- }
-
- protected final Optional<DatabaseDiscoveryRuleConfiguration>
getDatabaseDiscoveryRuleConfiguration(final String schemaName) {
- return
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().stream()
- .filter(each -> each instanceof
DatabaseDiscoveryRuleConfiguration).map(each ->
(DatabaseDiscoveryRuleConfiguration) each).findFirst();
- }
-
- protected final Optional<ShardingRuleConfiguration>
getShardingRuleConfiguration(final String schemaName) {
- return
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().stream()
- .filter(each -> each instanceof
ShardingRuleConfiguration).map(each -> (ShardingRuleConfiguration)
each).findFirst();
+ @SuppressWarnings("unchecked")
+ protected final <R extends SchemaRuleConfiguration> Optional<R>
findRuleConfiguration(final String schemaName, final Class<R> configRuleClass) {
+ return ProxyContext.getInstance().getMetaData(schemaName)
+ .getRuleMetaData().getConfigurations().stream().filter(each ->
configRuleClass.isAssignableFrom(each.getClass())).map(each -> (R)
each).findFirst();
}
protected final Collection<String> getInvalidResources(final String
schemaName, final Collection<String> resources) {
