You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by ch...@apache.org on 2024/03/07 03:49:35 UTC
(shardingsphere) branch master updated: Refactor YamlDatabaseConfigurationImportExecutor (#30416)
This is an automated email from the ASF dual-hosted git repository.
chenjiahao 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 cfe2fb7f857 Refactor YamlDatabaseConfigurationImportExecutor (#30416)
cfe2fb7f857 is described below
commit cfe2fb7f857a11da96504e9e3e1caa29c7833ba8
Author: Raigor <ra...@gmail.com>
AuthorDate: Thu Mar 7 11:49:28 2024 +0800
Refactor YamlDatabaseConfigurationImportExecutor (#30416)
* Refactor YamlDatabaseConfigurationImportExecutor
* Refactor ReadwriteSplittingImportRuleConfigurationProvider
* Remove null check in addRule
---
...teSplittingImportRuleConfigurationProvider.java | 22 ++++++--
.../ShardingImportRuleConfigurationProvider.java | 34 +++++------
...tion.java => MissingDatabaseNameException.java} | 12 ++--
.../exception/UnsupportedVariableException.java | 2 +-
.../YamlDatabaseConfigurationImportExecutor.java | 66 ++++++++++------------
.../ImportDatabaseConfigurationExecutorTest.java | 3 +-
6 files changed, 72 insertions(+), 67 deletions(-)
diff --git a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingImportRuleConfigurationProvider.java b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingImportRuleConfigurationProvider.java
index c21e016a268..57d0f241604 100644
--- a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingImportRuleConfigurationProvider.java
+++ b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingImportRuleConfigurationProvider.java
@@ -24,14 +24,18 @@ import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.identifier.scope.DatabaseRule;
+import org.apache.shardingsphere.infra.rule.identifier.type.datasource.DataSourceMapperRule;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
import java.util.Collection;
+import java.util.HashSet;
import java.util.LinkedHashSet;
+import java.util.Optional;
/**
* Readwrite-splitting import rule configuration provider.
@@ -44,8 +48,7 @@ public final class ReadwriteSplittingImportRuleConfigurationProvider implements
return;
}
ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfig = (ReadwriteSplittingRuleConfiguration) ruleConfig;
- String databaseName = database.getName();
- checkDataSources(databaseName, database, readwriteSplittingRuleConfig);
+ checkDataSources(database, readwriteSplittingRuleConfig);
checkLoadBalancers(readwriteSplittingRuleConfig);
}
@@ -54,7 +57,7 @@ public final class ReadwriteSplittingImportRuleConfigurationProvider implements
return new ReadwriteSplittingRule(database.getName(), (ReadwriteSplittingRuleConfiguration) ruleConfig, instanceContext);
}
- private void checkDataSources(final String databaseName, final ShardingSphereDatabase database, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
+ private void checkDataSources(final ShardingSphereDatabase database, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
Collection<String> requiredDataSources = new LinkedHashSet<>();
for (ReadwriteSplittingDataSourceRuleConfiguration each : currentRuleConfig.getDataSources()) {
if (null != each.getWriteDataSourceName()) {
@@ -65,7 +68,18 @@ public final class ReadwriteSplittingImportRuleConfigurationProvider implements
}
}
Collection<String> notExistedDataSources = database.getResourceMetaData().getNotExistedDataSources(requiredDataSources);
- ShardingSpherePreconditions.checkState(notExistedDataSources.isEmpty(), () -> new MissingRequiredStorageUnitsException(databaseName, notExistedDataSources));
+ Collection<String> logicalDataSources = getLogicDataSources(database);
+ notExistedDataSources.removeIf(logicalDataSources::contains);
+ ShardingSpherePreconditions.checkState(notExistedDataSources.isEmpty(), () -> new MissingRequiredStorageUnitsException(database.getName(), notExistedDataSources));
+ }
+
+ private Collection<String> getLogicDataSources(final ShardingSphereDatabase database) {
+ Collection<String> result = new HashSet<>();
+ for (ShardingSphereRule each : database.getRuleMetaData().getRules()) {
+ Optional<DataSourceMapperRule> dataSourceMapperRule = each.getRuleIdentifiers().findIdentifier(DataSourceMapperRule.class);
+ dataSourceMapperRule.ifPresent(optional -> result.addAll(optional.getDataSourceMapper().keySet()));
+ }
+ return result;
}
private void checkLoadBalancers(final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
diff --git a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/provider/ShardingImportRuleConfigurationProvider.java b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/provider/ShardingImportRuleConfigurationProvider.java
index 9506a5738c4..33447b9b3c3 100644
--- a/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/provider/ShardingImportRuleConfigurationProvider.java
+++ b/features/sharding/distsql/handler/src/main/java/org/apache/shardingsphere/sharding/distsql/handler/provider/ShardingImportRuleConfigurationProvider.java
@@ -43,7 +43,6 @@ import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
-import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
@@ -61,41 +60,36 @@ public final class ShardingImportRuleConfigurationProvider implements ImportRule
return;
}
ShardingRuleConfiguration shardingRuleConfig = (ShardingRuleConfiguration) ruleConfig;
- String databaseName = database.getName();
- checkLogicTables(databaseName, shardingRuleConfig);
- checkResources(databaseName, database, shardingRuleConfig);
+ checkLogicTables(database.getName(), shardingRuleConfig);
+ checkDataSources(database, shardingRuleConfig);
checkShardingAlgorithms(shardingRuleConfig.getShardingAlgorithms().values());
checkKeyGeneratorAlgorithms(shardingRuleConfig.getKeyGenerators().values());
}
@Override
public DatabaseRule build(final ShardingSphereDatabase database, final RuleConfiguration ruleConfig, final InstanceContext instanceContext) {
- ShardingRuleConfiguration shardingRuleConfig = (ShardingRuleConfiguration) ruleConfig;
Map<String, DataSource> dataSources = database.getResourceMetaData().getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, storageUnit -> storageUnit.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new));
- return new ShardingRule(shardingRuleConfig, dataSources, instanceContext);
+ return new ShardingRule((ShardingRuleConfiguration) ruleConfig, dataSources, instanceContext);
}
private void checkLogicTables(final String databaseName, final ShardingRuleConfiguration currentRuleConfig) {
- Collection<String> tablesLogicTables = currentRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toList());
- Collection<String> autoTablesLogicTables = currentRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toList());
- Collection<String> allLogicTables = new LinkedList<>();
- allLogicTables.addAll(tablesLogicTables);
- allLogicTables.addAll(autoTablesLogicTables);
- Set<String> duplicatedLogicTables = allLogicTables.stream().collect(Collectors.groupingBy(each -> each, Collectors.counting())).entrySet().stream()
+ Collection<String> logicTables = currentRuleConfig.getTables().stream().map(ShardingTableRuleConfiguration::getLogicTable).collect(Collectors.toList());
+ logicTables.addAll(currentRuleConfig.getAutoTables().stream().map(ShardingAutoTableRuleConfiguration::getLogicTable).collect(Collectors.toList()));
+ Set<String> duplicatedLogicTables = logicTables.stream().collect(Collectors.groupingBy(each -> each, Collectors.counting())).entrySet().stream()
.filter(each -> each.getValue() > 1).map(Entry::getKey).collect(Collectors.toSet());
ShardingSpherePreconditions.checkState(duplicatedLogicTables.isEmpty(), () -> new DuplicateRuleException("sharding", databaseName, duplicatedLogicTables));
}
- private void checkResources(final String databaseName, final ShardingSphereDatabase database, final ShardingRuleConfiguration currentRuleConfig) {
- Collection<String> requiredResource = getRequiredResources(currentRuleConfig);
- Collection<String> notExistedResources = database.getResourceMetaData().getNotExistedDataSources(requiredResource);
- Collection<String> logicResources = getLogicResources(database);
- notExistedResources.removeIf(logicResources::contains);
- ShardingSpherePreconditions.checkState(notExistedResources.isEmpty(), () -> new MissingRequiredStorageUnitsException(databaseName, notExistedResources));
+ private void checkDataSources(final ShardingSphereDatabase database, final ShardingRuleConfiguration currentRuleConfig) {
+ Collection<String> requiredDataSources = getRequiredDataSources(currentRuleConfig);
+ Collection<String> notExistedDataSources = database.getResourceMetaData().getNotExistedDataSources(requiredDataSources);
+ Collection<String> logicDataSources = getLogicDataSources(database);
+ notExistedDataSources.removeIf(logicDataSources::contains);
+ ShardingSpherePreconditions.checkState(notExistedDataSources.isEmpty(), () -> new MissingRequiredStorageUnitsException(database.getName(), notExistedDataSources));
}
- private Collection<String> getRequiredResources(final ShardingRuleConfiguration currentRuleConfig) {
+ private Collection<String> getRequiredDataSources(final ShardingRuleConfiguration currentRuleConfig) {
Collection<String> result = new LinkedHashSet<>();
currentRuleConfig.getTables().forEach(each -> result.addAll(getDataSourceNames(each)));
currentRuleConfig.getAutoTables().forEach(each -> result.addAll(getDataSourceNames(each)));
@@ -112,7 +106,7 @@ public final class ShardingImportRuleConfigurationProvider implements ImportRule
return actualDataNodes.stream().map(each -> new DataNode(each).getDataSourceName()).collect(Collectors.toList());
}
- private Collection<String> getLogicResources(final ShardingSphereDatabase database) {
+ private Collection<String> getLogicDataSources(final ShardingSphereDatabase database) {
Collection<String> result = new LinkedHashSet<>();
for (ShardingSphereRule each : database.getRuleMetaData().getRules()) {
each.getRuleIdentifiers().findIdentifier(DataSourceMapperRule.class).ifPresent(optional -> result.addAll(optional.getDataSourceMapper().keySet()));
diff --git a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/UnsupportedVariableException.java b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/MissingDatabaseNameException.java
similarity index 73%
copy from proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/UnsupportedVariableException.java
copy to proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/MissingDatabaseNameException.java
index aefb749acfa..7f40db6a149 100644
--- a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/UnsupportedVariableException.java
+++ b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/MissingDatabaseNameException.java
@@ -17,17 +17,17 @@
package org.apache.shardingsphere.proxy.backend.exception;
-import org.apache.shardingsphere.infra.exception.core.external.sql.type.kernel.category.SyntaxSQLException;
import org.apache.shardingsphere.infra.exception.core.external.sql.sqlstate.XOpenSQLState;
+import org.apache.shardingsphere.infra.exception.core.external.sql.type.kernel.category.DistSQLException;
/**
- * Unsupported variable exception.
+ * Missing database name exception.
*/
-public final class UnsupportedVariableException extends SyntaxSQLException {
+public final class MissingDatabaseNameException extends DistSQLException {
- private static final long serialVersionUID = 1955281568807066737L;
+ private static final long serialVersionUID = -1248634756191801109L;
- public UnsupportedVariableException(final String variable) {
- super(XOpenSQLState.SYNTAX_ERROR, 10, "Can not support variable `%s`.", variable);
+ public MissingDatabaseNameException() {
+ super(XOpenSQLState.CHECK_OPTION_VIOLATION, 8, "Missing required property `databaseName`.");
}
}
diff --git a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/UnsupportedVariableException.java b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/UnsupportedVariableException.java
index aefb749acfa..2daaa77e2b9 100644
--- a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/UnsupportedVariableException.java
+++ b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/exception/UnsupportedVariableException.java
@@ -28,6 +28,6 @@ public final class UnsupportedVariableException extends SyntaxSQLException {
private static final long serialVersionUID = 1955281568807066737L;
public UnsupportedVariableException(final String variable) {
- super(XOpenSQLState.SYNTAX_ERROR, 10, "Can not support variable `%s`.", variable);
+ super(XOpenSQLState.CHECK_OPTION_VIOLATION, 14, "Can not support variable `%s`.", variable);
}
}
diff --git a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
index 5d9352320c7..a662289c03a 100644
--- a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
+++ b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
@@ -50,6 +50,7 @@ import org.apache.shardingsphere.proxy.backend.config.yaml.YamlProxyDataSourceCo
import org.apache.shardingsphere.proxy.backend.config.yaml.YamlProxyDatabaseConfiguration;
import org.apache.shardingsphere.proxy.backend.config.yaml.swapper.YamlProxyDataSourceConfigurationSwapper;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
+import org.apache.shardingsphere.proxy.backend.exception.MissingDatabaseNameException;
import org.apache.shardingsphere.proxy.backend.handler.distsql.ral.common.checker.MaskRuleConfigurationImportChecker;
import org.apache.shardingsphere.proxy.backend.handler.distsql.ral.common.checker.ShadowRuleConfigurationImportChecker;
import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
@@ -89,9 +90,9 @@ public final class YamlDatabaseConfigurationImportExecutor {
public void importDatabaseConfiguration(final YamlProxyDatabaseConfiguration yamlConfig) {
String databaseName = yamlConfig.getDatabaseName();
checkDatabase(databaseName);
- checkDataSource(yamlConfig.getDataSources());
+ checkDataSources(yamlConfig.getDataSources());
addDatabase(databaseName);
- addResources(databaseName, yamlConfig.getDataSources());
+ addDataSources(databaseName, yamlConfig.getDataSources());
try {
addRules(databaseName, yamlConfig.getRules());
} catch (final DistSQLException ex) {
@@ -101,14 +102,14 @@ public final class YamlDatabaseConfigurationImportExecutor {
}
private void checkDatabase(final String databaseName) {
- ShardingSpherePreconditions.checkNotNull(databaseName, () -> new UnsupportedSQLOperationException("Property `databaseName` in imported config is required"));
+ ShardingSpherePreconditions.checkNotNull(databaseName, MissingDatabaseNameException::new);
if (ProxyContext.getInstance().databaseExists(databaseName)) {
ShardingSpherePreconditions.checkState(ProxyContext.getInstance().getContextManager().getDatabase(databaseName).getResourceMetaData().getStorageUnits().isEmpty(),
() -> new UnsupportedSQLOperationException(String.format("Database `%s` exists and is not empty，overwrite is not supported", databaseName)));
}
}
- private void checkDataSource(final Map<String, YamlProxyDataSourceConfiguration> dataSources) {
+ private void checkDataSources(final Map<String, YamlProxyDataSourceConfiguration> dataSources) {
ShardingSpherePreconditions.checkState(!dataSources.isEmpty(), () -> new MissingRequiredDataSourcesException("Data source configurations in imported config is required"));
}
@@ -119,7 +120,7 @@ public final class YamlDatabaseConfigurationImportExecutor {
contextManager.getMetaDataContexts().getMetaData().addDatabase(databaseName, protocolType, contextManager.getMetaDataContexts().getMetaData().getProps());
}
- private void addResources(final String databaseName, final Map<String, YamlProxyDataSourceConfiguration> yamlDataSourceMap) {
+ private void addDataSources(final String databaseName, final Map<String, YamlProxyDataSourceConfiguration> yamlDataSourceMap) {
Map<String, DataSourcePoolProperties> propsMap = new LinkedHashMap<>(yamlDataSourceMap.size(), 1F);
for (Entry<String, YamlProxyDataSourceConfiguration> entry : yamlDataSourceMap.entrySet()) {
DataSourceConfiguration dataSourceConfig = dataSourceConfigSwapper.swap(entry.getValue());
@@ -143,43 +144,38 @@ public final class YamlDatabaseConfigurationImportExecutor {
if (null == yamlRuleConfigs || yamlRuleConfigs.isEmpty()) {
return;
}
- Collection<RuleConfiguration> allRuleConfigs = new LinkedList<>();
+ Collection<RuleConfiguration> ruleConfigs = new LinkedList<>();
MetaDataContexts metaDataContexts = ProxyContext.getInstance().getContextManager().getMetaDataContexts();
ShardingSphereDatabase database = metaDataContexts.getMetaData().getDatabase(databaseName);
- swapToRuleConfigs(yamlRuleConfigs).values().forEach(each -> addRules(allRuleConfigs, each, database));
- metaDataContexts.getPersistService().getDatabaseRulePersistService().persist(metaDataContexts.getMetaData().getDatabase(databaseName).getName(), allRuleConfigs);
+ swapToRuleConfigs(yamlRuleConfigs).values().forEach(each -> addRule(ruleConfigs, each, database));
+ metaDataContexts.getPersistService().getDatabaseRulePersistService().persist(metaDataContexts.getMetaData().getDatabase(databaseName).getName(), ruleConfigs);
}
- private void addRules(final Collection<RuleConfiguration> allRuleConfigs, final Collection<RuleConfiguration> ruleConfigs, final ShardingSphereDatabase database) {
- RuleConfiguration ruleConfig = ruleConfigs.stream().findFirst().orElse(null);
- if (null == ruleConfig) {
- return;
- }
+ private void addRule(final Collection<RuleConfiguration> ruleConfigs, final RuleConfiguration ruleConfig, final ShardingSphereDatabase database) {
InstanceContext instanceContext = ProxyContext.getInstance().getContextManager().getInstanceContext();
if (ruleConfig instanceof ShadowRuleConfiguration) {
- ruleConfigs.forEach(each -> addShadowRuleConfiguration((ShadowRuleConfiguration) each, allRuleConfigs, database));
+ addShadowRuleConfiguration((ShadowRuleConfiguration) ruleConfig, ruleConfigs, database);
} else if (ruleConfig instanceof MaskRuleConfiguration) {
- ruleConfigs.forEach(each -> addMaskRuleConfiguration((MaskRuleConfiguration) each, allRuleConfigs, database));
+ addMaskRuleConfiguration((MaskRuleConfiguration) ruleConfig, ruleConfigs, database);
} else if (ruleConfig instanceof BroadcastRuleConfiguration) {
- ruleConfigs.forEach(each -> addBroadcastRuleConfiguration((BroadcastRuleConfiguration) each, allRuleConfigs, database));
+ addBroadcastRuleConfiguration((BroadcastRuleConfiguration) ruleConfig, ruleConfigs, database);
} else if (ruleConfig instanceof SingleRuleConfiguration) {
- ruleConfigs.forEach(each -> addSingleRuleConfiguration((SingleRuleConfiguration) each, allRuleConfigs, database));
+ addSingleRuleConfiguration((SingleRuleConfiguration) ruleConfig, ruleConfigs, database);
} else {
- ImportRuleConfigurationProvider importRuleConfigurationProvider = TypedSPILoader.getService(ImportRuleConfigurationProvider.class, ruleConfig.getClass());
- importRuleConfigurationProvider.check(database, ruleConfig);
- allRuleConfigs.add(ruleConfig);
- database.getRuleMetaData().getRules().add(importRuleConfigurationProvider.build(database, ruleConfig, instanceContext));
+ ImportRuleConfigurationProvider provider = TypedSPILoader.getService(ImportRuleConfigurationProvider.class, ruleConfig.getClass());
+ provider.check(database, ruleConfig);
+ ruleConfigs.add(ruleConfig);
+ database.getRuleMetaData().getRules().add(provider.build(database, ruleConfig, instanceContext));
}
}
@SuppressWarnings({"rawtypes", "unchecked"})
- private Map<Integer, Collection<RuleConfiguration>> swapToRuleConfigs(final Collection<YamlRuleConfiguration> yamlRuleConfigs) {
- Map<Integer, Collection<RuleConfiguration>> result = new TreeMap<>(Comparator.reverseOrder());
+ private Map<Integer, RuleConfiguration> swapToRuleConfigs(final Collection<YamlRuleConfiguration> yamlRuleConfigs) {
+ Map<Integer, RuleConfiguration> result = new TreeMap<>(Comparator.reverseOrder());
for (YamlRuleConfiguration each : yamlRuleConfigs) {
YamlRuleConfigurationSwapper swapper = OrderedSPILoader.getServicesByClass(YamlRuleConfigurationSwapper.class, Collections.singleton(each.getRuleConfigurationType()))
.get(each.getRuleConfigurationType());
- result.computeIfAbsent(swapper.getOrder(), key -> new LinkedList<>());
- result.get(swapper.getOrder()).add((RuleConfiguration) swapper.swapToObject(each));
+ result.put(swapper.getOrder(), (RuleConfiguration) swapper.swapToObject(each));
}
return result;
}
@@ -190,24 +186,24 @@ public final class YamlDatabaseConfigurationImportExecutor {
database.getRuleMetaData().getRules().add(new ShadowRule(shadowRuleConfig));
}
- private void addMaskRuleConfiguration(final MaskRuleConfiguration maskRuleConfig, final Collection<RuleConfiguration> allRuleConfigs, final ShardingSphereDatabase database) {
- maskRuleConfigImportChecker.check(database, maskRuleConfig);
- allRuleConfigs.add(maskRuleConfig);
- database.getRuleMetaData().getRules().add(new MaskRule(maskRuleConfig));
+ private void addMaskRuleConfiguration(final MaskRuleConfiguration ruleConfig, final Collection<RuleConfiguration> ruleConfigs, final ShardingSphereDatabase database) {
+ maskRuleConfigImportChecker.check(database, ruleConfig);
+ ruleConfigs.add(ruleConfig);
+ database.getRuleMetaData().getRules().add(new MaskRule(ruleConfig));
}
- private void addBroadcastRuleConfiguration(final BroadcastRuleConfiguration broadcastRuleConfig, final Collection<RuleConfiguration> allRuleConfigs, final ShardingSphereDatabase database) {
- allRuleConfigs.add(broadcastRuleConfig);
- database.getRuleMetaData().getRules().add(new BroadcastRule(broadcastRuleConfig, database.getName(),
+ private void addBroadcastRuleConfiguration(final BroadcastRuleConfiguration ruleConfig, final Collection<RuleConfiguration> ruleConfigs, final ShardingSphereDatabase database) {
+ ruleConfigs.add(ruleConfig);
+ database.getRuleMetaData().getRules().add(new BroadcastRule(ruleConfig, database.getName(),
database.getResourceMetaData().getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new)),
database.getRuleMetaData().getRules()));
}
- private void addSingleRuleConfiguration(final SingleRuleConfiguration singleRuleConfig, final Collection<RuleConfiguration> allRuleConfigs, final ShardingSphereDatabase database) {
- allRuleConfigs.add(singleRuleConfig);
+ private void addSingleRuleConfiguration(final SingleRuleConfiguration ruleConfig, final Collection<RuleConfiguration> ruleConfigs, final ShardingSphereDatabase database) {
+ ruleConfigs.add(ruleConfig);
database.getRuleMetaData().getRules().add(
- new SingleRule(singleRuleConfig, database.getName(), database.getProtocolType(),
+ new SingleRule(ruleConfig, database.getName(), database.getProtocolType(),
database.getResourceMetaData().getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new)),
database.getRuleMetaData().getRules()));
diff --git a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportDatabaseConfigurationExecutorTest.java b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportDatabaseConfigurationExecutorTest.java
index 4cb2bd7ee80..6858fbd4ec9 100644
--- a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportDatabaseConfigurationExecutorTest.java
+++ b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/ImportDatabaseConfigurationExecutorTest.java
@@ -37,6 +37,7 @@ import org.apache.shardingsphere.infra.spi.exception.ServiceProviderNotFoundExce
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
+import org.apache.shardingsphere.proxy.backend.exception.MissingDatabaseNameException;
import org.apache.shardingsphere.proxy.backend.util.YamlDatabaseConfigurationImportExecutor;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDriver;
import org.apache.shardingsphere.test.mock.AutoMockExtension;
@@ -104,7 +105,7 @@ class ImportDatabaseConfigurationExecutorTest {
@Test
void assertImportEmptyDatabaseName() {
- assertThrows(UnsupportedSQLOperationException.class, () -> assertExecute("sharding_db", "/conf/import/database-empty-database-name.yaml"));
+ assertThrows(MissingDatabaseNameException.class, () -> assertExecute("sharding_db", "/conf/import/database-empty-database-name.yaml"));
}
@Test