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/27 11:19:42 UTC
[shardingsphere] branch master updated: Refactor and
standardization of DropRuleStatementUpdater (#11037)
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 dae9a8a Refactor and standardization of DropRuleStatementUpdater (#11037)
dae9a8a is described below
commit dae9a8a5602cd03b12932de2488d1c4460891304
Author: Liang Zhang <te...@163.com>
AuthorDate: Sun Jun 27 19:19:17 2021 +0800
Refactor and standardization of DropRuleStatementUpdater (#11037)
* Refactor CreateDatabaseDiscoveryRuleStatementUpdater
* Refactor CreateEncryptRuleStatementUpdater
* Refactor CreateReadwriteSplittingRuleStatementUpdater
* Refactor CreateShardingBindingTableRuleStatementUpdater
* Refactor CreateShardingBroadcastTableRuleStatementUpdater
* Refactor CreateShardingTableRuleStatementUpdater
---
...reateDatabaseDiscoveryRuleStatementUpdater.java | 41 +++++-----
.../updater/CreateEncryptRuleStatementUpdater.java | 39 +++++-----
...eateReadwriteSplittingRuleStatementUpdater.java | 47 ++++++-----
...teShardingBindingTableRuleStatementUpdater.java | 31 ++++----
...ShardingBroadcastTableRuleStatementUpdater.java | 6 +-
.../CreateShardingTableRuleStatementUpdater.java | 90 +++++++++++++---------
6 files changed, 133 insertions(+), 121 deletions(-)
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateDatabaseDiscoveryRuleStatementUpdater.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateDatabaseDiscoveryRuleStatementUpdater.java
index ee7b04b..6196206 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateDatabaseDiscoveryRuleStatementUpdater.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateDatabaseDiscoveryRuleStatementUpdater.java
@@ -17,12 +17,12 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl.updater;
+import com.google.common.base.Preconditions;
import org.apache.shardingsphere.dbdiscovery.api.config.DatabaseDiscoveryRuleConfiguration;
import org.apache.shardingsphere.dbdiscovery.api.config.rule.DatabaseDiscoveryDataSourceRuleConfiguration;
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.distsql.RDLUpdater;
import org.apache.shardingsphere.infra.metadata.resource.ShardingSphereResource;
@@ -38,6 +38,7 @@ 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;
@@ -55,22 +56,22 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdater implements RDLUpd
public void checkSQLStatement(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement,
final DatabaseDiscoveryRuleConfiguration currentRuleConfig, final ShardingSphereResource resource) {
checkDuplicateRuleNames(schemaName, sqlStatement, currentRuleConfig);
- checkResources(schemaName, sqlStatement, resource);
- checkDiscoverTypes(sqlStatement);
+ checkToBeCreatedResources(schemaName, sqlStatement, resource);
+ checkToBeCreatedDiscoverTypes(sqlStatement);
}
private void checkDuplicateRuleNames(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
if (null != currentRuleConfig) {
- Collection<String> existRuleNames = getRuleNames(currentRuleConfig);
+ Collection<String> existRuleNames = currentRuleConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getName).collect(Collectors.toList());
Collection<String> duplicateRuleNames = sqlStatement.getRules().stream().map(DatabaseDiscoveryRuleSegment::getName).filter(existRuleNames::contains).collect(Collectors.toSet());
- duplicateRuleNames.addAll(getDuplicateRuleNames(sqlStatement));
+ duplicateRuleNames.addAll(getToBeCreatedDuplicateRuleNames(sqlStatement));
if (!duplicateRuleNames.isEmpty()) {
throw new DuplicateRuleNamesException(schemaName, duplicateRuleNames);
}
}
}
- private Collection<String> getDuplicateRuleNames(final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
+ private Collection<String> getToBeCreatedDuplicateRuleNames(final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
return sqlStatement.getRules().stream()
.collect(Collectors.toMap(DatabaseDiscoveryRuleSegment::getName, e -> 1, Integer::sum))
.entrySet().stream()
@@ -79,7 +80,7 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdater implements RDLUpd
.collect(Collectors.toSet());
}
- private void checkResources(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final ShardingSphereResource resource) {
+ private void checkToBeCreatedResources(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final ShardingSphereResource resource) {
Collection<String> resources = new LinkedHashSet<>();
sqlStatement.getRules().forEach(each -> resources.addAll(each.getDataSources()));
Collection<String> notExistResources = resource.getNotExistedResources(resources);
@@ -88,33 +89,29 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdater implements RDLUpd
}
}
- private void checkDiscoverTypes(final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
- Collection<String> invalidDiscoveryTypes = sqlStatement.getRules().stream().map(DatabaseDiscoveryRuleSegment::getDiscoveryTypeName).distinct()
+ private void checkToBeCreatedDiscoverTypes(final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
+ Collection<String> notExistedDiscoveryTypes = sqlStatement.getRules().stream().map(DatabaseDiscoveryRuleSegment::getDiscoveryTypeName).distinct()
.filter(each -> !TypedSPIRegistry.findRegisteredService(DatabaseDiscoveryType.class, each, new Properties()).isPresent()).collect(Collectors.toList());
- if (!invalidDiscoveryTypes.isEmpty()) {
- throw new InvalidDatabaseDiscoveryTypesException(invalidDiscoveryTypes);
+ if (!notExistedDiscoveryTypes.isEmpty()) {
+ throw new InvalidDatabaseDiscoveryTypesException(notExistedDiscoveryTypes);
}
}
@Override
public boolean updateCurrentRuleConfiguration(final String schemaName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
- YamlDatabaseDiscoveryRuleConfiguration yamlDatabaseDiscoveryRuleConfig = DatabaseDiscoveryRuleStatementConverter.convert(sqlStatement.getRules());
- DatabaseDiscoveryRuleConfiguration createdDatabaseDiscoveryRuleConfig = new YamlRuleConfigurationSwapperEngine()
- .swapToRuleConfigurations(Collections.singleton(yamlDatabaseDiscoveryRuleConfig))
- .stream().filter(each -> each instanceof DatabaseDiscoveryRuleConfiguration).findAny().map(each -> (DatabaseDiscoveryRuleConfiguration) each).get();
+ Optional<DatabaseDiscoveryRuleConfiguration> toBeCreatedRuleConfig = new YamlRuleConfigurationSwapperEngine()
+ .swapToRuleConfigurations(Collections.singleton(DatabaseDiscoveryRuleStatementConverter.convert(sqlStatement.getRules())))
+ .stream().filter(each -> each instanceof DatabaseDiscoveryRuleConfiguration).findAny().map(each -> (DatabaseDiscoveryRuleConfiguration) each);
+ Preconditions.checkState(toBeCreatedRuleConfig.isPresent());
if (null == currentRuleConfig) {
- ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdDatabaseDiscoveryRuleConfig);
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(toBeCreatedRuleConfig.get());
} else {
- currentRuleConfig.getDataSources().addAll(createdDatabaseDiscoveryRuleConfig.getDataSources());
- currentRuleConfig.getDiscoveryTypes().putAll(createdDatabaseDiscoveryRuleConfig.getDiscoveryTypes());
+ currentRuleConfig.getDataSources().addAll(toBeCreatedRuleConfig.get().getDataSources());
+ currentRuleConfig.getDiscoveryTypes().putAll(toBeCreatedRuleConfig.get().getDiscoveryTypes());
}
return false;
}
- private Collection<String> getRuleNames(final DatabaseDiscoveryRuleConfiguration databaseDiscoveryRuleConfiguration) {
- return databaseDiscoveryRuleConfiguration.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getName).collect(Collectors.toList());
- }
-
@Override
public String getType() {
return CreateDatabaseDiscoveryRuleStatement.class.getCanonicalName();
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateEncryptRuleStatementUpdater.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateEncryptRuleStatementUpdater.java
index c0a2388..3654114 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateEncryptRuleStatementUpdater.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateEncryptRuleStatementUpdater.java
@@ -17,12 +17,12 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl.updater;
+import com.google.common.base.Preconditions;
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.CreateEncryptRuleStatement;
import org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm;
-import org.apache.shardingsphere.encrypt.yaml.config.YamlEncryptRuleConfiguration;
import org.apache.shardingsphere.encrypt.yaml.converter.EncryptRuleStatementConverter;
import org.apache.shardingsphere.infra.distsql.RDLUpdater;
import org.apache.shardingsphere.infra.metadata.resource.ShardingSphereResource;
@@ -36,6 +36,7 @@ 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;
@@ -52,49 +53,45 @@ public final class CreateEncryptRuleStatementUpdater implements RDLUpdater<Creat
@Override
public void checkSQLStatement(final String schemaName, final CreateEncryptRuleStatement sqlStatement, final EncryptRuleConfiguration currentRuleConfig, final ShardingSphereResource resource) {
checkDuplicateRuleNames(schemaName, sqlStatement, currentRuleConfig);
- checkEncryptors(sqlStatement);
+ checkToBeCreatedEncryptors(sqlStatement);
// TODO check resource
}
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);
+ Collection<String> currentRuleNames = currentRuleConfig.getTables().stream().map(EncryptTableRuleConfiguration::getName).collect(Collectors.toList());
+ Collection<String> toBeCreatedDuplicateRuleNames = sqlStatement.getRules().stream().map(EncryptRuleSegment::getTableName).filter(currentRuleNames::contains).collect(Collectors.toList());
+ if (!toBeCreatedDuplicateRuleNames.isEmpty()) {
+ throw new DuplicateRuleNamesException(schemaName, toBeCreatedDuplicateRuleNames);
}
}
}
- private void checkEncryptors(final CreateEncryptRuleStatement sqlStatement) {
+ private void checkToBeCreatedEncryptors(final CreateEncryptRuleStatement sqlStatement) {
Collection<String> encryptors = new LinkedHashSet<>();
sqlStatement.getRules().forEach(each -> encryptors.addAll(each.getColumns().stream().map(column -> column.getEncryptor().getName()).collect(Collectors.toSet())));
- Collection<String> invalidEncryptors = encryptors.stream().filter(
+ Collection<String> notExistedEncryptors = encryptors.stream().filter(
each -> !TypedSPIRegistry.findRegisteredService(EncryptAlgorithm.class, each, new Properties()).isPresent()).collect(Collectors.toList());
- if (!invalidEncryptors.isEmpty()) {
- throw new InvalidEncryptorsException(invalidEncryptors);
+ if (!notExistedEncryptors.isEmpty()) {
+ throw new InvalidEncryptorsException(notExistedEncryptors);
}
}
@Override
public boolean updateCurrentRuleConfiguration(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> toBeCreatedRuleConfig = new YamlRuleConfigurationSwapperEngine()
+ .swapToRuleConfigurations(Collections.singleton(EncryptRuleStatementConverter.convert(sqlStatement.getRules())))
+ .stream().filter(each -> each instanceof EncryptRuleConfiguration).findAny().map(each -> (EncryptRuleConfiguration) each);
+ Preconditions.checkState(toBeCreatedRuleConfig.isPresent());
if (null == currentRuleConfig) {
- ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdEncryptRuleConfiguration);
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(toBeCreatedRuleConfig.get());
} else {
- currentRuleConfig.getTables().addAll(createdEncryptRuleConfiguration.getTables());
- currentRuleConfig.getEncryptors().putAll(createdEncryptRuleConfiguration.getEncryptors());
+ currentRuleConfig.getTables().addAll(toBeCreatedRuleConfig.get().getTables());
+ currentRuleConfig.getEncryptors().putAll(toBeCreatedRuleConfig.get().getEncryptors());
}
return false;
}
- private Collection<String> getRuleNames(final EncryptRuleConfiguration encryptRuleConfig) {
- return encryptRuleConfig.getTables().stream().map(EncryptTableRuleConfiguration::getName).collect(Collectors.toList());
- }
-
@Override
public String getType() {
return CreateEncryptRuleStatement.class.getCanonicalName();
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateReadwriteSplittingRuleStatementUpdater.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateReadwriteSplittingRuleStatementUpdater.java
index 1d0f68a..464d9c1 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateReadwriteSplittingRuleStatementUpdater.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateReadwriteSplittingRuleStatementUpdater.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rdl.impl.updater;
+import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import org.apache.shardingsphere.infra.distsql.RDLUpdater;
import org.apache.shardingsphere.infra.metadata.resource.ShardingSphereResource;
@@ -32,12 +33,12 @@ import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingD
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 java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
+import java.util.Optional;
import java.util.Properties;
import java.util.stream.Collectors;
@@ -55,36 +56,28 @@ public final class CreateReadwriteSplittingRuleStatementUpdater implements RDLUp
public void checkSQLStatement(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement,
final ReadwriteSplittingRuleConfiguration currentRuleConfig, final ShardingSphereResource resource) {
checkDuplicateRuleNames(schemaName, sqlStatement, currentRuleConfig);
- checkResources(schemaName, sqlStatement, resource);
- checkLoadBalancers(sqlStatement);
+ checkToBeCreatedResources(schemaName, sqlStatement, resource);
+ checkToBeCreatedLoadBalancers(sqlStatement);
}
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());
+ Collection<String> currentRuleNames = currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ Collection<String> duplicateRuleNames = sqlStatement.getRules().stream().map(ReadwriteSplittingRuleSegment::getName).filter(currentRuleNames::contains).collect(Collectors.toList());
if (!duplicateRuleNames.isEmpty()) {
throw new DuplicateRuleNamesException(schemaName, duplicateRuleNames);
}
}
}
- private void checkResources(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement, final ShardingSphereResource resource) {
- Collection<String> notExistResources = resource.getNotExistedResources(getResources(sqlStatement));
+ private void checkToBeCreatedResources(final String schemaName, final CreateReadwriteSplittingRuleStatement sqlStatement, final ShardingSphereResource resource) {
+ Collection<String> notExistResources = resource.getNotExistedResources(getToBeCreatedResources(sqlStatement));
if (!notExistResources.isEmpty()) {
throw new ResourceNotExistedException(schemaName, notExistResources);
}
}
- private void checkLoadBalancers(final CreateReadwriteSplittingRuleStatement sqlStatement) {
- Collection<String> invalidLoadBalances = sqlStatement.getRules().stream().map(ReadwriteSplittingRuleSegment::getLoadBalancer).distinct()
- .filter(each -> !TypedSPIRegistry.findRegisteredService(ReplicaLoadBalanceAlgorithm.class, each, new Properties()).isPresent()).collect(Collectors.toList());
- if (!invalidLoadBalances.isEmpty()) {
- throw new InvalidLoadBalancersException(invalidLoadBalances);
- }
- }
-
- private Collection<String> getResources(final CreateReadwriteSplittingRuleStatement sqlStatement) {
+ private Collection<String> getToBeCreatedResources(final CreateReadwriteSplittingRuleStatement sqlStatement) {
Collection<String> result = new LinkedHashSet<>();
sqlStatement.getRules().stream().filter(each -> Strings.isNullOrEmpty(each.getAutoAwareResource())).forEach(each -> {
result.add(each.getWriteDataSource());
@@ -93,21 +86,25 @@ public final class CreateReadwriteSplittingRuleStatementUpdater implements RDLUp
return result;
}
- private Collection<String> getRuleNames(final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
- return currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ private void checkToBeCreatedLoadBalancers(final CreateReadwriteSplittingRuleStatement sqlStatement) {
+ Collection<String> notExistedLoadBalancers = sqlStatement.getRules().stream().map(ReadwriteSplittingRuleSegment::getLoadBalancer).distinct()
+ .filter(each -> !TypedSPIRegistry.findRegisteredService(ReplicaLoadBalanceAlgorithm.class, each, new Properties()).isPresent()).collect(Collectors.toList());
+ if (!notExistedLoadBalancers.isEmpty()) {
+ throw new InvalidLoadBalancersException(notExistedLoadBalancers);
+ }
}
@Override
public boolean updateCurrentRuleConfiguration(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> toBeCreatedRuleConfig = new YamlRuleConfigurationSwapperEngine()
+ .swapToRuleConfigurations(Collections.singleton(ReadwriteSplittingRuleStatementConverter.convert(sqlStatement)))
+ .stream().filter(each -> each instanceof ReadwriteSplittingRuleConfiguration).findAny().map(each -> (ReadwriteSplittingRuleConfiguration) each);
+ Preconditions.checkState(toBeCreatedRuleConfig.isPresent());
if (null == currentRuleConfig) {
- ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(createdReadwriteSplittingRuleConfig);
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(toBeCreatedRuleConfig.get());
} else {
- currentRuleConfig.getDataSources().addAll(createdReadwriteSplittingRuleConfig.getDataSources());
- currentRuleConfig.getLoadBalancers().putAll(createdReadwriteSplittingRuleConfig.getLoadBalancers());
+ currentRuleConfig.getDataSources().addAll(toBeCreatedRuleConfig.get().getDataSources());
+ currentRuleConfig.getLoadBalancers().putAll(toBeCreatedRuleConfig.get().getLoadBalancers());
}
return false;
}
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBindingTableRuleStatementUpdater.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBindingTableRuleStatementUpdater.java
index ed4fa4d..e2d57b8 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBindingTableRuleStatementUpdater.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBindingTableRuleStatementUpdater.java
@@ -27,7 +27,6 @@ import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleC
import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
import org.apache.shardingsphere.sharding.converter.ShardingRuleStatementConverter;
import org.apache.shardingsphere.sharding.distsql.parser.statement.CreateShardingBindingTableRulesStatement;
-import org.apache.shardingsphere.sharding.yaml.config.YamlShardingRuleConfiguration;
import java.util.Arrays;
import java.util.Collection;
@@ -42,24 +41,31 @@ public final class CreateShardingBindingTableRuleStatementUpdater implements RDL
@Override
public void checkSQLStatement(final String schemaName, final CreateShardingBindingTableRulesStatement sqlStatement,
final ShardingRuleConfiguration currentRuleConfig, final ShardingSphereResource resource) {
+ checkCurrentRuleConfiguration(schemaName, currentRuleConfig);
+ checkToBeCreatedBindingTables(schemaName, sqlStatement, currentRuleConfig);
+ checkToBeCreatedDuplicateBindingTables(sqlStatement, currentRuleConfig);
+ }
+
+ private void checkCurrentRuleConfiguration(final String schemaName, final ShardingRuleConfiguration currentRuleConfig) {
if (null == currentRuleConfig) {
throw new ShardingBindingTableRuleNotExistsException(schemaName);
}
- Collection<String> invalidBindingTables = new HashSet<>();
- Collection<String> existLogicTables = getLogicTables(currentRuleConfig);
- Collection<String> bindingTables = sqlStatement.getBindingTables();
- for (String each : bindingTables) {
- if (!existLogicTables.contains(each)) {
- invalidBindingTables.add(each);
+ }
+
+ private void checkToBeCreatedBindingTables(final String schemaName, final CreateShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ Collection<String> notExistedBindingTables = new HashSet<>();
+ Collection<String> currentLogicTables = getCurrentLogicTables(currentRuleConfig);
+ for (String each : sqlStatement.getBindingTables()) {
+ if (!currentLogicTables.contains(each)) {
+ notExistedBindingTables.add(each);
}
}
- if (!invalidBindingTables.isEmpty()) {
- throw new ShardingTableRuleNotExistedException(schemaName, invalidBindingTables);
+ if (!notExistedBindingTables.isEmpty()) {
+ throw new ShardingTableRuleNotExistedException(schemaName, notExistedBindingTables);
}
- checkToBeCreatedDuplicateBindingTables(sqlStatement, currentRuleConfig);
}
- private Collection<String> getLogicTables(final ShardingRuleConfiguration currentRuleConfig) {
+ private Collection<String> getCurrentLogicTables(final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> result = new HashSet<>();
result.addAll(currentRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
result.addAll(currentRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toSet()));
@@ -81,8 +87,7 @@ public final class CreateShardingBindingTableRuleStatementUpdater implements RDL
@Override
public boolean updateCurrentRuleConfiguration(final String schemaName, final CreateShardingBindingTableRulesStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- YamlShardingRuleConfiguration yamlShardingRuleConfiguration = ShardingRuleStatementConverter.convert(sqlStatement);
- currentRuleConfig.getBindingTableGroups().addAll(yamlShardingRuleConfiguration.getBindingTables());
+ currentRuleConfig.getBindingTableGroups().addAll(ShardingRuleStatementConverter.convert(sqlStatement).getBindingTables());
return false;
}
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBroadcastTableRuleStatementUpdater.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBroadcastTableRuleStatementUpdater.java
index 32be774..5e13667 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBroadcastTableRuleStatementUpdater.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingBroadcastTableRuleStatementUpdater.java
@@ -37,9 +37,9 @@ public final class CreateShardingBroadcastTableRuleStatementUpdater implements R
@Override
public boolean updateCurrentRuleConfiguration(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);
+ ShardingRuleConfiguration toBeCreatedRuleConfig = new ShardingRuleConfiguration();
+ toBeCreatedRuleConfig.setBroadcastTables(sqlStatement.getTables());
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(toBeCreatedRuleConfig);
} else {
if (!currentRuleConfig.getBroadcastTables().isEmpty()) {
throw new ShardingBroadcastTableRuleExistedException(schemaName);
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingTableRuleStatementUpdater.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingTableRuleStatementUpdater.java
index 444bbe3..bf75630 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingTableRuleStatementUpdater.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rdl/impl/updater/CreateShardingTableRuleStatementUpdater.java
@@ -61,46 +61,36 @@ public final class CreateShardingTableRuleStatementUpdater implements RDLUpdater
@Override
public void checkSQLStatement(final String schemaName, final CreateShardingTableRuleStatement sqlStatement,
final ShardingRuleConfiguration currentRuleConfig, final ShardingSphereResource resource) {
- Collection<String> notExistResources = resource.getNotExistedResources(getResources(sqlStatement));
- if (!notExistResources.isEmpty()) {
- throw new ResourceNotExistedException(schemaName, notExistResources);
+ checkToBeCreatedResource(schemaName, sqlStatement, resource);
+ checkDuplicateTables(schemaName, sqlStatement, currentRuleConfig);
+ checkToBeCreatedShardingAlgorithms(sqlStatement);
+ checkToBeCreatedKeyGenerators(sqlStatement);
+ }
+
+ private void checkToBeCreatedResource(final String schemaName, final CreateShardingTableRuleStatement sqlStatement, final ShardingSphereResource resource) {
+ Collection<String> notExistedResources = resource.getNotExistedResources(getToBeCreatedResources(sqlStatement));
+ if (!notExistedResources.isEmpty()) {
+ throw new ResourceNotExistedException(schemaName, notExistedResources);
}
- Collection<String> existLogicTables = getAllTables(schemaName, currentRuleConfig);
+ }
+
+ private Collection<String> getToBeCreatedResources(final CreateShardingTableRuleStatement sqlStatement) {
+ Collection<String> result = new LinkedHashSet<>();
+ sqlStatement.getRules().forEach(each -> result.addAll(each.getDataSources()));
+ return result;
+ }
+
+ private void checkDuplicateTables(final String schemaName, final CreateShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ Collection<String> allCurrentTableNames = getAllCurrentTableNames(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()));
+ duplicateTableNames.addAll(sqlStatement.getRules().stream().map(TableRuleSegment::getLogicTable).filter(allCurrentTableNames::contains).collect(Collectors.toSet()));
if (!duplicateTableNames.isEmpty()) {
throw new DuplicateTablesException(duplicateTableNames);
}
- Collection<String> invalidTableAlgorithms = sqlStatement.getRules().stream().map(each -> each.getTableStrategy().getName()).distinct()
- .filter(each -> !TypedSPIRegistry.findRegisteredService(ShardingAlgorithm.class, each, new Properties()).isPresent())
- .collect(Collectors.toList());
- if (!invalidTableAlgorithms.isEmpty()) {
- throw new InvalidShardingAlgorithmsException(invalidTableAlgorithms);
- }
- Collection<String> invalidKeyGenerators = getKeyGenerators(sqlStatement).stream()
- .filter(each -> !TypedSPIRegistry.findRegisteredService(KeyGenerateAlgorithm.class, each, new Properties()).isPresent())
- .collect(Collectors.toList());
- if (!invalidKeyGenerators.isEmpty()) {
- throw new InvalidKeyGeneratorsException(invalidKeyGenerators);
- }
- }
-
- @Override
- public boolean updateCurrentRuleConfiguration(final String schemaName, final CreateShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
- ShardingRuleConfiguration shardingRuleConfig = (ShardingRuleConfiguration) new YamlRuleConfigurationSwapperEngine()
- .swapToRuleConfigurations(Collections.singleton(ShardingRuleStatementConverter.convert(sqlStatement))).iterator().next();
- 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());
- }
- return false;
}
- private Collection<String> getAllTables(final String schemaName, final ShardingRuleConfiguration currentRuleConfig) {
+ private Collection<String> getAllCurrentTableNames(final String schemaName, final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> result = new HashSet<>(ProxyContext.getInstance().getMetaData(schemaName).getSchema().getAllTableNames());
if (null != currentRuleConfig) {
result.addAll(getShardingTables(currentRuleConfig));
@@ -115,17 +105,43 @@ public final class CreateShardingTableRuleStatementUpdater implements RDLUpdater
return result;
}
- private Collection<String> getResources(final CreateShardingTableRuleStatement sqlStatement) {
- Collection<String> result = new LinkedHashSet<>();
- sqlStatement.getRules().forEach(each -> result.addAll(each.getDataSources()));
- return result;
+ private void checkToBeCreatedShardingAlgorithms(final CreateShardingTableRuleStatement sqlStatement) {
+ Collection<String> notExistedShardingAlgorithms = sqlStatement.getRules().stream().map(each -> each.getTableStrategy().getName()).distinct()
+ .filter(each -> !TypedSPIRegistry.findRegisteredService(ShardingAlgorithm.class, each, new Properties()).isPresent())
+ .collect(Collectors.toList());
+ if (!notExistedShardingAlgorithms.isEmpty()) {
+ throw new InvalidShardingAlgorithmsException(notExistedShardingAlgorithms);
+ }
+ }
+
+ private void checkToBeCreatedKeyGenerators(final CreateShardingTableRuleStatement sqlStatement) {
+ Collection<String> invalidKeyGenerators = getToBeCreatedKeyGenerators(sqlStatement).stream().distinct()
+ .filter(each -> !TypedSPIRegistry.findRegisteredService(KeyGenerateAlgorithm.class, each, new Properties()).isPresent())
+ .collect(Collectors.toList());
+ if (!invalidKeyGenerators.isEmpty()) {
+ throw new InvalidKeyGeneratorsException(invalidKeyGenerators);
+ }
}
- private Collection<String> getKeyGenerators(final CreateShardingTableRuleStatement sqlStatement) {
+ private Collection<String> getToBeCreatedKeyGenerators(final CreateShardingTableRuleStatement sqlStatement) {
return sqlStatement.getRules().stream().filter(each -> Objects.nonNull(each.getKeyGenerateStrategy())).map(each -> each.getKeyGenerateStrategy().getName()).collect(Collectors.toSet());
}
@Override
+ public boolean updateCurrentRuleConfiguration(final String schemaName, final CreateShardingTableRuleStatement sqlStatement, final ShardingRuleConfiguration currentRuleConfig) {
+ ShardingRuleConfiguration toBeCreatedRuleConfig = (ShardingRuleConfiguration) new YamlRuleConfigurationSwapperEngine()
+ .swapToRuleConfigurations(Collections.singleton(ShardingRuleStatementConverter.convert(sqlStatement))).iterator().next();
+ if (null == currentRuleConfig) {
+ ProxyContext.getInstance().getMetaData(schemaName).getRuleMetaData().getConfigurations().add(toBeCreatedRuleConfig);
+ } else {
+ currentRuleConfig.getAutoTables().addAll(toBeCreatedRuleConfig.getAutoTables());
+ currentRuleConfig.getShardingAlgorithms().putAll(toBeCreatedRuleConfig.getShardingAlgorithms());
+ currentRuleConfig.getKeyGenerators().putAll(toBeCreatedRuleConfig.getKeyGenerators());
+ }
+ return false;
+ }
+
+ @Override
public String getType() {
return CreateShardingTableRuleStatement.class.getCanonicalName();
}