You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by wu...@apache.org on 2021/06/25 07:07:25 UTC
[shardingsphere] branch master updated: Add SchemaRuleConfiguration
generic type for RDLBackendHandler (#11010)
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 6427673 Add SchemaRuleConfiguration generic type for RDLBackendHandler (#11010)
6427673 is described below
commit 6427673fd73522a2533ac1acc5e5e7746bdb8e1e
Author: Liang Zhang <te...@163.com>
AuthorDate: Fri Jun 25 15:06:57 2021 +0800
Add SchemaRuleConfiguration generic type for RDLBackendHandler (#11010)
* Update readme doc
* For code format
* Add SchemaRuleConfiguration generic type for RDLBackendHandler
* Add SchemaRuleConfiguration generic type for RDLBackendHandler
---
.../AlterDatabaseDiscoveryRuleBackendHandler.java | 24 +++++++--------
.../rdl/impl/AlterEncryptRuleBackendHandler.java | 31 ++++++++-----------
.../AlterReadwriteSplittingRuleBackendHandler.java | 36 ++++++++++------------
...terShardingBindingTableRulesBackendHandler.java | 22 ++++++-------
...rShardingBroadcastTableRulesBackendHandler.java | 12 +++-----
.../impl/AlterShardingTableRuleBackendHandler.java | 33 ++++++++++----------
.../CreateDatabaseDiscoveryRuleBackendHandler.java | 35 ++++++++++-----------
.../rdl/impl/CreateEncryptRuleBackendHandler.java | 26 +++++++---------
...CreateReadwriteSplittingRuleBackendHandler.java | 36 ++++++++++------------
...ateShardingBindingTableRulesBackendHandler.java | 23 ++++++--------
...eShardingBroadcastTableRulesBackendHandler.java | 21 ++++++-------
.../CreateShardingTableRuleBackendHandler.java | 33 ++++++++++----------
.../DropDatabaseDiscoveryRuleBackendHandler.java | 31 ++++++++++---------
.../rdl/impl/DropEncryptRuleBackendHandler.java | 30 ++++++++----------
.../DropReadwriteSplittingRuleBackendHandler.java | 26 +++++++---------
...ropShardingBindingTableRulesBackendHandler.java | 15 ++++-----
...pShardingBroadcastTableRulesBackendHandler.java | 15 ++++-----
.../impl/DropShardingTableRuleBackendHandler.java | 25 +++++++--------
.../text/distsql/rdl/impl/RDLBackendHandler.java | 33 +++++++++++---------
19 files changed, 229 insertions(+), 278 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 bf36e14..f2abb53 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
@@ -42,7 +42,7 @@ import java.util.stream.Collectors;
/**
* Alter database discovery rule backend handler.
*/
-public final class AlterDatabaseDiscoveryRuleBackendHandler extends RDLBackendHandler<AlterDatabaseDiscoveryRuleStatement> {
+public final class AlterDatabaseDiscoveryRuleBackendHandler extends RDLBackendHandler<AlterDatabaseDiscoveryRuleStatement, DatabaseDiscoveryRuleConfiguration> {
static {
// TODO consider about register once only
@@ -54,12 +54,19 @@ public final class AlterDatabaseDiscoveryRuleBackendHandler extends RDLBackendHa
}
@Override
- public void check(final String schemaName, final AlterDatabaseDiscoveryRuleStatement sqlStatement) {
- checkToBeAlteredRules(schemaName, getRuleConfiguration(schemaName, sqlStatement), sqlStatement);
+ public void check(final String schemaName, final AlterDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ checkCurrentRuleConfiguration(schemaName, sqlStatement, currentRuleConfig);
+ checkToBeAlteredRules(schemaName, currentRuleConfig, sqlStatement);
checkToBeAlteredResources(schemaName, sqlStatement);
checkToBeAlteredDiscoveryType(sqlStatement);
}
+ private void checkCurrentRuleConfiguration(final String schemaName, final AlterDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
+ throw new DatabaseDiscoveryRuleNotExistedException(schemaName, getToBeAlteredRuleNames(sqlStatement));
+ }
+ }
+
private void checkToBeAlteredRules(final String schemaName, final DatabaseDiscoveryRuleConfiguration ruleConfig, final AlterDatabaseDiscoveryRuleStatement sqlStatement) {
Collection<String> currentRuleNames = ruleConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getName).collect(Collectors.toSet());
Collection<String> notExistedRuleNames = getToBeAlteredRuleNames(sqlStatement).stream().filter(each -> !currentRuleNames.contains(each)).collect(Collectors.toList());
@@ -97,17 +104,8 @@ public final class AlterDatabaseDiscoveryRuleBackendHandler extends RDLBackendHa
return sqlStatement.getRules().stream().map(DatabaseDiscoveryRuleSegment::getDiscoveryTypeName).collect(Collectors.toSet());
}
- private DatabaseDiscoveryRuleConfiguration getRuleConfiguration(final String schemaName, final AlterDatabaseDiscoveryRuleStatement sqlStatement) {
- Optional<DatabaseDiscoveryRuleConfiguration> result = findCurrentRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
- if (!result.isPresent()) {
- throw new DatabaseDiscoveryRuleNotExistedException(schemaName, getToBeAlteredRuleNames(sqlStatement));
- }
- return result.get();
- }
-
@Override
- public void doExecute(final String schemaName, final AlterDatabaseDiscoveryRuleStatement sqlStatement) {
- DatabaseDiscoveryRuleConfiguration currentRuleConfig = getCurrentRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
+ public void doExecute(final String schemaName, final AlterDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
dropRuleConfiguration(currentRuleConfig, sqlStatement);
addRuleConfiguration(currentRuleConfig, sqlStatement);
}
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 7e56493..b81f7a6 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
@@ -17,10 +17,10 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import org.apache.shardingsphere.encrypt.distsql.parser.segment.EncryptRuleSegment;
-import org.apache.shardingsphere.encrypt.distsql.parser.statement.AlterEncryptRuleStatement;
import org.apache.shardingsphere.encrypt.api.config.EncryptRuleConfiguration;
import org.apache.shardingsphere.encrypt.api.config.rule.EncryptTableRuleConfiguration;
+import org.apache.shardingsphere.encrypt.distsql.parser.segment.EncryptRuleSegment;
+import org.apache.shardingsphere.encrypt.distsql.parser.statement.AlterEncryptRuleStatement;
import org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm;
import org.apache.shardingsphere.encrypt.yaml.converter.EncryptRuleStatementConverter;
import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
@@ -33,14 +33,13 @@ import org.apache.shardingsphere.proxy.backend.exception.InvalidEncryptorsExcept
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
-import java.util.Optional;
import java.util.Properties;
import java.util.stream.Collectors;
/**
* Alter encrypt rule backend handler.
*/
-public final class AlterEncryptRuleBackendHandler extends RDLBackendHandler<AlterEncryptRuleStatement> {
+public final class AlterEncryptRuleBackendHandler extends RDLBackendHandler<AlterEncryptRuleStatement, EncryptRuleConfiguration> {
static {
// TODO consider about register once only
@@ -52,21 +51,16 @@ public final class AlterEncryptRuleBackendHandler extends RDLBackendHandler<Alte
}
@Override
- public void check(final String schemaName, final AlterEncryptRuleStatement sqlStatement) {
- Optional<EncryptRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
- if (!ruleConfig.isPresent()) {
+ public void check(final String schemaName, final AlterEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new EncryptRuleNotExistedException(schemaName, getAlteredRuleNames(sqlStatement));
}
- check(schemaName, sqlStatement, ruleConfig.get());
- }
-
- private void check(final String schemaName, final AlterEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration encryptRuleConfig) {
- checkAlteredTables(schemaName, encryptRuleConfig, sqlStatement);
+ checkAlteredTables(schemaName, sqlStatement, currentRuleConfig);
checkEncryptors(sqlStatement);
}
- private void checkAlteredTables(final String schemaName, final EncryptRuleConfiguration encryptRuleConfig, final AlterEncryptRuleStatement sqlStatement) {
- Collection<String> existTables = getExistTables(encryptRuleConfig);
+ private void checkAlteredTables(final String schemaName, final AlterEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
+ Collection<String> existTables = getExistTables(currentRuleConfig);
Collection<String> notExistTables = getAlteredRuleNames(sqlStatement).stream().filter(each -> !existTables.contains(each)).collect(Collectors.toList());
if (!notExistTables.isEmpty()) {
throw new EncryptRuleNotExistedException(schemaName, notExistTables);
@@ -89,14 +83,13 @@ public final class AlterEncryptRuleBackendHandler extends RDLBackendHandler<Alte
}
@Override
- public void doExecute(final String schemaName, final AlterEncryptRuleStatement sqlStatement) {
- EncryptRuleConfiguration ruleConfig = getCurrentRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
+ public void doExecute(final String schemaName, final AlterEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
EncryptRuleConfiguration alteredEncryptRuleConfiguration = new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singleton(EncryptRuleStatementConverter.convert(sqlStatement.getRules()))).stream()
.map(each -> (EncryptRuleConfiguration) each).findFirst().get();
- drop(sqlStatement, ruleConfig);
- ruleConfig.getTables().addAll(alteredEncryptRuleConfiguration.getTables());
- ruleConfig.getEncryptors().putAll(alteredEncryptRuleConfiguration.getEncryptors());
+ drop(sqlStatement, currentRuleConfig);
+ currentRuleConfig.getTables().addAll(alteredEncryptRuleConfiguration.getTables());
+ currentRuleConfig.getEncryptors().putAll(alteredEncryptRuleConfiguration.getEncryptors());
}
private void drop(final AlterEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration encryptRuleConfig) {
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 c076684..b35c658 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
@@ -18,8 +18,6 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
import com.google.common.base.Strings;
-import org.apache.shardingsphere.readwritesplitting.distsql.parser.segment.ReadwriteSplittingRuleSegment;
-import org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.AlterReadwriteSplittingRuleStatement;
import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
import org.apache.shardingsphere.infra.spi.typed.TypedSPIRegistry;
import org.apache.shardingsphere.infra.yaml.swapper.YamlRuleConfigurationSwapperEngine;
@@ -29,13 +27,14 @@ import org.apache.shardingsphere.proxy.backend.exception.ReadwriteSplittingRuleN
import org.apache.shardingsphere.proxy.backend.exception.ResourceNotExistedException;
import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
-import org.apache.shardingsphere.readwritesplitting.yaml.converter.ReadwriteSplittingRuleStatementConverter;
+import org.apache.shardingsphere.readwritesplitting.distsql.parser.segment.ReadwriteSplittingRuleSegment;
+import org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.AlterReadwriteSplittingRuleStatement;
import org.apache.shardingsphere.readwritesplitting.spi.ReplicaLoadBalanceAlgorithm;
+import org.apache.shardingsphere.readwritesplitting.yaml.converter.ReadwriteSplittingRuleStatementConverter;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
-import java.util.Optional;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
@@ -43,7 +42,7 @@ import java.util.stream.Collectors;
/**
* Alter readwrite-splitting rule backend handler.
*/
-public final class AlterReadwriteSplittingRuleBackendHandler extends RDLBackendHandler<AlterReadwriteSplittingRuleStatement> {
+public final class AlterReadwriteSplittingRuleBackendHandler extends RDLBackendHandler<AlterReadwriteSplittingRuleStatement, ReadwriteSplittingRuleConfiguration> {
static {
// TODO consider about register once only
@@ -55,23 +54,22 @@ public final class AlterReadwriteSplittingRuleBackendHandler extends RDLBackendH
}
@Override
- public void check(final String schemaName, final AlterReadwriteSplittingRuleStatement sqlStatement) {
- Optional<ReadwriteSplittingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
- if (!ruleConfig.isPresent()) {
+ public void check(final String schemaName, final AlterReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new ReadwriteSplittingRuleNotExistedException(schemaName, getAlteredRuleNames(sqlStatement));
}
- check(schemaName, sqlStatement, ruleConfig.get(), getAlteredRuleNames(sqlStatement));
+ check(schemaName, sqlStatement, getAlteredRuleNames(sqlStatement), currentRuleConfig);
}
private void check(final String schemaName, final AlterReadwriteSplittingRuleStatement sqlStatement,
- final ReadwriteSplittingRuleConfiguration ruleConfig, final Collection<String> alteredRuleNames) {
- checkAlteredRules(schemaName, ruleConfig, alteredRuleNames);
+ final Collection<String> alteredRuleNames, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ checkAlteredRules(schemaName, alteredRuleNames, currentRuleConfig);
checkResources(sqlStatement, schemaName);
checkLoadBalancer(sqlStatement);
}
- private void checkAlteredRules(final String schemaName, final ReadwriteSplittingRuleConfiguration ruleConfig, final Collection<String> alteredRuleNames) {
- Set<String> existRuleNames = ruleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toSet());
+ private void checkAlteredRules(final String schemaName, final Collection<String> alteredRuleNames, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ Set<String> existRuleNames = currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toSet());
Collection<String> notExistRuleNames = alteredRuleNames.stream()
.filter(each -> !existRuleNames.contains(each)).collect(Collectors.toList());
if (!notExistRuleNames.isEmpty()) {
@@ -93,22 +91,20 @@ public final class AlterReadwriteSplittingRuleBackendHandler extends RDLBackendH
private void checkLoadBalancer(final AlterReadwriteSplittingRuleStatement sqlStatement) {
Collection<String> invalidLoadBalances = sqlStatement.getRules().stream().map(ReadwriteSplittingRuleSegment::getLoadBalancer).distinct()
- .filter(each -> !TypedSPIRegistry.findRegisteredService(ReplicaLoadBalanceAlgorithm.class, each, new Properties()).isPresent())
- .collect(Collectors.toList());
+ .filter(each -> !TypedSPIRegistry.findRegisteredService(ReplicaLoadBalanceAlgorithm.class, each, new Properties()).isPresent()).collect(Collectors.toList());
if (!invalidLoadBalances.isEmpty()) {
throw new InvalidLoadBalancersException(invalidLoadBalances);
}
}
@Override
- public void doExecute(final String schemaName, final AlterReadwriteSplittingRuleStatement sqlStatement) {
+ public void doExecute(final String schemaName, final AlterReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
ReadwriteSplittingRuleConfiguration alterReadwriteSplittingRuleConfig = new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singletonList(ReadwriteSplittingRuleStatementConverter.convert(sqlStatement))).stream()
.map(each -> (ReadwriteSplittingRuleConfiguration) each).findFirst().get();
- ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfig = getCurrentRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
- drop(sqlStatement, readwriteSplittingRuleConfig);
- readwriteSplittingRuleConfig.getDataSources().addAll(alterReadwriteSplittingRuleConfig.getDataSources());
- readwriteSplittingRuleConfig.getLoadBalancers().putAll(alterReadwriteSplittingRuleConfig.getLoadBalancers());
+ drop(sqlStatement, currentRuleConfig);
+ currentRuleConfig.getDataSources().addAll(alterReadwriteSplittingRuleConfig.getDataSources());
+ currentRuleConfig.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 779aff7..975cf5a 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
@@ -36,19 +36,19 @@ import java.util.stream.Collectors;
/**
* Alter sharding binding table rule backend handler.
*/
-public final class AlterShardingBindingTableRulesBackendHandler extends RDLBackendHandler<AlterShardingBindingTableRulesStatement> {
+public final class AlterShardingBindingTableRulesBackendHandler extends RDLBackendHandler<AlterShardingBindingTableRulesStatement, ShardingRuleConfiguration> {
public AlterShardingBindingTableRulesBackendHandler(final AlterShardingBindingTableRulesStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final AlterShardingBindingTableRulesStatement sqlStatement) {
- if (!findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).isPresent()) {
+ public void check(final String schemaName, final AlterShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new ShardingBindingTableRuleNotExistsException(schemaName);
}
Collection<String> invalidBindingTables = new HashSet<>();
- Collection<String> existLogicTables = getLogicTables(schemaName);
+ Collection<String> existLogicTables = getLogicTables(currentRuleConfig);
Collection<String> bindingTables = ShardingRuleStatementConverter.convert(sqlStatement).getBindingTables();
for (String bindingTable : bindingTables) {
for (String logicTable : Splitter.on(",").splitToList(bindingTable)) {
@@ -67,17 +67,16 @@ public final class AlterShardingBindingTableRulesBackendHandler extends RDLBacke
}
@Override
- public void doExecute(final String schemaName, final AlterShardingBindingTableRulesStatement sqlStatement) {
- Collection<String> bindingTableGroups = getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).getBindingTableGroups();
+ public void doExecute(final String schemaName, final AlterShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ Collection<String> bindingTableGroups = currentRuleConfig.getBindingTableGroups();
bindingTableGroups.clear();
bindingTableGroups.addAll(ShardingRuleStatementConverter.convert(sqlStatement).getBindingTables());
}
- private Collection<String> getLogicTables(final String schemaName) {
- ShardingRuleConfiguration shardingRuleConfig = getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
+ private Collection<String> getLogicTables(final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> result = new HashSet<>();
- result.addAll(shardingRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
- result.addAll(shardingRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+ result.addAll(currentRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+ result.addAll(currentRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
return result;
}
@@ -88,8 +87,7 @@ public final class AlterShardingBindingTableRulesBackendHandler extends RDLBacke
private boolean notEquals(final String table, final Collection<String> tables) {
for (String each : tables) {
- if (table.equals(each) || (table.length() == each.length() && Splitter.on(",").splitToList(each)
- .containsAll(Splitter.on(",").splitToList(table)))) {
+ if (table.equals(each) || (table.length() == each.length() && Splitter.on(",").splitToList(each).containsAll(Splitter.on(",").splitToList(table)))) {
return true;
}
}
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 15b6d86..6c7137a 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
@@ -23,28 +23,26 @@ import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.distsql.parser.statement.AlterShardingBroadcastTableRulesStatement;
import java.util.Collection;
-import java.util.Optional;
/**
* Alter sharding broadcast table rule backend handler.
*/
-public final class AlterShardingBroadcastTableRulesBackendHandler extends RDLBackendHandler<AlterShardingBroadcastTableRulesStatement> {
+public final class AlterShardingBroadcastTableRulesBackendHandler extends RDLBackendHandler<AlterShardingBroadcastTableRulesStatement, ShardingRuleConfiguration> {
public AlterShardingBroadcastTableRulesBackendHandler(final AlterShardingBroadcastTableRulesStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final AlterShardingBroadcastTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> shardingRuleConfig = findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
- if (!shardingRuleConfig.isPresent()) {
+ public void check(final String schemaName, final AlterShardingBroadcastTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new ShardingBroadcastTableRuleNotExistsException(schemaName);
}
}
@Override
- public void doExecute(final String schemaName, final AlterShardingBroadcastTableRulesStatement sqlStatement) {
- Collection<String> broadcastTables = getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).getBroadcastTables();
+ public void doExecute(final String schemaName, final AlterShardingBroadcastTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ Collection<String> broadcastTables = currentRuleConfig.getBroadcastTables();
broadcastTables.clear();
broadcastTables.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 08a700f..96b56b7 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
@@ -17,8 +17,6 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import org.apache.shardingsphere.sharding.distsql.parser.segment.TableRuleSegment;
-import org.apache.shardingsphere.sharding.distsql.parser.statement.AlterShardingTableRuleStatement;
import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
import org.apache.shardingsphere.infra.spi.typed.TypedSPIRegistry;
import org.apache.shardingsphere.infra.yaml.swapper.YamlRuleConfigurationSwapperEngine;
@@ -32,6 +30,8 @@ import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
import org.apache.shardingsphere.sharding.converter.ShardingRuleStatementConverter;
+import org.apache.shardingsphere.sharding.distsql.parser.segment.TableRuleSegment;
+import org.apache.shardingsphere.sharding.distsql.parser.statement.AlterShardingTableRuleStatement;
import org.apache.shardingsphere.sharding.spi.KeyGenerateAlgorithm;
import org.apache.shardingsphere.sharding.spi.ShardingAlgorithm;
@@ -47,7 +47,7 @@ import java.util.stream.Collectors;
/**
* Alter sharding table rule backend handler.
*/
-public final class AlterShardingTableRuleBackendHandler extends RDLBackendHandler<AlterShardingTableRuleStatement> {
+public final class AlterShardingTableRuleBackendHandler extends RDLBackendHandler<AlterShardingTableRuleStatement, ShardingRuleConfiguration> {
static {
// TODO consider about register once only
@@ -60,7 +60,7 @@ public final class AlterShardingTableRuleBackendHandler extends RDLBackendHandle
}
@Override
- public void check(final String schemaName, final AlterShardingTableRuleStatement sqlStatement) {
+ public void check(final String schemaName, final AlterShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> notExistResources = getNotExistedResources(schemaName, getResources(sqlStatement));
if (!notExistResources.isEmpty()) {
throw new ResourceNotExistedException(schemaName, notExistResources);
@@ -70,10 +70,10 @@ public final class AlterShardingTableRuleBackendHandler extends RDLBackendHandle
throw new DuplicateTablesException(duplicateTables);
}
Collection<String> alteredTables = getAlteredTables(sqlStatement);
- if (!findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).isPresent()) {
+ if (null == currentRuleConfig) {
throw new ShardingTableRuleNotExistedException(schemaName, alteredTables);
}
- Collection<String> existTables = getShardingTables(findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).get());
+ Collection<String> existTables = getShardingTables(currentRuleConfig);
Collection<String> notExistTables = alteredTables.stream().filter(each -> !existTables.contains(each)).collect(Collectors.toList());
if (!notExistTables.isEmpty()) {
throw new ShardingTableRuleNotExistedException(schemaName, notExistTables);
@@ -91,23 +91,22 @@ public final class AlterShardingTableRuleBackendHandler extends RDLBackendHandle
}
@Override
- public void doExecute(final String schemaName, final AlterShardingTableRuleStatement sqlStatement) {
+ public void doExecute(final String schemaName, final AlterShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
ShardingRuleConfiguration alteredShardingRuleConfig = new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singletonList(ShardingRuleStatementConverter.convert(sqlStatement))).stream().map(each -> (ShardingRuleConfiguration) each).findFirst().get();
- ShardingRuleConfiguration shardingRuleConfig = getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
- drop(shardingRuleConfig, sqlStatement);
- shardingRuleConfig.getAutoTables().addAll(alteredShardingRuleConfig.getAutoTables());
- shardingRuleConfig.getShardingAlgorithms().putAll(alteredShardingRuleConfig.getShardingAlgorithms());
- shardingRuleConfig.getKeyGenerators().putAll(alteredShardingRuleConfig.getKeyGenerators());
+ drop(sqlStatement, currentRuleConfig);
+ currentRuleConfig.getAutoTables().addAll(alteredShardingRuleConfig.getAutoTables());
+ currentRuleConfig.getShardingAlgorithms().putAll(alteredShardingRuleConfig.getShardingAlgorithms());
+ currentRuleConfig.getKeyGenerators().putAll(alteredShardingRuleConfig.getKeyGenerators());
}
- private void drop(final ShardingRuleConfiguration shardingRuleConfig, final AlterShardingTableRuleStatement sqlStatement) {
+ private void drop(final AlterShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
getAlteredTables(sqlStatement).forEach(each -> {
- ShardingAutoTableRuleConfiguration shardingAutoTableRuleConfig = shardingRuleConfig.getAutoTables().stream().filter(tableRule -> each.equals(tableRule.getLogicTable())).findAny().get();
- shardingRuleConfig.getAutoTables().remove(shardingAutoTableRuleConfig);
- shardingRuleConfig.getShardingAlgorithms().remove(shardingAutoTableRuleConfig.getShardingStrategy().getShardingAlgorithmName());
+ ShardingAutoTableRuleConfiguration shardingAutoTableRuleConfig = currentRuleConfig.getAutoTables().stream().filter(tableRule -> each.equals(tableRule.getLogicTable())).findAny().get();
+ currentRuleConfig.getAutoTables().remove(shardingAutoTableRuleConfig);
+ currentRuleConfig.getShardingAlgorithms().remove(shardingAutoTableRuleConfig.getShardingStrategy().getShardingAlgorithmName());
if (Objects.nonNull(shardingAutoTableRuleConfig.getKeyGenerateStrategy())) {
- shardingRuleConfig.getKeyGenerators().remove(shardingAutoTableRuleConfig.getKeyGenerateStrategy().getKeyGeneratorName());
+ currentRuleConfig.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 5dabd26..e141f31 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
@@ -19,11 +19,11 @@ package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
import org.apache.shardingsphere.dbdiscovery.api.config.DatabaseDiscoveryRuleConfiguration;
import org.apache.shardingsphere.dbdiscovery.api.config.rule.DatabaseDiscoveryDataSourceRuleConfiguration;
-import org.apache.shardingsphere.dbdiscovery.yaml.config.YamlDatabaseDiscoveryRuleConfiguration;
-import org.apache.shardingsphere.dbdiscovery.yaml.converter.DatabaseDiscoveryRuleStatementConverter;
-import org.apache.shardingsphere.dbdiscovery.spi.DatabaseDiscoveryType;
import org.apache.shardingsphere.dbdiscovery.distsql.parser.segment.DatabaseDiscoveryRuleSegment;
import org.apache.shardingsphere.dbdiscovery.distsql.parser.statement.CreateDatabaseDiscoveryRuleStatement;
+import org.apache.shardingsphere.dbdiscovery.spi.DatabaseDiscoveryType;
+import org.apache.shardingsphere.dbdiscovery.yaml.config.YamlDatabaseDiscoveryRuleConfiguration;
+import org.apache.shardingsphere.dbdiscovery.yaml.converter.DatabaseDiscoveryRuleStatementConverter;
import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
import org.apache.shardingsphere.infra.spi.typed.TypedSPIRegistry;
import org.apache.shardingsphere.infra.yaml.swapper.YamlRuleConfigurationSwapperEngine;
@@ -37,14 +37,14 @@ import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Map.Entry;
-import java.util.Optional;
import java.util.Properties;
import java.util.stream.Collectors;
+
/**
* Create database discovery rule backend handler.
*/
-public final class CreateDatabaseDiscoveryRuleBackendHandler extends RDLBackendHandler<CreateDatabaseDiscoveryRuleStatement> {
+public final class CreateDatabaseDiscoveryRuleBackendHandler extends RDLBackendHandler<CreateDatabaseDiscoveryRuleStatement, DatabaseDiscoveryRuleConfiguration> {
static {
// TODO consider about register once only
@@ -56,16 +56,15 @@ public final class CreateDatabaseDiscoveryRuleBackendHandler extends RDLBackendH
}
@Override
- public void check(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
- checkDuplicateRuleNames(schemaName, sqlStatement);
+ public void check(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ checkDuplicateRuleNames(schemaName, sqlStatement, currentRuleConfig);
checkResources(schemaName, sqlStatement);
checkDiscoverTypes(sqlStatement);
}
- private void checkDuplicateRuleNames(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
- Optional<DatabaseDiscoveryRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
- if (ruleConfig.isPresent()) {
- Collection<String> existRuleNames = getRuleNames(ruleConfig.get());
+ private void checkDuplicateRuleNames(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ if (null != currentRuleConfig) {
+ Collection<String> existRuleNames = getRuleNames(currentRuleConfig);
Collection<String> duplicateRuleNames = sqlStatement.getRules().stream().map(DatabaseDiscoveryRuleSegment::getName).filter(existRuleNames::contains).collect(Collectors.toSet());
duplicateRuleNames.addAll(getDuplicateRuleNames(sqlStatement));
if (!duplicateRuleNames.isEmpty()) {
@@ -101,18 +100,16 @@ public final class CreateDatabaseDiscoveryRuleBackendHandler extends RDLBackendH
}
@Override
- public void doExecute(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
+ public void doExecute(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
YamlDatabaseDiscoveryRuleConfiguration yamlDatabaseDiscoveryRuleConfig = DatabaseDiscoveryRuleStatementConverter.convert(sqlStatement.getRules());
- DatabaseDiscoveryRuleConfiguration createdDatabaseDiscoveryRuleConfiguration = new YamlRuleConfigurationSwapperEngine()
+ DatabaseDiscoveryRuleConfiguration createdDatabaseDiscoveryRuleConfig = new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singleton(yamlDatabaseDiscoveryRuleConfig))
.stream().filter(each -> each instanceof DatabaseDiscoveryRuleConfiguration).findAny().map(each -> (DatabaseDiscoveryRuleConfiguration) each).get();
- Optional<DatabaseDiscoveryRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
- if (ruleConfig.isPresent()) {
- DatabaseDiscoveryRuleConfiguration existDatabaseDiscoveryRuleConfig = ruleConfig.get();
- existDatabaseDiscoveryRuleConfig.getDataSources().addAll(createdDatabaseDiscoveryRuleConfiguration.getDataSources());
- existDatabaseDiscoveryRuleConfig.getDiscoveryTypes().putAll(createdDatabaseDiscoveryRuleConfiguration.getDiscoveryTypes());
+ if (null == currentRuleConfig) {
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdDatabaseDiscoveryRuleConfig);
} else {
- ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdDatabaseDiscoveryRuleConfiguration);
+ currentRuleConfig.getDataSources().addAll(createdDatabaseDiscoveryRuleConfig.getDataSources());
+ currentRuleConfig.getDiscoveryTypes().putAll(createdDatabaseDiscoveryRuleConfig.getDiscoveryTypes());
}
}
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 f18dec0..238e5fc 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
@@ -35,14 +35,13 @@ import org.apache.shardingsphere.proxy.backend.exception.InvalidEncryptorsExcept
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
-import java.util.Optional;
import java.util.Properties;
import java.util.stream.Collectors;
/**
* Create encrypt rule backend handler.
*/
-public final class CreateEncryptRuleBackendHandler extends RDLBackendHandler<CreateEncryptRuleStatement> {
+public final class CreateEncryptRuleBackendHandler extends RDLBackendHandler<CreateEncryptRuleStatement, EncryptRuleConfiguration> {
static {
// TODO consider about register once only
@@ -54,16 +53,15 @@ public final class CreateEncryptRuleBackendHandler extends RDLBackendHandler<Cre
}
@Override
- public void check(final String schemaName, final CreateEncryptRuleStatement sqlStatement) {
- checkDuplicateRuleNames(schemaName, sqlStatement);
+ public void check(final String schemaName, final CreateEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
+ checkDuplicateRuleNames(schemaName, sqlStatement, currentRuleConfig);
checkEncryptors(sqlStatement);
// TODO check resource
}
- private void checkDuplicateRuleNames(final String schemaName, final CreateEncryptRuleStatement sqlStatement) {
- Optional<EncryptRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
- if (ruleConfig.isPresent()) {
- Collection<String> existRuleNames = getRuleNames(ruleConfig.get());
+ private void checkDuplicateRuleNames(final String schemaName, final CreateEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
+ if (null != currentRuleConfig) {
+ Collection<String> existRuleNames = getRuleNames(currentRuleConfig);
Collection<String> duplicateRuleNames = sqlStatement.getRules().stream().map(EncryptRuleSegment::getTableName).filter(existRuleNames::contains).collect(Collectors.toList());
if (!duplicateRuleNames.isEmpty()) {
throw new DuplicateRuleNamesException(schemaName, duplicateRuleNames);
@@ -82,18 +80,16 @@ public final class CreateEncryptRuleBackendHandler extends RDLBackendHandler<Cre
}
@Override
- public void doExecute(final String schemaName, final CreateEncryptRuleStatement sqlStatement) {
+ public void doExecute(final String schemaName, final CreateEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
YamlEncryptRuleConfiguration yamlEncryptRuleConfiguration = EncryptRuleStatementConverter.convert(sqlStatement.getRules());
EncryptRuleConfiguration createdEncryptRuleConfiguration = new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singleton(yamlEncryptRuleConfiguration))
.stream().filter(each -> each instanceof EncryptRuleConfiguration).findAny().map(each -> (EncryptRuleConfiguration) each).get();
- Optional<EncryptRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
- if (ruleConfig.isPresent()) {
- EncryptRuleConfiguration existEncryptRuleConfig = ruleConfig.get();
- existEncryptRuleConfig.getTables().addAll(createdEncryptRuleConfiguration.getTables());
- existEncryptRuleConfig.getEncryptors().putAll(createdEncryptRuleConfiguration.getEncryptors());
- } else {
+ if (null == currentRuleConfig) {
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdEncryptRuleConfiguration);
+ } else {
+ currentRuleConfig.getTables().addAll(createdEncryptRuleConfiguration.getTables());
+ currentRuleConfig.getEncryptors().putAll(createdEncryptRuleConfiguration.getEncryptors());
}
}
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 c490f38..d1cc8f6 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
@@ -18,8 +18,6 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
import com.google.common.base.Strings;
-import org.apache.shardingsphere.readwritesplitting.distsql.parser.segment.ReadwriteSplittingRuleSegment;
-import org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.CreateReadwriteSplittingRuleStatement;
import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
import org.apache.shardingsphere.infra.spi.typed.TypedSPIRegistry;
import org.apache.shardingsphere.infra.yaml.swapper.YamlRuleConfigurationSwapperEngine;
@@ -30,21 +28,22 @@ import org.apache.shardingsphere.proxy.backend.exception.InvalidLoadBalancersExc
import org.apache.shardingsphere.proxy.backend.exception.ResourceNotExistedException;
import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.distsql.parser.segment.ReadwriteSplittingRuleSegment;
+import org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.CreateReadwriteSplittingRuleStatement;
+import org.apache.shardingsphere.readwritesplitting.spi.ReplicaLoadBalanceAlgorithm;
import org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.yaml.converter.ReadwriteSplittingRuleStatementConverter;
-import org.apache.shardingsphere.readwritesplitting.spi.ReplicaLoadBalanceAlgorithm;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
-import java.util.Optional;
import java.util.Properties;
import java.util.stream.Collectors;
/**
* Create readwrite splitting rule backend handler.
*/
-public final class CreateReadwriteSplittingRuleBackendHandler extends RDLBackendHandler<CreateReadwriteSplittingRuleStatement> {
+public final class CreateReadwriteSplittingRuleBackendHandler extends RDLBackendHandler<CreateReadwriteSplittingRuleStatement, ReadwriteSplittingRuleConfiguration> {
static {
// TODO consider about register once only
@@ -56,16 +55,15 @@ public final class CreateReadwriteSplittingRuleBackendHandler extends RDLBackend
}
@Override
- public void check(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement) {
- checkDuplicateRuleNames(schemaName, sqlStatement);
+ public void check(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ checkDuplicateRuleNames(schemaName, sqlStatement, currentRuleConfig);
checkResources(schemaName, sqlStatement);
checkLoadBalancers(sqlStatement);
}
- private void checkDuplicateRuleNames(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement) {
- Optional<ReadwriteSplittingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
- if (ruleConfig.isPresent()) {
- Collection<String> existRuleNames = getRuleNames(ruleConfig.get());
+ private void checkDuplicateRuleNames(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ if (null != currentRuleConfig) {
+ Collection<String> existRuleNames = getRuleNames(currentRuleConfig);
Collection<String> duplicateRuleNames = sqlStatement.getRules().stream().map(ReadwriteSplittingRuleSegment::getName).filter(existRuleNames::contains).collect(Collectors.toList());
if (!duplicateRuleNames.isEmpty()) {
throw new DuplicateRuleNamesException(schemaName, duplicateRuleNames);
@@ -98,23 +96,21 @@ public final class CreateReadwriteSplittingRuleBackendHandler extends RDLBackend
return result;
}
- private Collection<String> getRuleNames(final ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfiguration) {
- return readwriteSplittingRuleConfiguration.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ private Collection<String> getRuleNames(final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ return currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
}
@Override
- public void doExecute(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement) {
+ public void doExecute(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
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();
- Optional<ReadwriteSplittingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
- if (ruleConfig.isPresent()) {
- ReadwriteSplittingRuleConfiguration existReadwriteSplittingRuleConfig = ruleConfig.get();
- existReadwriteSplittingRuleConfig.getDataSources().addAll(createdReadwriteSplittingRuleConfig.getDataSources());
- existReadwriteSplittingRuleConfig.getLoadBalancers().putAll(createdReadwriteSplittingRuleConfig.getLoadBalancers());
- } else {
+ if (null == currentRuleConfig) {
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdReadwriteSplittingRuleConfig);
+ } else {
+ currentRuleConfig.getDataSources().addAll(createdReadwriteSplittingRuleConfig.getDataSources());
+ currentRuleConfig.getLoadBalancers().putAll(createdReadwriteSplittingRuleConfig.getLoadBalancers());
}
}
}
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 cb9230b6..4a8fc33 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
@@ -31,27 +31,25 @@ import org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfigurat
import java.util.Collection;
import java.util.HashSet;
-import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/**
* Create sharding binding table rule backend handler.
*/
-public final class CreateShardingBindingTableRulesBackendHandler extends RDLBackendHandler<CreateShardingBindingTableRulesStatement> {
+public final class CreateShardingBindingTableRulesBackendHandler extends RDLBackendHandler<CreateShardingBindingTableRulesStatement, ShardingRuleConfiguration> {
public CreateShardingBindingTableRulesBackendHandler(final CreateShardingBindingTableRulesStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final CreateShardingBindingTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
- if (!ruleConfig.isPresent()) {
+ public void check(final String schemaName, final CreateShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new ShardingBindingTableRuleNotExistsException(schemaName);
}
Collection<String> invalidBindingTables = new HashSet<>();
- Collection<String> existLogicTables = getLogicTables(schemaName);
+ Collection<String> existLogicTables = getLogicTables(currentRuleConfig);
Collection<String> bindingTables = ShardingRuleStatementConverter.convert(sqlStatement).getBindingTables();
for (String bindingTable : bindingTables) {
for (String logicTable : Splitter.on(",").splitToList(bindingTable)) {
@@ -63,18 +61,17 @@ public final class CreateShardingBindingTableRulesBackendHandler extends RDLBack
if (!invalidBindingTables.isEmpty()) {
throw new ShardingTableRuleNotExistedException(schemaName, invalidBindingTables);
}
- bindingTables.addAll(ruleConfig.get().getBindingTableGroups());
+ bindingTables.addAll(currentRuleConfig.getBindingTableGroups());
Collection<String> duplicateBindingTables = bindingTables.stream().filter(distinct()).collect(Collectors.toList());
if (!duplicateBindingTables.isEmpty()) {
throw new DuplicateBindingTablesException(duplicateBindingTables);
}
}
- private Collection<String> getLogicTables(final String schemaName) {
- ShardingRuleConfiguration ruleConfig = getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
+ private Collection<String> getLogicTables(final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> result = new HashSet<>();
- result.addAll(ruleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
- result.addAll(ruleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+ result.addAll(currentRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
+ result.addAll(currentRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
return result;
}
@@ -95,8 +92,8 @@ public final class CreateShardingBindingTableRulesBackendHandler extends RDLBack
}
@Override
- public void doExecute(final String schemaName, final CreateShardingBindingTableRulesStatement sqlStatement) {
+ public void doExecute(final String schemaName, final CreateShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
YamlShardingRuleConfiguration yamlShardingRuleConfiguration = ShardingRuleStatementConverter.convert(sqlStatement);
- getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).getBindingTableGroups().addAll(yamlShardingRuleConfiguration.getBindingTables());
+ currentRuleConfig.getBindingTableGroups().addAll(yamlShardingRuleConfiguration.getBindingTables());
}
}
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 4241288..61a03ae 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
@@ -23,33 +23,30 @@ import org.apache.shardingsphere.proxy.backend.exception.ShardingBroadcastTableR
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.distsql.parser.statement.CreateShardingBroadcastTableRulesStatement;
-import java.util.Optional;
-
/**
* Create sharding broadcast table rule backend handler.
*/
-public final class CreateShardingBroadcastTableRulesBackendHandler extends RDLBackendHandler<CreateShardingBroadcastTableRulesStatement> {
+public final class CreateShardingBroadcastTableRulesBackendHandler extends RDLBackendHandler<CreateShardingBroadcastTableRulesStatement, ShardingRuleConfiguration> {
public CreateShardingBroadcastTableRulesBackendHandler(final CreateShardingBroadcastTableRulesStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final CreateShardingBroadcastTableRulesStatement sqlStatement) {
+ public void check(final String schemaName, final CreateShardingBroadcastTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
}
@Override
- public void doExecute(final String schemaName, final CreateShardingBroadcastTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
- if (ruleConfig.isPresent()) {
- if (!ruleConfig.get().getBroadcastTables().isEmpty()) {
- throw new ShardingBroadcastTableRuleExistedException(schemaName);
- }
- ruleConfig.get().getBroadcastTables().addAll(sqlStatement.getTables());
- } else {
+ public void doExecute(final String schemaName, final CreateShardingBroadcastTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
ShardingRuleConfiguration shardingRuleConfiguration = new ShardingRuleConfiguration();
shardingRuleConfiguration.setBroadcastTables(sqlStatement.getTables());
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(shardingRuleConfiguration);
+ } else {
+ if (!currentRuleConfig.getBroadcastTables().isEmpty()) {
+ throw new ShardingBroadcastTableRuleExistedException(schemaName);
+ }
+ currentRuleConfig.getBroadcastTables().addAll(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 0beb441..0668a32 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
@@ -17,7 +17,6 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import com.google.common.collect.Sets;
import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
import org.apache.shardingsphere.infra.spi.typed.TypedSPIRegistry;
import org.apache.shardingsphere.infra.yaml.swapper.YamlRuleConfigurationSwapperEngine;
@@ -38,11 +37,11 @@ import org.apache.shardingsphere.sharding.spi.ShardingAlgorithm;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Objects;
-import java.util.Optional;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
@@ -50,7 +49,7 @@ import java.util.stream.Collectors;
/**
* Create sharding table rule backend handler.
*/
-public final class CreateShardingTableRuleBackendHandler extends RDLBackendHandler<CreateShardingTableRuleStatement> {
+public final class CreateShardingTableRuleBackendHandler extends RDLBackendHandler<CreateShardingTableRuleStatement, ShardingRuleConfiguration> {
static {
// TODO consider about register once only
@@ -63,12 +62,12 @@ public final class CreateShardingTableRuleBackendHandler extends RDLBackendHandl
}
@Override
- public void check(final String schemaName, final CreateShardingTableRuleStatement sqlStatement) {
+ public void check(final String schemaName, final CreateShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> notExistResources = getNotExistedResources(schemaName, getResources(sqlStatement));
if (!notExistResources.isEmpty()) {
throw new ResourceNotExistedException(schemaName, notExistResources);
}
- Collection<String> existLogicTables = getAllTables(schemaName);
+ Collection<String> existLogicTables = getAllTables(schemaName, currentRuleConfig);
Set<String> duplicateTableNames = sqlStatement.getRules().stream().collect(Collectors.toMap(TableRuleSegment::getLogicTable, each -> 1, Integer::sum))
.entrySet().stream().filter(entry -> entry.getValue() > 1).map(Entry::getKey).collect(Collectors.toSet());
duplicateTableNames.addAll(sqlStatement.getRules().stream().map(TableRuleSegment::getLogicTable).filter(existLogicTables::contains).collect(Collectors.toSet()));
@@ -90,22 +89,23 @@ public final class CreateShardingTableRuleBackendHandler extends RDLBackendHandl
}
@Override
- public void doExecute(final String schemaName, final CreateShardingTableRuleStatement sqlStatement) {
+ public void doExecute(final String schemaName, final CreateShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
ShardingRuleConfiguration shardingRuleConfig = (ShardingRuleConfiguration) new YamlRuleConfigurationSwapperEngine()
.swapToRuleConfigurations(Collections.singleton(ShardingRuleStatementConverter.convert(sqlStatement))).iterator().next();
- Optional<ShardingRuleConfiguration> existShardingRuleConfig = findCurrentRuleConfiguration(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 {
+ if (null == currentRuleConfig) {
ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(shardingRuleConfig);
+ } else {
+ currentRuleConfig.getAutoTables().addAll(shardingRuleConfig.getAutoTables());
+ currentRuleConfig.getShardingAlgorithms().putAll(shardingRuleConfig.getShardingAlgorithms());
+ currentRuleConfig.getKeyGenerators().putAll(shardingRuleConfig.getKeyGenerators());
}
}
- private Collection<String> getAllTables(final String schemaName) {
- Collection<String> result = Sets.newHashSet(ProxyContext.getInstance().getMetaData(schemaName).getSchema().getAllTableNames());
- findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).ifPresent(optional -> result.addAll(getShardingTables(optional)));
+ private Collection<String> getAllTables(final String schemaName, final ShardingRuleConfiguration currentRuleConfig) {
+ Collection<String> result = new HashSet<>(ProxyContext.getInstance().getMetaData(schemaName).getSchema().getAllTableNames());
+ if (null != currentRuleConfig) {
+ result.addAll(getShardingTables(currentRuleConfig));
+ }
return result;
}
@@ -123,7 +123,6 @@ public final class CreateShardingTableRuleBackendHandler extends RDLBackendHandl
}
private Collection<String> getKeyGenerators(final CreateShardingTableRuleStatement sqlStatement) {
- return sqlStatement.getRules().stream().filter(each -> Objects.nonNull(each.getKeyGenerateStrategy()))
- .map(each -> each.getKeyGenerateStrategy().getName()).collect(Collectors.toSet());
+ return sqlStatement.getRules().stream().filter(each -> Objects.nonNull(each.getKeyGenerateStrategy())).map(each -> each.getKeyGenerateStrategy().getName()).collect(Collectors.toSet());
}
}
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 7d07ad1..9ce5789 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
@@ -25,29 +25,31 @@ import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.exception.DatabaseDiscoveryRuleNotExistedException;
import java.util.Collection;
-import java.util.Optional;
import java.util.stream.Collectors;
/**
* Drop database discovery rule backend handler.
*/
-public final class DropDatabaseDiscoveryRuleBackendHandler extends RDLBackendHandler<DropDatabaseDiscoveryRuleStatement> {
+public final class DropDatabaseDiscoveryRuleBackendHandler extends RDLBackendHandler<DropDatabaseDiscoveryRuleStatement, DatabaseDiscoveryRuleConfiguration> {
public DropDatabaseDiscoveryRuleBackendHandler(final DropDatabaseDiscoveryRuleStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final DropDatabaseDiscoveryRuleStatement sqlStatement) {
- Optional<DatabaseDiscoveryRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
- if (!ruleConfig.isPresent()) {
+ public void check(final String schemaName, final DropDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ checkCurrentRuleConfiguration(schemaName, sqlStatement, currentRuleConfig);
+ checkRuleNames(schemaName, sqlStatement, currentRuleConfig);
+ }
+
+ private void checkCurrentRuleConfiguration(final String schemaName, final DropDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new DatabaseDiscoveryRuleNotExistedException(schemaName, sqlStatement.getRuleNames());
}
- check(schemaName, ruleConfig.get(), sqlStatement);
}
- private void check(final String schemaName, final DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfig, final DropDatabaseDiscoveryRuleStatement sqlStatement) {
- Collection<String> existRuleNames = databaseDiscoveryRuleConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ private void checkRuleNames(final String schemaName, final DropDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ Collection<String> existRuleNames = currentRuleConfig.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 DatabaseDiscoveryRuleNotExistedException(schemaName, notExistedRuleNames);
@@ -55,16 +57,15 @@ public final class DropDatabaseDiscoveryRuleBackendHandler extends RDLBackendHan
}
@Override
- public void doExecute(final String schemaName, final DropDatabaseDiscoveryRuleStatement sqlStatement) {
- DatabaseDiscoveryRuleConfiguration ruleConfig = getCurrentRuleConfiguration(schemaName, DatabaseDiscoveryRuleConfiguration.class);
+ public void doExecute(final String schemaName, final DropDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
sqlStatement.getRuleNames().forEach(each -> {
- DatabaseDiscoveryDataSourceRuleConfiguration databaseDiscoveryDataSourceRuleConfig = ruleConfig.getDataSources()
+ DatabaseDiscoveryDataSourceRuleConfiguration databaseDiscoveryDataSourceRuleConfig = currentRuleConfig.getDataSources()
.stream().filter(dataSource -> dataSource.getName().equals(each)).findAny().get();
- ruleConfig.getDataSources().remove(databaseDiscoveryDataSourceRuleConfig);
- ruleConfig.getDiscoveryTypes().remove(databaseDiscoveryDataSourceRuleConfig.getDiscoveryTypeName());
+ currentRuleConfig.getDataSources().remove(databaseDiscoveryDataSourceRuleConfig);
+ currentRuleConfig.getDiscoveryTypes().remove(databaseDiscoveryDataSourceRuleConfig.getDiscoveryTypeName());
});
- if (ruleConfig.getDataSources().isEmpty()) {
- ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(ruleConfig);
+ if (currentRuleConfig.getDataSources().isEmpty()) {
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(currentRuleConfig);
}
}
}
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 ece5add..ada2166 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
@@ -17,37 +17,35 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import org.apache.shardingsphere.encrypt.distsql.parser.statement.DropEncryptRuleStatement;
import org.apache.shardingsphere.encrypt.api.config.EncryptRuleConfiguration;
import org.apache.shardingsphere.encrypt.api.config.rule.EncryptTableRuleConfiguration;
+import org.apache.shardingsphere.encrypt.distsql.parser.statement.DropEncryptRuleStatement;
import org.apache.shardingsphere.proxy.backend.communication.jdbc.connection.BackendConnection;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.exception.EncryptRuleNotExistedException;
import java.util.Collection;
-import java.util.Optional;
import java.util.stream.Collectors;
/**
* Drop encrypt rule backend handler.
*/
-public final class DropEncryptRuleBackendHandler extends RDLBackendHandler<DropEncryptRuleStatement> {
+public final class DropEncryptRuleBackendHandler extends RDLBackendHandler<DropEncryptRuleStatement, EncryptRuleConfiguration> {
public DropEncryptRuleBackendHandler(final DropEncryptRuleStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final DropEncryptRuleStatement sqlStatement) {
- Optional<EncryptRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
- if (!ruleConfig.isPresent()) {
+ public void check(final String schemaName, final DropEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new EncryptRuleNotExistedException(schemaName, sqlStatement.getTables());
}
- check(schemaName, ruleConfig.get(), sqlStatement.getTables());
+ check(schemaName, sqlStatement.getTables(), currentRuleConfig);
}
- private void check(final String schemaName, final EncryptRuleConfiguration ruleConfig, final Collection<String> droppedTables) {
- Collection<String> encryptTables = ruleConfig.getTables().stream().map(EncryptTableRuleConfiguration::getName).collect(Collectors.toList());
+ private void check(final String schemaName, final Collection<String> droppedTables, final EncryptRuleConfiguration currentRuleConfig) {
+ Collection<String> encryptTables = currentRuleConfig.getTables().stream().map(EncryptTableRuleConfiguration::getName).collect(Collectors.toList());
Collection<String> notExistedTables = droppedTables.stream().filter(each -> !encryptTables.contains(each)).collect(Collectors.toList());
if (!notExistedTables.isEmpty()) {
throw new EncryptRuleNotExistedException(schemaName, notExistedTables);
@@ -55,16 +53,14 @@ public final class DropEncryptRuleBackendHandler extends RDLBackendHandler<DropE
}
@Override
- public void doExecute(final String schemaName, final DropEncryptRuleStatement sqlStatement) {
- EncryptRuleConfiguration ruleConfig = getCurrentRuleConfiguration(schemaName, EncryptRuleConfiguration.class);
+ public void doExecute(final String schemaName, final DropEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig) {
sqlStatement.getTables().forEach(each -> {
- EncryptTableRuleConfiguration encryptTableRuleConfiguration = ruleConfig.getTables()
- .stream().filter(tableRule -> tableRule.getName().equals(each)).findAny().get();
- ruleConfig.getTables().remove(encryptTableRuleConfiguration);
- encryptTableRuleConfiguration.getColumns().forEach(column -> ruleConfig.getEncryptors().remove(column.getEncryptorName()));
+ EncryptTableRuleConfiguration encryptTableRuleConfiguration = currentRuleConfig.getTables().stream().filter(tableRule -> tableRule.getName().equals(each)).findAny().get();
+ currentRuleConfig.getTables().remove(encryptTableRuleConfiguration);
+ encryptTableRuleConfiguration.getColumns().forEach(column -> currentRuleConfig.getEncryptors().remove(column.getEncryptorName()));
});
- if (ruleConfig.getTables().isEmpty()) {
- ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(ruleConfig);
+ if (currentRuleConfig.getTables().isEmpty()) {
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(currentRuleConfig);
}
}
}
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 6037476..15215ad 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
@@ -17,33 +17,31 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.DropReadwriteSplittingRuleStatement;
import org.apache.shardingsphere.proxy.backend.communication.jdbc.connection.BackendConnection;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.exception.ReadwriteSplittingRuleNotExistedException;
import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.DropReadwriteSplittingRuleStatement;
import java.util.Collection;
-import java.util.Optional;
import java.util.stream.Collectors;
/**
* Drop readwrite splitting rule backend handler.
*/
-public final class DropReadwriteSplittingRuleBackendHandler extends RDLBackendHandler<DropReadwriteSplittingRuleStatement> {
+public final class DropReadwriteSplittingRuleBackendHandler extends RDLBackendHandler<DropReadwriteSplittingRuleStatement, ReadwriteSplittingRuleConfiguration> {
public DropReadwriteSplittingRuleBackendHandler(final DropReadwriteSplittingRuleStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final DropReadwriteSplittingRuleStatement sqlStatement) {
- Optional<ReadwriteSplittingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
- if (!ruleConfig.isPresent()) {
+ public void check(final String schemaName, final DropReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig) {
throw new ReadwriteSplittingRuleNotExistedException(schemaName, sqlStatement.getRuleNames());
}
- Collection<String> existRuleNames = ruleConfig.get().getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ Collection<String> existRuleNames = currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
Collection<String> notExistedRuleNames = sqlStatement.getRuleNames().stream().filter(each -> !existRuleNames.contains(each)).collect(Collectors.toList());
if (!notExistedRuleNames.isEmpty()) {
throw new ReadwriteSplittingRuleNotExistedException(schemaName, sqlStatement.getRuleNames());
@@ -51,16 +49,14 @@ public final class DropReadwriteSplittingRuleBackendHandler extends RDLBackendHa
}
@Override
- public void doExecute(final String schemaName, final DropReadwriteSplittingRuleStatement sqlStatement) {
- ReadwriteSplittingRuleConfiguration ruleConfig = getCurrentRuleConfiguration(schemaName, ReadwriteSplittingRuleConfiguration.class);
+ public void doExecute(final String schemaName, final DropReadwriteSplittingRuleStatement sqlStatement, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
sqlStatement.getRuleNames().forEach(each -> {
- ReadwriteSplittingDataSourceRuleConfiguration readwriteSplittingDataSourceRuleConfig
- = ruleConfig.getDataSources().stream().filter(dataSource -> each.equals(dataSource.getName())).findAny().get();
- ruleConfig.getDataSources().remove(readwriteSplittingDataSourceRuleConfig);
- ruleConfig.getLoadBalancers().remove(readwriteSplittingDataSourceRuleConfig.getLoadBalancerName());
+ ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig = currentRuleConfig.getDataSources().stream().filter(dataSource -> each.equals(dataSource.getName())).findAny().get();
+ currentRuleConfig.getDataSources().remove(dataSourceRuleConfig);
+ currentRuleConfig.getLoadBalancers().remove(dataSourceRuleConfig.getLoadBalancerName());
});
- if (ruleConfig.getDataSources().isEmpty()) {
- ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(ruleConfig);
+ if (currentRuleConfig.getDataSources().isEmpty()) {
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().remove(currentRuleConfig);
}
}
}
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 8f42f02..d208ef5 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
@@ -17,32 +17,29 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import org.apache.shardingsphere.sharding.distsql.parser.statement.DropShardingBindingTableRulesStatement;
import org.apache.shardingsphere.proxy.backend.communication.jdbc.connection.BackendConnection;
import org.apache.shardingsphere.proxy.backend.exception.ShardingBindingTableRuleNotExistsException;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
-
-import java.util.Optional;
+import org.apache.shardingsphere.sharding.distsql.parser.statement.DropShardingBindingTableRulesStatement;
/**
* Drop sharding binding table rules backend handler.
*/
-public final class DropShardingBindingTableRulesBackendHandler extends RDLBackendHandler<DropShardingBindingTableRulesStatement> {
+public final class DropShardingBindingTableRulesBackendHandler extends RDLBackendHandler<DropShardingBindingTableRulesStatement, ShardingRuleConfiguration> {
public DropShardingBindingTableRulesBackendHandler(final DropShardingBindingTableRulesStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final DropShardingBindingTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
- if (!ruleConfig.isPresent() || ruleConfig.get().getBindingTableGroups().isEmpty()) {
+ public void check(final String schemaName, final DropShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig || currentRuleConfig.getBindingTableGroups().isEmpty()) {
throw new ShardingBindingTableRuleNotExistsException(schemaName);
}
}
@Override
- public void doExecute(final String schemaName, final DropShardingBindingTableRulesStatement sqlStatement) {
- getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).getBindingTableGroups().clear();
+ public void doExecute(final String schemaName, final DropShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ currentRuleConfig.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 8399923..41e62e8 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
@@ -17,32 +17,29 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import org.apache.shardingsphere.sharding.distsql.parser.statement.DropShardingBroadcastTableRulesStatement;
import org.apache.shardingsphere.proxy.backend.communication.jdbc.connection.BackendConnection;
import org.apache.shardingsphere.proxy.backend.exception.ShardingBroadcastTableRuleNotExistsException;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
-
-import java.util.Optional;
+import org.apache.shardingsphere.sharding.distsql.parser.statement.DropShardingBroadcastTableRulesStatement;
/**
* Drop sharding broadcast table rules backend handler.
*/
-public final class DropShardingBroadcastTableRulesBackendHandler extends RDLBackendHandler<DropShardingBroadcastTableRulesStatement> {
+public final class DropShardingBroadcastTableRulesBackendHandler extends RDLBackendHandler<DropShardingBroadcastTableRulesStatement, ShardingRuleConfiguration> {
public DropShardingBroadcastTableRulesBackendHandler(final DropShardingBroadcastTableRulesStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final DropShardingBroadcastTableRulesStatement sqlStatement) {
- Optional<ShardingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
- if (!ruleConfig.isPresent() || ruleConfig.get().getBroadcastTables().isEmpty()) {
+ public void check(final String schemaName, final DropShardingBroadcastTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ if (null == currentRuleConfig || currentRuleConfig.getBroadcastTables().isEmpty()) {
throw new ShardingBroadcastTableRuleNotExistsException(schemaName);
}
}
@Override
- public void doExecute(final String schemaName, final DropShardingBroadcastTableRulesStatement sqlStatement) {
- getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class).getBroadcastTables().clear();
+ public void doExecute(final String schemaName, final DropShardingBroadcastTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ currentRuleConfig.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 f230fef..b61ac03 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
@@ -18,42 +18,40 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
import com.google.common.base.Splitter;
-import org.apache.shardingsphere.sharding.distsql.parser.statement.DropShardingTableRuleStatement;
import org.apache.shardingsphere.proxy.backend.communication.jdbc.connection.BackendConnection;
import org.apache.shardingsphere.proxy.backend.exception.ShardingTableRuleNotExistedException;
import org.apache.shardingsphere.proxy.backend.exception.ShardingTableRulesInUsedException;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
+import org.apache.shardingsphere.sharding.distsql.parser.statement.DropShardingTableRuleStatement;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.LinkedList;
-import java.util.Optional;
import java.util.stream.Collectors;
/**
* Drop sharding table rule backend handler.
*/
-public final class DropShardingTableRuleBackendHandler extends RDLBackendHandler<DropShardingTableRuleStatement> {
+public final class DropShardingTableRuleBackendHandler extends RDLBackendHandler<DropShardingTableRuleStatement, ShardingRuleConfiguration> {
public DropShardingTableRuleBackendHandler(final DropShardingTableRuleStatement sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
@Override
- public void check(final String schemaName, final DropShardingTableRuleStatement sqlStatement) {
+ public void check(final String schemaName, final DropShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> tableNames = sqlStatement.getTableNames().stream().map(each -> each.getIdentifier().getValue()).collect(Collectors.toList());
- Optional<ShardingRuleConfiguration> ruleConfig = findCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
- if (!ruleConfig.isPresent()) {
+ if (null == currentRuleConfig) {
throw new ShardingTableRuleNotExistedException(schemaName, tableNames);
}
- Collection<String> shardingTableNames = getShardingTables(ruleConfig.get());
+ Collection<String> shardingTableNames = getShardingTables(currentRuleConfig);
Collection<String> notExistedTableNames = tableNames.stream().filter(each -> !shardingTableNames.contains(each)).collect(Collectors.toList());
if (!notExistedTableNames.isEmpty()) {
throw new ShardingTableRuleNotExistedException(schemaName, notExistedTableNames);
}
- Collection<String> bindingTables = getBindingTables(ruleConfig.get());
+ Collection<String> bindingTables = getBindingTables(currentRuleConfig);
Collection<String> usedTableNames = tableNames.stream().filter(bindingTables::contains).collect(Collectors.toList());
if (!usedTableNames.isEmpty()) {
throw new ShardingTableRulesInUsedException(usedTableNames);
@@ -61,10 +59,9 @@ public final class DropShardingTableRuleBackendHandler extends RDLBackendHandler
}
@Override
- public void doExecute(final String schemaName, final DropShardingTableRuleStatement sqlStatement) {
- ShardingRuleConfiguration ruleConfig = getCurrentRuleConfiguration(schemaName, ShardingRuleConfiguration.class);
+ public void doExecute(final String schemaName, final DropShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
for (String each : getDroppedTables(sqlStatement)) {
- dropShardingTable(ruleConfig, each);
+ dropShardingTable(currentRuleConfig, each);
}
}
@@ -79,9 +76,9 @@ public final class DropShardingTableRuleBackendHandler extends RDLBackendHandler
return result;
}
- 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 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()));
}
private Collection<String> getBindingTables(final ShardingRuleConfiguration shardingRuleConfig) {
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 7ed1315..42eb4da 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,8 +17,8 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl;
-import com.google.common.base.Preconditions;
import org.apache.shardingsphere.governance.core.registry.config.event.rule.RuleConfigurationsAlteredSQLNotificationEvent;
+import org.apache.shardingsphere.infra.config.RuleConfiguration;
import org.apache.shardingsphere.infra.config.scope.SchemaRuleConfiguration;
import org.apache.shardingsphere.infra.eventbus.ShardingSphereEventBus;
import org.apache.shardingsphere.infra.metadata.resource.ShardingSphereResource;
@@ -29,6 +29,7 @@ import org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResp
import org.apache.shardingsphere.proxy.backend.text.SchemaRequiredBackendHandler;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
+import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.Optional;
import java.util.stream.Collectors;
@@ -37,24 +38,28 @@ import java.util.stream.Collectors;
* RDL backend handler.
*
* @param <T> type of SQL statement
+ * @param <R> type of rule configuration
*/
-public abstract class RDLBackendHandler<T extends SQLStatement> extends SchemaRequiredBackendHandler<T> {
+public abstract class RDLBackendHandler<T extends SQLStatement, R extends SchemaRuleConfiguration> extends SchemaRequiredBackendHandler<T> {
public RDLBackendHandler(final T sqlStatement, final BackendConnection backendConnection) {
super(sqlStatement, backendConnection);
}
+ @SuppressWarnings("unchecked")
@Override
protected final ResponseHeader execute(final String schemaName, final T sqlStatement) {
- check(schemaName, sqlStatement);
- doExecute(schemaName, sqlStatement);
+ Class<R> configRuleClass = (Class<R>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[1];
+ R currentRuleConfig = findCurrentRuleConfiguration(schemaName, configRuleClass).orElse(null);
+ check(schemaName, sqlStatement, currentRuleConfig);
+ doExecute(schemaName, sqlStatement, currentRuleConfig);
postChange(schemaName);
return new UpdateResponseHeader(sqlStatement);
}
- protected abstract void check(String schemaName, T sqlStatement);
+ protected abstract void check(String schemaName, T sqlStatement, R currentRuleConfig);
- protected abstract void doExecute(String schemaName, T sqlStatement);
+ protected abstract void doExecute(String schemaName, T sqlStatement, R currentRuleConfig);
private void postChange(final String schemaName) {
ShardingSphereEventBus.getInstance().post(
@@ -62,15 +67,13 @@ public abstract class RDLBackendHandler<T extends SQLStatement> extends SchemaRe
}
@SuppressWarnings("unchecked")
- protected final <R extends SchemaRuleConfiguration> Optional<R> findCurrentRuleConfiguration(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 <R extends SchemaRuleConfiguration> R getCurrentRuleConfiguration(final String schemaName, final Class<R> configRuleClass) {
- Optional<R> result = findCurrentRuleConfiguration(schemaName, configRuleClass);
- Preconditions.checkState(result.isPresent(), "Can not find rule type: `%s`.", configRuleClass);
- return result.get();
+ private Optional<R> findCurrentRuleConfiguration(final String schemaName, final Class<R> configRuleClass) {
+ for (RuleConfiguration each : ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations()) {
+ if (configRuleClass.isAssignableFrom(each.getClass())) {
+ return Optional.of((R) each);
+ }
+ }
+ return Optional.empty();
}
protected final Collection<String> getNotExistedResources(final String schemaName, final Collection<String> resourceNames) {