This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 66851223694 Refactor NewRuleDefinitionBackendHandler (#29784)
66851223694 is described below
commit 66851223694a7451de8d8d215ffc34e1ea35d8f2
Author: Liang Zhang <[email protected]>
AuthorDate: Sat Jan 20 13:10:56 2024 +0800
Refactor NewRuleDefinitionBackendHandler (#29784)
* Refactor NewRuleDefinitionBackendHandler
* Refactor NewRuleDefinitionBackendHandler
* Refactor RDLBackendHandler
* Refactor RDLBackendHandler
* Refactor RDLBackendHandler
* Refactor RDLBackendHandler
* Refactor RDLBackendHandler
---
.../handler/distsql/rdl/RDLBackendHandler.java | 15 ++-------
.../rdl/rule/NewRuleDefinitionBackendHandler.java | 39 +++++++++-------------
.../rdl/rule/RuleDefinitionBackendHandler.java | 5 ++-
.../unit/AlterStorageUnitBackendHandler.java | 23 +++++++------
.../unit/RegisterStorageUnitBackendHandler.java | 34 +++++++++----------
.../unit/StorageUnitDefinitionBackendHandler.java | 3 +-
.../unit/UnregisterStorageUnitBackendHandler.java | 21 ++++++------
.../rdl/rule/RuleDefinitionBackendHandlerTest.java | 1 -
.../unit/AlterStorageUnitBackendHandlerTest.java | 11 +++---
.../RegisterStorageUnitBackendHandlerTest.java | 11 +++---
.../UnregisterStorageUnitBackendHandlerTest.java | 18 ++++++----
11 files changed, 85 insertions(+), 96 deletions(-)
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandler.java
index 12e3b8dd7ae..8eb0c775ddf 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandler.java
@@ -20,9 +20,7 @@ package
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.distsql.statement.rdl.RDLStatement;
-import
org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
-import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.NoDatabaseSelectedException;
-import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.UnknownDatabaseException;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import
org.apache.shardingsphere.proxy.backend.handler.distsql.DistSQLBackendHandler;
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
@@ -46,15 +44,8 @@ public abstract class RDLBackendHandler<T extends
RDLStatement> implements DistS
@Override
public final ResponseHeader execute() throws SQLException {
- String databaseName = DatabaseNameUtils.getDatabaseName(sqlStatement,
connectionSession);
- checkDatabaseName(databaseName);
- return execute(databaseName, sqlStatement);
+ return
execute(ProxyContext.getInstance().getDatabase(DatabaseNameUtils.getDatabaseName(sqlStatement,
connectionSession)), sqlStatement);
}
- protected abstract ResponseHeader execute(String databaseName, T
sqlStatement);
-
- private void checkDatabaseName(final String databaseName) {
- ShardingSpherePreconditions.checkNotNull(databaseName,
NoDatabaseSelectedException::new);
-
ShardingSpherePreconditions.checkState(ProxyContext.getInstance().databaseExists(databaseName),
() -> new UnknownDatabaseException(databaseName));
- }
+ protected abstract ResponseHeader execute(ShardingSphereDatabase database,
T sqlStatement);
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
index 01e0cc4b727..c601fd7b9d4 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/NewRuleDefinitionBackendHandler.java
@@ -67,10 +67,10 @@ public final class NewRuleDefinitionBackendHandler<T
extends RuleDefinitionState
@SuppressWarnings("rawtypes")
@Override
- protected ResponseHeader execute(final String databaseName, final T
sqlStatement) {
+ protected ResponseHeader execute(final ShardingSphereDatabase database,
final T sqlStatement) {
Optional<DatabaseRuleRDLExecutor> executor =
TypedSPILoader.findService(DatabaseRuleRDLExecutor.class,
sqlStatement.getClass());
if (executor.isPresent()) {
- execute(databaseName, sqlStatement, executor.get());
+ execute(database, sqlStatement, executor.get());
return new UpdateResponseHeader(sqlStatement);
}
String modeType =
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeConfiguration().getType();
@@ -78,9 +78,8 @@ public final class NewRuleDefinitionBackendHandler<T extends
RuleDefinitionState
}
@SuppressWarnings({"rawtypes", "unchecked"})
- private void execute(final String databaseName, final T sqlStatement,
final DatabaseRuleRDLExecutor executor) {
+ private void execute(final ShardingSphereDatabase database, final T
sqlStatement, final DatabaseRuleRDLExecutor executor) {
Class<? extends RuleConfiguration> ruleConfigClass =
executor.getRuleConfigurationClass();
- ShardingSphereDatabase database =
ProxyContext.getInstance().getDatabase(databaseName);
RuleConfiguration currentRuleConfig =
findCurrentRuleConfiguration(database, ruleConfigClass).orElse(null);
executor.checkSQLStatement(database, sqlStatement, currentRuleConfig);
if (getRefreshStatus(sqlStatement, currentRuleConfig, executor)) {
@@ -90,12 +89,12 @@ public final class NewRuleDefinitionBackendHandler<T
extends RuleDefinitionState
}
private Optional<RuleConfiguration> findCurrentRuleConfiguration(final
ShardingSphereDatabase database, final Class<? extends RuleConfiguration>
ruleConfigClass) {
- for (RuleConfiguration each :
database.getRuleMetaData().getConfigurations()) {
- if (ruleConfigClass.isAssignableFrom(each.getClass())) {
- return Optional.of(each);
- }
- }
- return Optional.empty();
+ return
database.getRuleMetaData().getConfigurations().stream().filter(each ->
ruleConfigClass.isAssignableFrom(each.getClass())).findFirst();
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ private boolean getRefreshStatus(final SQLStatement sqlStatement, final
RuleConfiguration currentRuleConfig, final DatabaseRuleRDLExecutor<?, ?>
executor) {
+ return !(executor instanceof DatabaseRuleRDLDropExecutor) ||
((DatabaseRuleRDLDropExecutor) executor).hasAnyOneToBeDropped(sqlStatement,
currentRuleConfig);
}
@SuppressWarnings("rawtypes")
@@ -141,15 +140,6 @@ public final class NewRuleDefinitionBackendHandler<T
extends RuleDefinitionState
return
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager().alterRuleConfiguration(database.getName(),
toBeAlteredRuleConfig);
}
- @SuppressWarnings({"unchecked", "rawtypes"})
- private RuleConfiguration decorateRuleConfiguration(final
ShardingSphereDatabase database, final RuleConfiguration ruleConfig) {
- Optional<RuleConfigurationDecorator> decorator =
TypedSPILoader.findService(RuleConfigurationDecorator.class,
ruleConfig.getClass());
- return decorator.map(optional -> optional.decorate(database.getName(),
-
database.getResourceMetaData().getStorageUnits().entrySet().stream()
- .collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue,
LinkedHashMap::new)),
- database.getRuleMetaData().getRules(),
ruleConfig)).orElse(ruleConfig);
- }
-
@SuppressWarnings({"rawtypes", "unchecked"})
private Collection<MetaDataVersion> processDrop(final
ShardingSphereDatabase database,
final T sqlStatement,
final DatabaseRuleRDLDropExecutor executor, final RuleConfiguration
currentRuleConfig) {
@@ -171,12 +161,15 @@ public final class NewRuleDefinitionBackendHandler<T
extends RuleDefinitionState
// TODO refactor to new metadata refresh way
}
modeContextManager.removeRuleConfigurationItem(database.getName(),
toBeDroppedRuleConfig);
- final RuleConfiguration toBeAlteredRuleConfig =
executor.buildToBeAlteredRuleConfiguration(currentRuleConfig, sqlStatement);
+ RuleConfiguration toBeAlteredRuleConfig =
executor.buildToBeAlteredRuleConfiguration(currentRuleConfig, sqlStatement);
return modeContextManager.alterRuleConfiguration(database.getName(),
toBeAlteredRuleConfig);
}
- @SuppressWarnings({"rawtypes", "unchecked"})
- private boolean getRefreshStatus(final SQLStatement sqlStatement, final
RuleConfiguration currentRuleConfig, final DatabaseRuleRDLExecutor<?, ?>
executor) {
- return !(executor instanceof DatabaseRuleRDLDropExecutor) ||
((DatabaseRuleRDLDropExecutor) executor).hasAnyOneToBeDropped(sqlStatement,
currentRuleConfig);
+ @SuppressWarnings("unchecked")
+ private RuleConfiguration decorateRuleConfiguration(final
ShardingSphereDatabase database, final RuleConfiguration ruleConfig) {
+ return TypedSPILoader.findService(RuleConfigurationDecorator.class,
ruleConfig.getClass()).map(optional -> optional.decorate(database.getName(),
+
database.getResourceMetaData().getStorageUnits().entrySet().stream()
+ .collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue,
LinkedHashMap::new)),
+ database.getRuleMetaData().getRules(),
ruleConfig)).orElse(ruleConfig);
}
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandler.java
index c70e0c5f8bd..929cba8cdb0 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandler.java
@@ -57,15 +57,14 @@ public final class RuleDefinitionBackendHandler<T extends
RuleDefinitionStatemen
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
- protected ResponseHeader execute(final String databaseName, final T
sqlStatement) {
+ protected ResponseHeader execute(final ShardingSphereDatabase database,
final T sqlStatement) {
DatabaseRuleRDLExecutor executor =
TypedSPILoader.getService(DatabaseRuleRDLExecutor.class,
sqlStatement.getClass());
- ShardingSphereDatabase database =
ProxyContext.getInstance().getDatabase(databaseName);
Class<? extends RuleConfiguration> ruleConfigClass =
executor.getRuleConfigurationClass();
RuleConfiguration currentRuleConfig =
findCurrentRuleConfiguration(database, ruleConfigClass).orElse(null);
executor.checkSQLStatement(database, sqlStatement, currentRuleConfig);
if (getRefreshStatus(sqlStatement, currentRuleConfig, executor)) {
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager()
- .alterRuleConfiguration(databaseName,
processSQLStatement(database, sqlStatement, executor, currentRuleConfig));
+ .alterRuleConfiguration(database.getName(),
processSQLStatement(database, sqlStatement, executor, currentRuleConfig));
}
return new UpdateResponseHeader(sqlStatement);
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandler.java
index 565b81743cc..dcee8765946 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandler.java
@@ -34,6 +34,7 @@ import
org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import
org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import
org.apache.shardingsphere.infra.exception.core.external.ShardingSphereExternalException;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
@@ -65,12 +66,12 @@ public final class AlterStorageUnitBackendHandler extends
StorageUnitDefinitionB
}
@Override
- public ResponseHeader execute(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
- checkSQLStatement(databaseName, sqlStatement);
+ public ResponseHeader execute(final ShardingSphereDatabase database, final
AlterStorageUnitStatement sqlStatement) {
+ checkSQLStatement(database, sqlStatement);
Map<String, DataSourcePoolProperties> propsMap =
DataSourceSegmentsConverter.convert(databaseType,
sqlStatement.getStorageUnits());
validateHandler.validate(propsMap);
try {
-
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager().alterStorageUnits(databaseName,
propsMap);
+
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager().alterStorageUnits(database.getName(),
propsMap);
} catch (final SQLException | ShardingSphereExternalException ex) {
log.error("Alter storage unit failed", ex);
throw new
InvalidStorageUnitsException(Collections.singleton(ex.getMessage()));
@@ -79,11 +80,11 @@ public final class AlterStorageUnitBackendHandler extends
StorageUnitDefinitionB
}
@Override
- public void checkSQLStatement(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
+ public void checkSQLStatement(final ShardingSphereDatabase database, final
AlterStorageUnitStatement sqlStatement) {
Collection<String> toBeAlteredStorageUnitNames =
getToBeAlteredStorageUnitNames(sqlStatement);
checkDuplicatedStorageUnitNames(toBeAlteredStorageUnitNames);
- checkStorageUnitNameExisted(databaseName, toBeAlteredStorageUnitNames);
- checkDatabase(databaseName, sqlStatement);
+ checkStorageUnitNameExisted(database, toBeAlteredStorageUnitNames);
+ checkDatabase(database, sqlStatement);
}
private Collection<String> getToBeAlteredStorageUnitNames(final
AlterStorageUnitStatement sqlStatement) {
@@ -99,14 +100,14 @@ public final class AlterStorageUnitBackendHandler extends
StorageUnitDefinitionB
return storageUnitNames.stream().filter(each ->
storageUnitNames.stream().filter(each::equals).count() >
1).collect(Collectors.toList());
}
- private void checkStorageUnitNameExisted(final String databaseName, final
Collection<String> storageUnitNames) {
- Map<String, StorageUnit> storageUnits =
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getStorageUnits();
+ private void checkStorageUnitNameExisted(final ShardingSphereDatabase
database, final Collection<String> storageUnitNames) {
+ Map<String, StorageUnit> storageUnits =
database.getResourceMetaData().getStorageUnits();
Collection<String> notExistedStorageUnitNames =
storageUnitNames.stream().filter(each ->
!storageUnits.containsKey(each)).collect(Collectors.toList());
-
ShardingSpherePreconditions.checkState(notExistedStorageUnitNames.isEmpty(), ()
-> new MissingRequiredStorageUnitsException(databaseName,
notExistedStorageUnitNames));
+
ShardingSpherePreconditions.checkState(notExistedStorageUnitNames.isEmpty(), ()
-> new MissingRequiredStorageUnitsException(database.getName(),
notExistedStorageUnitNames));
}
- private void checkDatabase(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
- Map<String, StorageUnit> storageUnits =
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getStorageUnits();
+ private void checkDatabase(final ShardingSphereDatabase database, final
AlterStorageUnitStatement sqlStatement) {
+ Map<String, StorageUnit> storageUnits =
database.getResourceMetaData().getStorageUnits();
Collection<String> invalidStorageUnitNames =
sqlStatement.getStorageUnits().stream().collect(Collectors.toMap(DataSourceSegment::getName,
each -> each)).entrySet().stream()
.filter(each -> !isIdenticalDatabase(each.getValue(),
storageUnits.get(each.getKey()))).map(Entry::getKey).collect(Collectors.toSet());
ShardingSpherePreconditions.checkState(invalidStorageUnitNames.isEmpty(),
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
index 3e15a31b3ce..c3ec984d505 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandler.java
@@ -26,6 +26,7 @@ import
org.apache.shardingsphere.distsql.segment.converter.DataSourceSegmentsCon
import
org.apache.shardingsphere.distsql.statement.rdl.create.RegisterStorageUnitStatement;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.rule.identifier.type.DataSourceContainedRule;
import
org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import
org.apache.shardingsphere.infra.exception.core.external.ShardingSphereExternalException;
@@ -59,12 +60,12 @@ public final class RegisterStorageUnitBackendHandler
extends StorageUnitDefiniti
}
@Override
- public ResponseHeader execute(final String databaseName, final
RegisterStorageUnitStatement sqlStatement) {
- checkSQLStatement(databaseName, sqlStatement);
+ public ResponseHeader execute(final ShardingSphereDatabase database, final
RegisterStorageUnitStatement sqlStatement) {
+ checkSQLStatement(database, sqlStatement);
Map<String, DataSourcePoolProperties> propsMap =
DataSourceSegmentsConverter.convert(databaseType,
sqlStatement.getStorageUnits());
if (sqlStatement.isIfNotExists()) {
- Collection<String> currentStorageUnits =
getCurrentStorageUnitNames(databaseName);
- Collection<String> logicalDataSourceNames =
getLogicalDataSourceNames(databaseName);
+ Collection<String> currentStorageUnits =
getCurrentStorageUnitNames(database);
+ Collection<String> logicalDataSourceNames =
getLogicalDataSourceNames(database);
propsMap.keySet().removeIf(currentStorageUnits::contains);
propsMap.keySet().removeIf(logicalDataSourceNames::contains);
}
@@ -73,7 +74,7 @@ public final class RegisterStorageUnitBackendHandler extends
StorageUnitDefiniti
}
validateHandler.validate(propsMap);
try {
-
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager().registerStorageUnits(databaseName,
propsMap);
+
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager().registerStorageUnits(database.getName(),
propsMap);
} catch (final SQLException | ShardingSphereExternalException ex) {
log.error("Register storage unit failed", ex);
throw new
InvalidStorageUnitsException(Collections.singleton(ex.getMessage()));
@@ -82,18 +83,18 @@ public final class RegisterStorageUnitBackendHandler
extends StorageUnitDefiniti
}
@Override
- public void checkSQLStatement(final String databaseName, final
RegisterStorageUnitStatement sqlStatement) {
+ public void checkSQLStatement(final ShardingSphereDatabase database, final
RegisterStorageUnitStatement sqlStatement) {
Collection<String> dataSourceNames = new
ArrayList<>(sqlStatement.getStorageUnits().size());
if (!sqlStatement.isIfNotExists()) {
- checkDuplicatedDataSourceNames(databaseName, dataSourceNames,
sqlStatement);
- checkDuplicatedLogicalDataSourceNames(databaseName,
dataSourceNames);
+ checkDuplicatedDataSourceNames(database, dataSourceNames,
sqlStatement);
+ checkDuplicatedLogicalDataSourceNames(database, dataSourceNames);
}
}
- private void checkDuplicatedDataSourceNames(final String databaseName,
final Collection<String> dataSourceNames, final RegisterStorageUnitStatement
sqlStatement) {
+ private void checkDuplicatedDataSourceNames(final ShardingSphereDatabase
database, final Collection<String> dataSourceNames, final
RegisterStorageUnitStatement sqlStatement) {
Collection<String> duplicatedDataSourceNames = new
HashSet<>(sqlStatement.getStorageUnits().size(), 1F);
for (DataSourceSegment each : sqlStatement.getStorageUnits()) {
- if (dataSourceNames.contains(each.getName()) ||
getCurrentStorageUnitNames(databaseName).contains(each.getName())) {
+ if (dataSourceNames.contains(each.getName()) ||
getCurrentStorageUnitNames(database).contains(each.getName())) {
duplicatedDataSourceNames.add(each.getName());
}
dataSourceNames.add(each.getName());
@@ -101,8 +102,8 @@ public final class RegisterStorageUnitBackendHandler
extends StorageUnitDefiniti
ShardingSpherePreconditions.checkState(duplicatedDataSourceNames.isEmpty(), ()
-> new DuplicateStorageUnitException(duplicatedDataSourceNames));
}
- private void checkDuplicatedLogicalDataSourceNames(final String
databaseName, final Collection<String> requiredDataSourceNames) {
- Collection<String> logicalDataSourceNames =
getLogicalDataSourceNames(databaseName);
+ private void checkDuplicatedLogicalDataSourceNames(final
ShardingSphereDatabase database, final Collection<String>
requiredDataSourceNames) {
+ Collection<String> logicalDataSourceNames =
getLogicalDataSourceNames(database);
if (logicalDataSourceNames.isEmpty()) {
return;
}
@@ -111,12 +112,11 @@ public final class RegisterStorageUnitBackendHandler
extends StorageUnitDefiniti
() -> new
InvalidStorageUnitsException(Collections.singleton(String.format("%s already
existed in rule", duplicatedDataSourceNames))));
}
- private Collection<String> getCurrentStorageUnitNames(final String
databaseName) {
- return
ProxyContext.getInstance().getContextManager().getStorageUnits(databaseName).keySet();
+ private Collection<String> getCurrentStorageUnitNames(final
ShardingSphereDatabase database) {
+ return
ProxyContext.getInstance().getContextManager().getStorageUnits(database.getName()).keySet();
}
- private Collection<String> getLogicalDataSourceNames(final String
databaseName) {
- return
ProxyContext.getInstance().getDatabase(databaseName).getRuleMetaData().findRules(DataSourceContainedRule.class).stream()
- .map(each ->
each.getDataSourceMapper().keySet()).flatMap(Collection::stream).collect(Collectors.toList());
+ private Collection<String> getLogicalDataSourceNames(final
ShardingSphereDatabase database) {
+ return
database.getRuleMetaData().findRules(DataSourceContainedRule.class).stream().map(each
->
each.getDataSourceMapper().keySet()).flatMap(Collection::stream).collect(Collectors.toList());
}
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/StorageUnitDefinitionBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/StorageUnitDefinitionBackendHandler.java
index 9b4d3af9ebf..6dbf4ee8bbb 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/StorageUnitDefinitionBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/StorageUnitDefinitionBackendHandler.java
@@ -18,6 +18,7 @@
package
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.storage.unit;
import
org.apache.shardingsphere.distsql.statement.rdl.StorageUnitDefinitionStatement;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.RDLBackendHandler;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
@@ -32,5 +33,5 @@ public abstract class StorageUnitDefinitionBackendHandler<T
extends StorageUnitD
super(sqlStatement, connectionSession);
}
- protected abstract void checkSQLStatement(String databaseName, T
sqlStatement);
+ protected abstract void checkSQLStatement(ShardingSphereDatabase database,
T sqlStatement);
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandler.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandler.java
index 975b50abaa8..8b1b84dc72c 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandler.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandler.java
@@ -53,10 +53,10 @@ public final class UnregisterStorageUnitBackendHandler
extends StorageUnitDefini
}
@Override
- public ResponseHeader execute(final String databaseName, final
UnregisterStorageUnitStatement sqlStatement) {
- checkSQLStatement(databaseName, sqlStatement);
+ public ResponseHeader execute(final ShardingSphereDatabase database, final
UnregisterStorageUnitStatement sqlStatement) {
+ checkSQLStatement(database, sqlStatement);
try {
-
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager().unregisterStorageUnits(databaseName,
sqlStatement.getStorageUnitNames());
+
ProxyContext.getInstance().getContextManager().getInstanceContext().getModeContextManager().unregisterStorageUnits(database.getName(),
sqlStatement.getStorageUnitNames());
} catch (final SQLException | ShardingSphereServerException ex) {
log.error("Unregister storage unit failed", ex);
throw new
InvalidStorageUnitsException(Collections.singleton(ex.getMessage()));
@@ -65,21 +65,20 @@ public final class UnregisterStorageUnitBackendHandler
extends StorageUnitDefini
}
@Override
- public void checkSQLStatement(final String databaseName, final
UnregisterStorageUnitStatement sqlStatement) {
+ public void checkSQLStatement(final ShardingSphereDatabase database, final
UnregisterStorageUnitStatement sqlStatement) {
if (!sqlStatement.isIfExists()) {
- checkExisted(databaseName, sqlStatement.getStorageUnitNames());
+ checkExisted(database, sqlStatement.getStorageUnitNames());
}
- checkInUsed(databaseName, sqlStatement);
+ checkInUsed(database, sqlStatement);
}
- private void checkExisted(final String databaseName, final
Collection<String> storageUnitNames) {
- Map<String, StorageUnit> storageUnits =
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getStorageUnits();
+ private void checkExisted(final ShardingSphereDatabase database, final
Collection<String> storageUnitNames) {
+ Map<String, StorageUnit> storageUnits =
database.getResourceMetaData().getStorageUnits();
Collection<String> notExistedStorageUnits =
storageUnitNames.stream().filter(each ->
!storageUnits.containsKey(each)).collect(Collectors.toList());
-
ShardingSpherePreconditions.checkState(notExistedStorageUnits.isEmpty(), () ->
new MissingRequiredStorageUnitsException(databaseName, notExistedStorageUnits));
+
ShardingSpherePreconditions.checkState(notExistedStorageUnits.isEmpty(), () ->
new MissingRequiredStorageUnitsException(database.getName(),
notExistedStorageUnits));
}
- private void checkInUsed(final String databaseName, final
UnregisterStorageUnitStatement sqlStatement) {
- ShardingSphereDatabase database =
ProxyContext.getInstance().getDatabase(databaseName);
+ private void checkInUsed(final ShardingSphereDatabase database, final
UnregisterStorageUnitStatement sqlStatement) {
Map<String, Collection<Class<? extends ShardingSphereRule>>>
inUsedStorageUnits =
database.getRuleMetaData().getInUsedStorageUnitNameAndRulesMap();
Collection<String> inUsedStorageUnitNames =
inUsedStorageUnits.keySet();
inUsedStorageUnitNames.retainAll(sqlStatement.getStorageUnitNames());
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandlerTest.java
index 2be5eb71c78..d197eb9d642 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/RuleDefinitionBackendHandlerTest.java
@@ -54,7 +54,6 @@ class RuleDefinitionBackendHandlerTest {
ShardingSphereDatabase database = mockDatabase();
ContextManager contextManager = mockContextManager(database);
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
-
when(ProxyContext.getInstance().databaseExists("foo_db")).thenReturn(true);
when(ProxyContext.getInstance().getDatabase("foo_db")).thenReturn(database);
ResponseHeader response = new RuleDefinitionBackendHandler<>(new
CreateFixtureRuleStatement(), connectionSession).execute();
assertThat(response, instanceOf(UpdateResponseHeader.class));
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandlerTest.java
index ed9b7bd4504..d619aa2d5f2 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/AlterStorageUnitBackendHandlerTest.java
@@ -41,6 +41,7 @@ import org.apache.shardingsphere.test.mock.StaticMockSettings;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.internal.configuration.plugins.Plugins;
@@ -60,7 +61,7 @@ import static org.mockito.Mockito.when;
@StaticMockSettings(ProxyContext.class)
class AlterStorageUnitBackendHandlerTest {
- @Mock
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
private ShardingSphereDatabase database;
private AlterStorageUnitBackendHandler handler;
@@ -85,12 +86,12 @@ class AlterStorageUnitBackendHandlerTest {
when(storageUnit.getConnectionProperties()).thenReturn(connectionProperties);
when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("ds_0",
storageUnit));
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
- assertThat(handler.execute("foo_db",
createAlterStorageUnitStatement("ds_0")),
instanceOf(UpdateResponseHeader.class));
+ assertThat(handler.execute(database,
createAlterStorageUnitStatement("ds_0")),
instanceOf(UpdateResponseHeader.class));
}
@Test
void assertExecuteWithDuplicateStorageUnitNames() {
- assertThrows(DuplicateStorageUnitException.class, () ->
handler.execute("foo_db",
createAlterStorageUnitStatementWithDuplicateStorageUnitNames()));
+ assertThrows(DuplicateStorageUnitException.class, () ->
handler.execute(database,
createAlterStorageUnitStatementWithDuplicateStorageUnitNames()));
}
@Test
@@ -99,7 +100,7 @@ class AlterStorageUnitBackendHandlerTest {
when(metaDataContexts.getMetaData().getDatabases()).thenReturn(Collections.singletonMap("foo_db",
database));
ContextManager contextManager = mockContextManager(metaDataContexts);
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- assertThrows(MissingRequiredStorageUnitsException.class, () ->
handler.execute("foo_db", createAlterStorageUnitStatement("not_existed")));
+ assertThrows(MissingRequiredStorageUnitsException.class, () ->
handler.execute(database, createAlterStorageUnitStatement("not_existed")));
}
@Test
@@ -113,7 +114,7 @@ class AlterStorageUnitBackendHandlerTest {
when(storageUnit.getConnectionProperties()).thenReturn(connectionProperties);
when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("ds_0",
storageUnit));
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
- assertThrows(InvalidStorageUnitsException.class, () ->
handler.execute("foo_db", createAlterStorageUnitStatement("ds_0")));
+ assertThrows(InvalidStorageUnitsException.class, () ->
handler.execute(database, createAlterStorageUnitStatement("ds_0")));
}
private ContextManager mockContextManager(final MetaDataContexts
metaDataContexts) {
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
index 4af2f7b6624..411f3877114 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/RegisterStorageUnitBackendHandlerTest.java
@@ -71,6 +71,7 @@ class RegisterStorageUnitBackendHandlerTest {
void setUp() throws ReflectiveOperationException {
ConnectionSession connectionSession = mock(ConnectionSession.class);
when(connectionSession.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"FIXTURE"));
+ when(database.getName()).thenReturn("foo_db");
when(database.getRuleMetaData()).thenReturn(mock(RuleMetaData.class));
handler = new
RegisterStorageUnitBackendHandler(mock(RegisterStorageUnitStatement.class),
connectionSession);
Plugins.getMemberAccessor().set(handler.getClass().getDeclaredField("validateHandler"),
handler, mock(DataSourcePoolPropertiesValidateHandler.class));
@@ -82,7 +83,7 @@ class RegisterStorageUnitBackendHandlerTest {
when(contextManager.getMetaDataContexts()).thenReturn(mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS));
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
when(ProxyContext.getInstance().getDatabase("foo_db")).thenReturn(database);
- ResponseHeader responseHeader = handler.execute("foo_db",
createRegisterStorageUnitStatement());
+ ResponseHeader responseHeader = handler.execute(database,
createRegisterStorageUnitStatement());
assertThat(responseHeader, instanceOf(UpdateResponseHeader.class));
}
@@ -91,7 +92,7 @@ class RegisterStorageUnitBackendHandlerTest {
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
when(contextManager.getMetaDataContexts()).thenReturn(mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS));
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- assertThrows(DuplicateStorageUnitException.class, () ->
handler.execute("foo_db",
createRegisterStorageUnitStatementWithDuplicateStorageUnitNames()));
+ assertThrows(DuplicateStorageUnitException.class, () ->
handler.execute(database,
createRegisterStorageUnitStatementWithDuplicateStorageUnitNames()));
}
@Test
@@ -99,7 +100,7 @@ class RegisterStorageUnitBackendHandlerTest {
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
when(contextManager.getStorageUnits("foo_db").keySet()).thenReturn(Collections.singleton("ds_0"));
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
- assertThrows(DuplicateStorageUnitException.class, () ->
handler.execute("foo_db", createRegisterStorageUnitStatement()));
+ assertThrows(DuplicateStorageUnitException.class, () ->
handler.execute(database, createRegisterStorageUnitStatement()));
}
@Test
@@ -111,14 +112,14 @@ class RegisterStorageUnitBackendHandlerTest {
when(database.getRuleMetaData().findRules(DataSourceContainedRule.class)).thenReturn(Collections.singleton(rule));
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
when(ProxyContext.getInstance().getDatabase("foo_db")).thenReturn(database);
- assertThrows(InvalidStorageUnitsException.class, () ->
handler.execute("foo_db", createRegisterStorageUnitStatement()));
+ assertThrows(InvalidStorageUnitsException.class, () ->
handler.execute(database, createRegisterStorageUnitStatement()));
}
@Test
void assertCheckStatementWithIfNotExists() {
RegisterStorageUnitStatement
registerStorageUnitStatementWithIfNotExists = new
RegisterStorageUnitStatement(true, Collections.singleton(
new HostnameAndPortBasedDataSourceSegment("ds_0", "127.0.0.1",
"3306", "db_1", "root", "", new Properties())));
- handler.checkSQLStatement("foo_db",
registerStorageUnitStatementWithIfNotExists);
+ handler.checkSQLStatement(database,
registerStorageUnitStatementWithIfNotExists);
}
private RegisterStorageUnitStatement createRegisterStorageUnitStatement() {
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java
index 15c93a1c0fd..78fcbdde0f4 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/storage/unit/UnregisterStorageUnitBackendHandlerTest.java
@@ -44,6 +44,8 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
import java.sql.SQLException;
import java.util.Collections;
@@ -58,6 +60,7 @@ import static org.mockito.Mockito.when;
@ExtendWith(AutoMockExtension.class)
@StaticMockSettings(ProxyContext.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
class UnregisterStorageUnitBackendHandlerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
@@ -87,6 +90,7 @@ class UnregisterStorageUnitBackendHandlerTest {
when(dataSourcePoolProps.getConnectionPropertySynonyms().getStandardProperties()).thenReturn(Collections.singletonMap("url",
"jdbc:mock://127.0.0.1/foo_db"));
StorageUnit storageUnit = new StorageUnit(mock(StorageNode.class),
dataSourcePoolProps, new MockedDataSource());
when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds",
storageUnit));
+ when(database.getName()).thenReturn("foo_db");
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
contextManager = mockContextManager();
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
@@ -112,14 +116,14 @@ class UnregisterStorageUnitBackendHandlerTest {
when(database.getRuleMetaData().getInUsedStorageUnitNameAndRulesMap()).thenReturn(Collections.emptyMap());
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
UnregisterStorageUnitStatement unregisterStorageUnitStatement = new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false);
- assertThat(handler.execute("foo_db", unregisterStorageUnitStatement),
instanceOf(UpdateResponseHeader.class));
+ assertThat(handler.execute(database, unregisterStorageUnitStatement),
instanceOf(UpdateResponseHeader.class));
verify(modeContextManager).unregisterStorageUnits("foo_db",
unregisterStorageUnitStatement.getStorageUnitNames());
}
@Test
void assertStorageUnitNameNotExistedExecute() {
when(ProxyContext.getInstance().getDatabase("foo_db").getResourceMetaData().getStorageUnits()).thenReturn(Collections.emptyMap());
- assertThrows(MissingRequiredStorageUnitsException.class, () ->
handler.execute("foo_db", new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false)));
+ assertThrows(MissingRequiredStorageUnitsException.class, () ->
handler.execute(database, new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false)));
}
@Test
@@ -132,7 +136,7 @@ class UnregisterStorageUnitBackendHandlerTest {
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
assertThrows(StorageUnitInUsedException.class,
- () -> handler.execute("foo_db", new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false)));
+ () -> handler.execute(database, new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false)));
}
@Test
@@ -146,7 +150,7 @@ class UnregisterStorageUnitBackendHandlerTest {
when(resourceMetaData.getStorageUnits()).thenReturn(Collections.singletonMap("foo_ds",
storageUnit));
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
- assertThrows(StorageUnitInUsedException.class, () ->
handler.execute("foo_db", new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false)));
+ assertThrows(StorageUnitInUsedException.class, () ->
handler.execute(database, new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false, false)));
}
@Test
@@ -161,14 +165,14 @@ class UnregisterStorageUnitBackendHandlerTest {
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
UnregisterStorageUnitStatement unregisterStorageUnitStatement = new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), true, false);
- assertThat(handler.execute("foo_db", unregisterStorageUnitStatement),
instanceOf(UpdateResponseHeader.class));
+ assertThat(handler.execute(database, unregisterStorageUnitStatement),
instanceOf(UpdateResponseHeader.class));
verify(modeContextManager).unregisterStorageUnits("foo_db",
unregisterStorageUnitStatement.getStorageUnitNames());
}
@Test
void assertExecuteWithIfExists() throws SQLException {
UnregisterStorageUnitStatement unregisterStorageUnitStatement = new
UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true,
false);
- assertThat(handler.execute("foo_db", unregisterStorageUnitStatement),
instanceOf(UpdateResponseHeader.class));
+ assertThat(handler.execute(database, unregisterStorageUnitStatement),
instanceOf(UpdateResponseHeader.class));
verify(modeContextManager).unregisterStorageUnits("foo_db",
unregisterStorageUnitStatement.getStorageUnitNames());
}
@@ -178,6 +182,6 @@ class UnregisterStorageUnitBackendHandlerTest {
when(shadowRule.getDataSourceMapper()).thenReturn(Collections.singletonMap("",
Collections.singleton("foo_ds")));
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")).thenReturn(database);
UnregisterStorageUnitStatement unregisterStorageUnitStatement = new
UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true,
false);
- assertThrows(DistSQLException.class, () -> handler.execute("foo_db",
unregisterStorageUnitStatement));
+ assertThrows(DistSQLException.class, () -> handler.execute(database,
unregisterStorageUnitStatement));
}
}
