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 <[email protected]>
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
