You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by ji...@apache.org on 2023/01/05 17:10:52 UTC
[shardingsphere] branch master updated: Refactor ifNotExists of DB_DISCOVERY RULE. (#23363)
This is an automated email from the ASF dual-hosted git repository.
jianglongtao 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 f44a4995b44 Refactor ifNotExists of DB_DISCOVERY RULE. (#23363)
f44a4995b44 is described below
commit f44a4995b442e86fc2f8e989bbf5bbc28c9b4a9e
Author: yx9o <ya...@163.com>
AuthorDate: Fri Jan 6 01:10:44 2023 +0800
Refactor ifNotExists of DB_DISCOVERY RULE. (#23363)
---
...reateDatabaseDiscoveryRuleStatementUpdater.java | 99 +++++++++-------------
...eDatabaseDiscoveryRuleStatementUpdaterTest.java | 31 ++++---
2 files changed, 59 insertions(+), 71 deletions(-)
diff --git a/features/db-discovery/distsql/handler/src/main/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdater.java b/features/db-discovery/distsql/handler/src/main/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdater.java
index 372e82a1919..76259fcbab9 100644
--- a/features/db-discovery/distsql/handler/src/main/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdater.java
+++ b/features/db-discovery/distsql/handler/src/main/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdater.java
@@ -36,7 +36,6 @@ import org.apache.shardingsphere.infra.util.spi.type.typed.TypedSPIRegistry;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
-import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
@@ -47,41 +46,63 @@ import java.util.stream.Collectors;
*/
public final class CreateDatabaseDiscoveryRuleStatementUpdater implements RuleDefinitionCreateUpdater<CreateDatabaseDiscoveryRuleStatement, DatabaseDiscoveryRuleConfiguration> {
- private static final String RULE_TYPE = "Database discovery";
-
- private boolean ifNotExists;
-
@Override
public void checkSQLStatement(final ShardingSphereDatabase database, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
String databaseName = database.getName();
- ifNotExists = sqlStatement.isIfNotExists();
- if (!ifNotExists) {
- checkDuplicateRuleNames(databaseName, sqlStatement, currentRuleConfig);
- }
+ checkDuplicatedRuleNames(databaseName, sqlStatement, currentRuleConfig);
checkResources(databaseName, sqlStatement, database.getResourceMetaData());
checkDiscoverTypeAndHeartbeat(sqlStatement);
}
- private void checkDuplicateRuleNames(final String databaseName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
- if (null == currentRuleConfig) {
- return;
+ @Override
+ public DatabaseDiscoveryRuleConfiguration buildToBeCreatedRuleConfiguration(final DatabaseDiscoveryRuleConfiguration currentRuleConfig, final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
+ Collection<AbstractDatabaseDiscoverySegment> segments = sqlStatement.getRules();
+ if (sqlStatement.isIfNotExists()) {
+ Collection<String> duplicatedRuleNames = getDuplicatedRuleNames(sqlStatement, currentRuleConfig);
+ segments.removeIf(each -> duplicatedRuleNames.contains(each.getName()));
+ }
+ return DatabaseDiscoveryRuleStatementConverter.convert(segments);
+ }
+
+ @Override
+ public void updateCurrentRuleConfiguration(final DatabaseDiscoveryRuleConfiguration currentRuleConfig, final DatabaseDiscoveryRuleConfiguration toBeCreatedRuleConfig) {
+ currentRuleConfig.getDataSources().addAll(toBeCreatedRuleConfig.getDataSources());
+ currentRuleConfig.getDiscoveryTypes().putAll(toBeCreatedRuleConfig.getDiscoveryTypes());
+ currentRuleConfig.getDiscoveryHeartbeats().putAll(toBeCreatedRuleConfig.getDiscoveryHeartbeats());
+ }
+
+ private void checkDuplicatedRuleNames(final String databaseName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ checkDuplicatedRuleNamesWithSelf(databaseName, sqlStatement);
+ if (!sqlStatement.isIfNotExists()) {
+ checkDuplicatedRuleNamesWithRuleConfiguration(databaseName, sqlStatement, currentRuleConfig);
}
- Collection<String> existRuleNames = currentRuleConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getGroupName).collect(Collectors.toList());
- Collection<String> duplicateRuleNames = sqlStatement.getRules().stream().map(AbstractDatabaseDiscoverySegment::getName).filter(existRuleNames::contains).collect(Collectors.toSet());
- duplicateRuleNames.addAll(getToBeCreatedDuplicateRuleNames(sqlStatement));
- ShardingSpherePreconditions.checkState(duplicateRuleNames.isEmpty(), () -> new DuplicateRuleException(RULE_TYPE.toLowerCase(), databaseName, duplicateRuleNames));
}
- private Collection<String> getToBeCreatedDuplicateRuleNames(final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
- return sqlStatement.getRules().stream().collect(Collectors.toMap(AbstractDatabaseDiscoverySegment::getName, each -> 1, Integer::sum))
+ private void checkDuplicatedRuleNamesWithSelf(final String databaseName, final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
+ Collection<String> duplicatedRuleNames = sqlStatement.getRules().stream().collect(Collectors.toMap(AbstractDatabaseDiscoverySegment::getName, each -> 1, Integer::sum))
.entrySet().stream().filter(entry -> entry.getValue() > 1).map(Entry::getKey).collect(Collectors.toSet());
+ ShardingSpherePreconditions.checkState(duplicatedRuleNames.isEmpty(), () -> new DuplicateRuleException("database discovery", databaseName, duplicatedRuleNames));
+ }
+
+ private void checkDuplicatedRuleNamesWithRuleConfiguration(final String databaseName, final CreateDatabaseDiscoveryRuleStatement sqlStatement,
+ final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ Collection<String> duplicatedRuleNames = getDuplicatedRuleNames(sqlStatement, currentRuleConfig);
+ ShardingSpherePreconditions.checkState(duplicatedRuleNames.isEmpty(), () -> new DuplicateRuleException("database discovery", databaseName, duplicatedRuleNames));
+ }
+
+ private Collection<String> getDuplicatedRuleNames(final CreateDatabaseDiscoveryRuleStatement sqlStatement, final DatabaseDiscoveryRuleConfiguration currentRuleConfig) {
+ Collection<String> currentRuleNames = new LinkedHashSet<>();
+ if (null != currentRuleConfig) {
+ currentRuleNames = currentRuleConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getGroupName).collect(Collectors.toSet());
+ }
+ return sqlStatement.getRules().stream().map(AbstractDatabaseDiscoverySegment::getName).filter(currentRuleNames::contains).collect(Collectors.toSet());
}
private void checkResources(final String databaseName, final CreateDatabaseDiscoveryRuleStatement sqlStatement, final ShardingSphereResourceMetaData resourceMetaData) {
Collection<String> resources = new LinkedHashSet<>();
sqlStatement.getRules().forEach(each -> resources.addAll(each.getDataSources()));
- Collection<String> notExistResources = resourceMetaData.getNotExistedResources(resources);
- ShardingSpherePreconditions.checkState(notExistResources.isEmpty(), () -> new MissingRequiredStorageUnitsException(databaseName, notExistResources));
+ Collection<String> notExistedResources = resourceMetaData.getNotExistedResources(resources);
+ ShardingSpherePreconditions.checkState(notExistedResources.isEmpty(), () -> new MissingRequiredStorageUnitsException(databaseName, notExistedResources));
}
private void checkDiscoverTypeAndHeartbeat(final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
@@ -89,43 +110,7 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdater implements RuleDe
Collection<String> invalidInput = segmentMap.getOrDefault(DatabaseDiscoveryDefinitionSegment.class.getSimpleName(), Collections.emptyList()).stream()
.map(each -> ((DatabaseDiscoveryDefinitionSegment) each).getDiscoveryType().getName()).distinct()
.filter(each -> !TypedSPIRegistry.findRegisteredService(DatabaseDiscoveryProviderAlgorithm.class, each).isPresent()).collect(Collectors.toList());
- ShardingSpherePreconditions.checkState(invalidInput.isEmpty(), () -> new InvalidAlgorithmConfigurationException(RULE_TYPE.toLowerCase(), invalidInput));
- }
-
- @Override
- public DatabaseDiscoveryRuleConfiguration buildToBeCreatedRuleConfiguration(final DatabaseDiscoveryRuleConfiguration currentRuleConfig, final CreateDatabaseDiscoveryRuleStatement sqlStatement) {
- return DatabaseDiscoveryRuleStatementConverter.convert(sqlStatement.getRules());
- }
-
- @Override
- public void updateCurrentRuleConfiguration(final DatabaseDiscoveryRuleConfiguration currentRuleConfig, final DatabaseDiscoveryRuleConfiguration toBeCreatedRuleConfig) {
- if (ifNotExists) {
- removeDuplicatedRules(currentRuleConfig, toBeCreatedRuleConfig);
- }
- if (toBeCreatedRuleConfig.getDataSources().isEmpty()) {
- return;
- }
- currentRuleConfig.getDataSources().addAll(toBeCreatedRuleConfig.getDataSources());
- currentRuleConfig.getDiscoveryTypes().putAll(toBeCreatedRuleConfig.getDiscoveryTypes());
- currentRuleConfig.getDiscoveryHeartbeats().putAll(toBeCreatedRuleConfig.getDiscoveryHeartbeats());
- }
-
- private void removeDuplicatedRules(final DatabaseDiscoveryRuleConfiguration currentRuleConfig, final DatabaseDiscoveryRuleConfiguration toBeCreatedRuleConfig) {
- Collection<String> currentRules = new LinkedList<>();
- Collection<String> toBeRemovedDataSources = new LinkedList<>();
- Collection<String> toBeRemovedHeartBeats = new LinkedList<>();
- Collection<String> toBeRemovedTypes = new LinkedList<>();
- currentRuleConfig.getDataSources().forEach(each -> currentRules.add(each.getGroupName()));
- toBeCreatedRuleConfig.getDataSources().forEach(each -> {
- if (currentRules.contains(each.getGroupName())) {
- toBeRemovedHeartBeats.add(each.getDiscoveryHeartbeatName());
- toBeRemovedTypes.add(each.getDiscoveryTypeName());
- toBeRemovedDataSources.add(each.getGroupName());
- }
- });
- toBeCreatedRuleConfig.getDataSources().removeIf(each -> toBeRemovedDataSources.contains(each.getGroupName()));
- toBeCreatedRuleConfig.getDiscoveryHeartbeats().keySet().removeIf(toBeRemovedHeartBeats::contains);
- toBeCreatedRuleConfig.getDiscoveryTypes().keySet().removeIf(toBeRemovedTypes::contains);
+ ShardingSpherePreconditions.checkState(invalidInput.isEmpty(), () -> new InvalidAlgorithmConfigurationException("database discovery", invalidInput));
}
@Override
diff --git a/features/db-discovery/distsql/handler/src/test/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdaterTest.java b/features/db-discovery/distsql/handler/src/test/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdaterTest.java
index 96e15279cc5..e5b457842f5 100644
--- a/features/db-discovery/distsql/handler/src/test/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdaterTest.java
+++ b/features/db-discovery/distsql/handler/src/test/java/org/apache/shardingsphere/dbdiscovery/distsql/handler/update/CreateDatabaseDiscoveryRuleStatementUpdaterTest.java
@@ -72,7 +72,7 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdaterTest {
Properties props = new Properties();
DatabaseDiscoveryDefinitionSegment databaseDiscoveryDefinitionSegment =
new DatabaseDiscoveryDefinitionSegment("readwrite_ds", Collections.emptyList(), new AlgorithmSegment("MySQL.MGR", props), props);
- updater.checkSQLStatement(database, new CreateDatabaseDiscoveryRuleStatement(false, Collections.singletonList(databaseDiscoveryDefinitionSegment)),
+ updater.checkSQLStatement(database, createSQLStatement(false, Collections.singletonList(databaseDiscoveryDefinitionSegment)),
new DatabaseDiscoveryRuleConfiguration(Collections.singleton(dataSourceRuleConfig), Collections.emptyMap(), Collections.emptyMap()));
}
@@ -82,14 +82,14 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdaterTest {
Properties props = new Properties();
DatabaseDiscoveryDefinitionSegment segment =
new DatabaseDiscoveryDefinitionSegment("readwrite_ds", Arrays.asList("ds_read_0", "ds_read_1"), new AlgorithmSegment("MySQL.MGR", props), props);
- updater.checkSQLStatement(database, new CreateDatabaseDiscoveryRuleStatement(false, Collections.singleton(segment)), null);
+ updater.checkSQLStatement(database, createSQLStatement(false, Collections.singleton(segment)), null);
}
@Test(expected = InvalidAlgorithmConfigurationException.class)
public void assertCheckSQLStatementWithDatabaseDiscoveryType() {
AlgorithmSegment algorithmSegment = new AlgorithmSegment("INVALID_TYPE", new Properties());
DatabaseDiscoveryDefinitionSegment segment = new DatabaseDiscoveryDefinitionSegment("readwrite_ds", Arrays.asList("ds_read_0", "ds_read_1"), algorithmSegment, new Properties());
- updater.checkSQLStatement(database, new CreateDatabaseDiscoveryRuleStatement(false, Collections.singleton(segment)), null);
+ updater.checkSQLStatement(database, createSQLStatement(false, Collections.singleton(segment)), null);
}
@Test
@@ -97,7 +97,7 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdaterTest {
AlgorithmSegment algorithmSegment = new AlgorithmSegment("MySQL.MGR", new Properties());
DatabaseDiscoveryDefinitionSegment definitionSegment = new DatabaseDiscoveryDefinitionSegment("readwrite_ds_1", Arrays.asList("ds_read_0", "ds_read_1"), algorithmSegment, new Properties());
DatabaseDiscoveryRuleConfiguration ruleConfig =
- updater.buildToBeCreatedRuleConfiguration(null, new CreateDatabaseDiscoveryRuleStatement(false, Collections.singletonList(definitionSegment)));
+ updater.buildToBeCreatedRuleConfiguration(null, createSQLStatement(false, Collections.singletonList(definitionSegment)));
assertThat(ruleConfig.getDataSources().size(), is(1));
assertTrue(ruleConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getGroupName)
.collect(Collectors.toList()).removeAll(Collections.singletonList("readwrite_ds_1")));
@@ -111,7 +111,7 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdaterTest {
DatabaseDiscoveryDefinitionSegment definitionSegment = new DatabaseDiscoveryDefinitionSegment("readwrite_ds_1", Arrays.asList("ds_read_0", "ds_read_1"), algorithmSegment, new Properties());
DatabaseDiscoveryRuleConfiguration currentConfig = new DatabaseDiscoveryRuleConfiguration(new LinkedList<>(), new LinkedHashMap<>(), new LinkedHashMap<>());
DatabaseDiscoveryRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(currentConfig,
- new CreateDatabaseDiscoveryRuleStatement(false, Collections.singletonList(definitionSegment)));
+ createSQLStatement(false, Collections.singletonList(definitionSegment)));
updater.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
assertThat(currentConfig.getDataSources().size(), is(1));
assertTrue(currentConfig.getDataSources().stream().map(DatabaseDiscoveryDataSourceRuleConfiguration::getGroupName)
@@ -127,19 +127,18 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdaterTest {
Arrays.asList("ds_read_0", "ds_read_1"), algorithmSegment, new Properties());
DatabaseDiscoveryDefinitionSegment definitionSegmentDS2 = new DatabaseDiscoveryDefinitionSegment("readwrite_ds_2",
Arrays.asList("ds_read_0", "ds_read_1"), algorithmSegment, new Properties());
- Collection<AbstractDatabaseDiscoverySegment> currentRules = new LinkedList<>();
- currentRules.add(definitionSegmentDS1);
- currentRules.add(definitionSegmentDS2);
+ Collection<AbstractDatabaseDiscoverySegment> currentSegments = new LinkedList<>();
+ currentSegments.add(definitionSegmentDS1);
+ currentSegments.add(definitionSegmentDS2);
DatabaseDiscoveryRuleConfiguration currentConfig = new DatabaseDiscoveryRuleConfiguration(new LinkedList<>(), new LinkedHashMap<>(), new LinkedHashMap<>());
- DatabaseDiscoveryRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(currentConfig,
- new CreateDatabaseDiscoveryRuleStatement(false, currentRules));
+ DatabaseDiscoveryRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(currentConfig, createSQLStatement(false, currentSegments));
updater.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
definitionSegmentDS1 = new DatabaseDiscoveryDefinitionSegment("readwrite_ds_1", Arrays.asList("ds_read_0", "ds_read_1", "ds_read_3"), algorithmSegment, new Properties());
definitionSegmentDS2 = new DatabaseDiscoveryDefinitionSegment("readwrite_ds_2", Arrays.asList("ds_read_0", "ds_read_1", "ds_read_3"), algorithmSegment, new Properties());
- Collection<AbstractDatabaseDiscoverySegment> rules = new LinkedList<>();
- rules.add(definitionSegmentDS1);
- rules.add(definitionSegmentDS2);
- CreateDatabaseDiscoveryRuleStatement statement = new CreateDatabaseDiscoveryRuleStatement(true, rules);
+ Collection<AbstractDatabaseDiscoverySegment> toBeCreatedSegments = new LinkedList<>();
+ toBeCreatedSegments.add(definitionSegmentDS1);
+ toBeCreatedSegments.add(definitionSegmentDS2);
+ CreateDatabaseDiscoveryRuleStatement statement = createSQLStatement(true, toBeCreatedSegments);
updater.checkSQLStatement(database, statement, currentConfig);
toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(currentConfig, statement);
updater.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
@@ -159,4 +158,8 @@ public final class CreateDatabaseDiscoveryRuleStatementUpdaterTest {
assertTrue(dataSources.contains("ds_read_1"));
assertFalse(dataSources.contains("ds_read_3"));
}
+
+ private CreateDatabaseDiscoveryRuleStatement createSQLStatement(final boolean ifNotExists, final Collection<AbstractDatabaseDiscoverySegment> segments) {
+ return new CreateDatabaseDiscoveryRuleStatement(ifNotExists, segments);
+ }
}