This is an automated email from the ASF dual-hosted git repository.
tuichenchuxin 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 3719f6e5c8a Refactor StorageUnitBackendHandler. (#22191)
3719f6e5c8a is described below
commit 3719f6e5c8a52b08aa09c74b28c346422f2386d4
Author: Raigor <[email protected]>
AuthorDate: Wed Nov 16 08:58:46 2022 +0800
Refactor StorageUnitBackendHandler. (#22191)
* Refactor StorageUnitBackendHandler.
* Change method order.
---
...nt.java => StorageUnitDefinitionStatement.java} | 4 +-
.../rdl/alter/AlterStorageUnitStatement.java | 8 +--
.../rdl/create/RegisterStorageUnitStatement.java | 8 +--
.../rdl/drop/UnregisterStorageUnitStatement.java | 14 ++---
.../distsql/rdl/RDLBackendHandlerFactory.java | 15 +++--
.../resource/AlterStorageUnitBackendHandler.java | 34 +++++------
.../RegisterStorageUnitBackendHandler.java | 40 +++++++------
.../rdl/resource/StorageUnitBackendHandler.java | 16 +++++-
.../UnregisterStorageUnitBackendHandler.java | 65 +++++++++++-----------
.../UnregisterStorageUnitBackendHandlerTest.java | 6 +-
.../rdl/alter/AlterStorageUnitStatementAssert.java | 12 ++--
.../create/RegisterStorageUnitStatementAssert.java | 12 ++--
.../drop/UnregisterStorageUnitStatementAssert.java | 12 ++--
13 files changed, 132 insertions(+), 114 deletions(-)
diff --git
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/ResourceDefinitionStatement.java
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/StorageUnitDefinitionStatement.java
similarity index 88%
copy from
distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/ResourceDefinitionStatement.java
copy to
distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/StorageUnitDefinitionStatement.java
index 5a33bdb74db..889021e4388 100644
---
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/ResourceDefinitionStatement.java
+++
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/StorageUnitDefinitionStatement.java
@@ -18,7 +18,7 @@
package org.apache.shardingsphere.distsql.parser.statement.rdl;
/**
- * Resource definition statement.
+ * Storage unit definition statement.
*/
-public abstract class ResourceDefinitionStatement extends RDLStatement {
+public abstract class StorageUnitDefinitionStatement extends RDLStatement {
}
diff --git
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/alter/AlterStorageUnitStatement.java
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/alter/AlterStorageUnitStatement.java
index a3a46f1e0a0..12e8de33a5b 100644
---
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/alter/AlterStorageUnitStatement.java
+++
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/alter/AlterStorageUnitStatement.java
@@ -20,16 +20,16 @@ package
org.apache.shardingsphere.distsql.parser.statement.rdl.alter;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.distsql.parser.segment.DataSourceSegment;
-import
org.apache.shardingsphere.distsql.parser.statement.rdl.ResourceDefinitionStatement;
+import
org.apache.shardingsphere.distsql.parser.statement.rdl.StorageUnitDefinitionStatement;
import java.util.Collection;
/**
- * Alter resource statement.
+ * Alter storage unit statement.
*/
@RequiredArgsConstructor
@Getter
-public final class AlterStorageUnitStatement extends
ResourceDefinitionStatement {
+public final class AlterStorageUnitStatement extends
StorageUnitDefinitionStatement {
- private final Collection<DataSourceSegment> dataSources;
+ private final Collection<DataSourceSegment> storageUnits;
}
diff --git
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/create/RegisterStorageUnitStatement.java
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/create/RegisterStorageUnitStatement.java
index 84e73a17c6f..a255a7b77e8 100644
---
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/create/RegisterStorageUnitStatement.java
+++
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/create/RegisterStorageUnitStatement.java
@@ -20,16 +20,16 @@ package
org.apache.shardingsphere.distsql.parser.statement.rdl.create;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.distsql.parser.segment.DataSourceSegment;
-import
org.apache.shardingsphere.distsql.parser.statement.rdl.ResourceDefinitionStatement;
+import
org.apache.shardingsphere.distsql.parser.statement.rdl.StorageUnitDefinitionStatement;
import java.util.Collection;
/**
- * Add resource statement.
+ * Register storage unit statement.
*/
@RequiredArgsConstructor
@Getter
-public final class RegisterStorageUnitStatement extends
ResourceDefinitionStatement {
+public final class RegisterStorageUnitStatement extends
StorageUnitDefinitionStatement {
- private final Collection<DataSourceSegment> dataSources;
+ private final Collection<DataSourceSegment> storageUnits;
}
diff --git
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/drop/UnregisterStorageUnitStatement.java
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/drop/UnregisterStorageUnitStatement.java
index 7a8f83de6f4..9e0aad88597 100644
---
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/drop/UnregisterStorageUnitStatement.java
+++
b/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/drop/UnregisterStorageUnitStatement.java
@@ -19,26 +19,24 @@ package
org.apache.shardingsphere.distsql.parser.statement.rdl.drop;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
-import
org.apache.shardingsphere.distsql.parser.statement.rdl.ResourceDefinitionStatement;
+import
org.apache.shardingsphere.distsql.parser.statement.rdl.StorageUnitDefinitionStatement;
import java.util.Collection;
/**
- * Drop resource statement.
+ * Unregister storage unit statement.
*/
@RequiredArgsConstructor
@Getter
-public final class UnregisterStorageUnitStatement extends
ResourceDefinitionStatement {
+public final class UnregisterStorageUnitStatement extends
StorageUnitDefinitionStatement {
private final boolean ifExists;
- private final Collection<String> names;
+ private final Collection<String> storageUnitNames;
private final boolean ignoreSingleTables;
- public UnregisterStorageUnitStatement(final Collection<String> names,
final boolean ignoreSingleTables) {
- this.ifExists = false;
- this.names = names;
- this.ignoreSingleTables = ignoreSingleTables;
+ public UnregisterStorageUnitStatement(final Collection<String>
storageUnitNames, final boolean ignoreSingleTables) {
+ this(false, storageUnitNames, ignoreSingleTables);
}
}
diff --git
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
index b8de8f2b29c..0e97de1c536 100644
---
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
+++
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/RDLBackendHandlerFactory.java
@@ -21,12 +21,13 @@ import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.shardingsphere.distsql.parser.statement.rdl.RDLStatement;
import
org.apache.shardingsphere.distsql.parser.statement.rdl.RuleDefinitionStatement;
+import
org.apache.shardingsphere.distsql.parser.statement.rdl.StorageUnitDefinitionStatement;
import
org.apache.shardingsphere.distsql.parser.statement.rdl.alter.AlterStorageUnitStatement;
import
org.apache.shardingsphere.distsql.parser.statement.rdl.create.RegisterStorageUnitStatement;
import
org.apache.shardingsphere.distsql.parser.statement.rdl.drop.UnregisterStorageUnitStatement;
import org.apache.shardingsphere.proxy.backend.handler.ProxyBackendHandler;
-import
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource.RegisterStorageUnitBackendHandler;
import
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource.AlterStorageUnitBackendHandler;
+import
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource.RegisterStorageUnitBackendHandler;
import
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource.UnregisterStorageUnitBackendHandler;
import
org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.rule.RuleDefinitionBackendHandler;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
@@ -45,15 +46,19 @@ public final class RDLBackendHandlerFactory {
* @return RDL backend handler
*/
public static ProxyBackendHandler newInstance(final RDLStatement
sqlStatement, final ConnectionSession connectionSession) {
+ if (sqlStatement instanceof StorageUnitDefinitionStatement) {
+ return
getStorageUnitBackendHandler((StorageUnitDefinitionStatement) sqlStatement,
connectionSession);
+ }
+ return new RuleDefinitionBackendHandler<>((RuleDefinitionStatement)
sqlStatement, connectionSession);
+ }
+
+ private static ProxyBackendHandler getStorageUnitBackendHandler(final
StorageUnitDefinitionStatement sqlStatement, final ConnectionSession
connectionSession) {
if (sqlStatement instanceof RegisterStorageUnitStatement) {
return new
RegisterStorageUnitBackendHandler((RegisterStorageUnitStatement) sqlStatement,
connectionSession);
}
if (sqlStatement instanceof AlterStorageUnitStatement) {
return new
AlterStorageUnitBackendHandler((AlterStorageUnitStatement) sqlStatement,
connectionSession);
}
- if (sqlStatement instanceof UnregisterStorageUnitStatement) {
- return new
UnregisterStorageUnitBackendHandler((UnregisterStorageUnitStatement)
sqlStatement, connectionSession);
- }
- return new RuleDefinitionBackendHandler<>((RuleDefinitionStatement)
sqlStatement, connectionSession);
+ return new
UnregisterStorageUnitBackendHandler((UnregisterStorageUnitStatement)
sqlStatement, connectionSession);
}
}
diff --git
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/AlterStorageUnitBackendHandler.java
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/AlterStorageUnitBackendHandler.java
index 2520e36d74e..d3b832c83c8 100644
---
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/AlterStorageUnitBackendHandler.java
+++
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/AlterStorageUnitBackendHandler.java
@@ -53,7 +53,7 @@ import java.util.stream.Collectors;
* Alter storage unit backend handler.
*/
@Slf4j
-public final class AlterStorageUnitBackendHandler extends
DatabaseRequiredBackendHandler<AlterStorageUnitStatement> {
+public final class AlterStorageUnitBackendHandler extends
DatabaseRequiredBackendHandler<AlterStorageUnitStatement> implements
StorageUnitBackendHandler<AlterStorageUnitStatement> {
private final DatabaseType databaseType;
@@ -68,7 +68,7 @@ public final class AlterStorageUnitBackendHandler extends
DatabaseRequiredBacken
@Override
public ResponseHeader execute(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
checkSQLStatement(databaseName, sqlStatement);
- Map<String, DataSourceProperties> dataSourcePropsMap =
ResourceSegmentsConverter.convert(databaseType, sqlStatement.getDataSources());
+ Map<String, DataSourceProperties> dataSourcePropsMap =
ResourceSegmentsConverter.convert(databaseType, sqlStatement.getStorageUnits());
validator.validate(dataSourcePropsMap);
try {
ProxyContext.getInstance().getContextManager().updateResources(databaseName,
dataSourcePropsMap);
@@ -79,30 +79,24 @@ public final class AlterStorageUnitBackendHandler extends
DatabaseRequiredBacken
return new UpdateResponseHeader(sqlStatement);
}
- private void checkSQLStatement(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
+ @Override
+ public void checkSQLStatement(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
Collection<String> toBeAlteredStorageUnitNames =
getToBeAlteredStorageUnitNames(sqlStatement);
- checkToBeAlteredDuplicateStorageUnitNames(toBeAlteredStorageUnitNames);
+ checkDuplicatedStorageUnitNames(toBeAlteredStorageUnitNames);
checkStorageUnitNameExisted(databaseName, toBeAlteredStorageUnitNames);
checkDatabase(databaseName, sqlStatement);
}
- private void checkDatabase(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
- Map<String, DataSource> storageUnits =
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getDataSources();
- Collection<String> invalid =
sqlStatement.getDataSources().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(invalid.isEmpty(), () -> new
InvalidResourcesException(Collections.singleton(String.format("Cannot alter the
database of %s", invalid))));
- }
-
private Collection<String> getToBeAlteredStorageUnitNames(final
AlterStorageUnitStatement sqlStatement) {
- return
sqlStatement.getDataSources().stream().map(DataSourceSegment::getName).collect(Collectors.toList());
+ return
sqlStatement.getStorageUnits().stream().map(DataSourceSegment::getName).collect(Collectors.toList());
}
- private void checkToBeAlteredDuplicateStorageUnitNames(final
Collection<String> storageUnitNames) {
- Collection<String> duplicateStorageUnitNames =
getDuplicateStorageUnitNames(storageUnitNames);
-
ShardingSpherePreconditions.checkState(duplicateStorageUnitNames.isEmpty(), ()
-> new DuplicateResourceException(duplicateStorageUnitNames));
+ private void checkDuplicatedStorageUnitNames(final Collection<String>
storageUnitNames) {
+ Collection<String> duplicatedStorageUnitNames =
getDuplicatedStorageUnitNames(storageUnitNames);
+
ShardingSpherePreconditions.checkState(duplicatedStorageUnitNames.isEmpty(), ()
-> new DuplicateResourceException(duplicatedStorageUnitNames));
}
- private Collection<String> getDuplicateStorageUnitNames(final
Collection<String> storageUnitNames) {
+ private Collection<String> getDuplicatedStorageUnitNames(final
Collection<String> storageUnitNames) {
return storageUnitNames.stream().filter(each ->
storageUnitNames.stream().filter(each::equals).count() >
1).collect(Collectors.toList());
}
@@ -112,6 +106,14 @@ public final class AlterStorageUnitBackendHandler extends
DatabaseRequiredBacken
ShardingSpherePreconditions.checkState(notExistedStorageUnitNames.isEmpty(), ()
-> new MissingRequiredResourcesException(databaseName,
notExistedStorageUnitNames));
}
+ private void checkDatabase(final String databaseName, final
AlterStorageUnitStatement sqlStatement) {
+ Map<String, DataSource> storageUnits =
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getDataSources();
+ 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(),
+ () -> new
InvalidResourcesException(Collections.singleton(String.format("Cannot alter the
database of %s", invalidStorageUnitNames))));
+ }
+
private boolean isIdenticalDatabase(final DataSourceSegment segment, final
DataSource dataSource) {
String hostName = null;
String port = null;
diff --git
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/RegisterStorageUnitBackendHandler.java
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/RegisterStorageUnitBackendHandler.java
index dac30460abc..8737eb240aa 100644
---
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/RegisterStorageUnitBackendHandler.java
+++
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/RegisterStorageUnitBackendHandler.java
@@ -50,7 +50,7 @@ import java.util.stream.Collectors;
* Register storage unit backend handler.
*/
@Slf4j
-public final class RegisterStorageUnitBackendHandler extends
DatabaseRequiredBackendHandler<RegisterStorageUnitStatement> {
+public final class RegisterStorageUnitBackendHandler extends
DatabaseRequiredBackendHandler<RegisterStorageUnitStatement> implements
StorageUnitBackendHandler<RegisterStorageUnitStatement> {
private final DatabaseType databaseType;
@@ -65,7 +65,7 @@ public final class RegisterStorageUnitBackendHandler extends
DatabaseRequiredBac
@Override
public ResponseHeader execute(final String databaseName, final
RegisterStorageUnitStatement sqlStatement) {
checkSQLStatement(databaseName, sqlStatement);
- Map<String, DataSourceProperties> dataSourcePropsMap =
ResourceSegmentsConverter.convert(databaseType, sqlStatement.getDataSources());
+ Map<String, DataSourceProperties> dataSourcePropsMap =
ResourceSegmentsConverter.convert(databaseType, sqlStatement.getStorageUnits());
validator.validate(dataSourcePropsMap);
try {
ProxyContext.getInstance().getContextManager().addResources(databaseName,
dataSourcePropsMap);
@@ -76,28 +76,34 @@ public final class RegisterStorageUnitBackendHandler
extends DatabaseRequiredBac
return new UpdateResponseHeader(sqlStatement);
}
- private void checkSQLStatement(final String databaseName, final
RegisterStorageUnitStatement sqlStatement) {
- Collection<String> dataSourceNames = new
ArrayList<>(sqlStatement.getDataSources().size());
- Collection<String> duplicateDataSourceNames = new
HashSet<>(sqlStatement.getDataSources().size(), 1);
- for (DataSourceSegment each : sqlStatement.getDataSources()) {
+ @Override
+ public void checkSQLStatement(final String databaseName, final
RegisterStorageUnitStatement sqlStatement) {
+ Collection<String> dataSourceNames = new
ArrayList<>(sqlStatement.getStorageUnits().size());
+ checkDuplicatedDataSourceNames(databaseName, dataSourceNames,
sqlStatement);
+ checkDuplicatedDataSourceNameWithReadwriteSplittingRule(databaseName,
dataSourceNames);
+ }
+
+ private void checkDuplicatedDataSourceNames(final String databaseName,
final Collection<String> dataSourceNames, final RegisterStorageUnitStatement
sqlStatement) {
+ Collection<String> duplicatedDataSourceNames = new
HashSet<>(sqlStatement.getStorageUnits().size(), 1);
+ for (DataSourceSegment each : sqlStatement.getStorageUnits()) {
if (dataSourceNames.contains(each.getName()) ||
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getDataSources().containsKey(each.getName()))
{
- duplicateDataSourceNames.add(each.getName());
+ duplicatedDataSourceNames.add(each.getName());
}
dataSourceNames.add(each.getName());
}
-
ShardingSpherePreconditions.checkState(duplicateDataSourceNames.isEmpty(), ()
-> new DuplicateResourceException(duplicateDataSourceNames));
- checkDuplicateDataSourceNameWithReadwriteSplittingRule(databaseName,
dataSourceNames);
+
ShardingSpherePreconditions.checkState(duplicatedDataSourceNames.isEmpty(), ()
-> new DuplicateResourceException(duplicatedDataSourceNames));
}
- private void checkDuplicateDataSourceNameWithReadwriteSplittingRule(final
String databaseName, final Collection<String> requiredDataSourceNames) {
- Optional<ReadwriteSplittingRule> readwriteSplittingRule =
ProxyContext.getInstance().getDatabase(databaseName).getRuleMetaData().findSingleRule(ReadwriteSplittingRule.class);
- if (!readwriteSplittingRule.isPresent()) {
+ private void checkDuplicatedDataSourceNameWithReadwriteSplittingRule(final
String databaseName, final Collection<String> requiredDataSourceNames) {
+ // TODO use SPI to decouple features
+ Optional<ReadwriteSplittingRule> rule =
ProxyContext.getInstance().getDatabase(databaseName).getRuleMetaData().findSingleRule(ReadwriteSplittingRule.class);
+ if (!rule.isPresent()) {
return;
}
- ReadwriteSplittingRuleConfiguration config =
(ReadwriteSplittingRuleConfiguration)
readwriteSplittingRule.get().getConfiguration();
- Collection<String> existRuleNames =
config.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toSet());
- Collection<String> duplicateDataSourceNames =
requiredDataSourceNames.stream().filter(each ->
existRuleNames.contains(each)).collect(Collectors.toSet());
-
ShardingSpherePreconditions.checkState(duplicateDataSourceNames.isEmpty(),
- () -> new
InvalidResourcesException(Collections.singleton(String.format("%s already
exists in readwrite splitting", duplicateDataSourceNames))));
+ ReadwriteSplittingRuleConfiguration ruleConfig =
(ReadwriteSplittingRuleConfiguration) rule.get().getConfiguration();
+ Collection<String> existedRuleNames =
ruleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toSet());
+ Collection<String> duplicatedDataSourceNames =
requiredDataSourceNames.stream().filter(existedRuleNames::contains).collect(Collectors.toSet());
+
ShardingSpherePreconditions.checkState(duplicatedDataSourceNames.isEmpty(),
+ () -> new
InvalidResourcesException(Collections.singleton(String.format("%s already
exists in readwrite splitting", duplicatedDataSourceNames))));
}
}
diff --git
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/ResourceDefinitionStatement.java
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/StorageUnitBackendHandler.java
similarity index 62%
rename from
distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/ResourceDefinitionStatement.java
rename to
proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/StorageUnitBackendHandler.java
index 5a33bdb74db..5f5c411d06c 100644
---
a/distsql/statement/src/main/java/org/apache/shardingsphere/distsql/parser/statement/rdl/ResourceDefinitionStatement.java
+++
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/StorageUnitBackendHandler.java
@@ -15,10 +15,20 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.distsql.parser.statement.rdl;
+package org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.resource;
+
+import
org.apache.shardingsphere.distsql.parser.statement.rdl.StorageUnitDefinitionStatement;
/**
- * Resource definition statement.
+ * Storage unit backend handler.
*/
-public abstract class ResourceDefinitionStatement extends RDLStatement {
+public interface StorageUnitBackendHandler<T extends
StorageUnitDefinitionStatement> {
+
+ /**
+ * Check SQL statement.
+ *
+ * @param databaseName database name
+ * @param sqlStatement SQL statement
+ */
+ void checkSQLStatement(String databaseName, T sqlStatement);
}
diff --git
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandler.java
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandler.java
index 063a2c456d3..b7af8365bc1 100644
---
a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandler.java
+++
b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandler.java
@@ -49,7 +49,7 @@ import java.util.stream.Collectors;
* Unregister storage unit backend handler.
*/
@Slf4j
-public final class UnregisterStorageUnitBackendHandler extends
DatabaseRequiredBackendHandler<UnregisterStorageUnitStatement> {
+public final class UnregisterStorageUnitBackendHandler extends
DatabaseRequiredBackendHandler<UnregisterStorageUnitStatement> implements
StorageUnitBackendHandler<UnregisterStorageUnitStatement> {
public UnregisterStorageUnitBackendHandler(final
UnregisterStorageUnitStatement sqlStatement, final ConnectionSession
connectionSession) {
super(sqlStatement, connectionSession);
@@ -57,10 +57,9 @@ public final class UnregisterStorageUnitBackendHandler
extends DatabaseRequiredB
@Override
public ResponseHeader execute(final String databaseName, final
UnregisterStorageUnitStatement sqlStatement) {
- Collection<String> toBeDroppedResourceNames = sqlStatement.getNames();
- check(databaseName, toBeDroppedResourceNames,
sqlStatement.isIgnoreSingleTables(), sqlStatement.isIfExists());
+ checkSQLStatement(databaseName, sqlStatement);
try {
-
ProxyContext.getInstance().getContextManager().dropResources(databaseName,
toBeDroppedResourceNames);
+
ProxyContext.getInstance().getContextManager().dropResources(databaseName,
sqlStatement.getStorageUnitNames());
} catch (final SQLException | ShardingSphereServerException ex) {
log.error("Unregister storage unit failed", ex);
throw new
InvalidResourcesException(Collections.singleton(ex.getMessage()));
@@ -68,52 +67,42 @@ public final class UnregisterStorageUnitBackendHandler
extends DatabaseRequiredB
return new UpdateResponseHeader(sqlStatement);
}
- private void check(final String databaseName, final Collection<String>
toBeDroppedResourceNames,
- final boolean ignoreSingleTables, final boolean
allowNotExist) {
- if (!allowNotExist) {
- checkResourceNameExisted(databaseName, toBeDroppedResourceNames);
+ @Override
+ public void checkSQLStatement(final String databaseName, final
UnregisterStorageUnitStatement sqlStatement) {
+ if (!sqlStatement.isIfExists()) {
+ checkExisted(databaseName, sqlStatement.getStorageUnitNames());
}
- checkResourceNameNotInUse(databaseName, toBeDroppedResourceNames,
ignoreSingleTables);
+ checkInUsed(databaseName, sqlStatement);
}
- private void checkResourceNameExisted(final String databaseName, final
Collection<String> resourceNames) {
- Map<String, DataSource> resources =
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getDataSources();
- Collection<String> notExistedResourceNames =
resourceNames.stream().filter(each ->
!resources.containsKey(each)).collect(Collectors.toList());
-
ShardingSpherePreconditions.checkState(notExistedResourceNames.isEmpty(), () ->
new MissingRequiredResourcesException(databaseName, notExistedResourceNames));
+ private void checkExisted(final String databaseName, final
Collection<String> storageUnitNames) {
+ Map<String, DataSource> dataSources =
ProxyContext.getInstance().getDatabase(databaseName).getResourceMetaData().getDataSources();
+ Collection<String> notExistedStorageUnits =
storageUnitNames.stream().filter(each ->
!dataSources.containsKey(each)).collect(Collectors.toList());
+
ShardingSpherePreconditions.checkState(notExistedStorageUnits.isEmpty(), () ->
new MissingRequiredResourcesException(databaseName, notExistedStorageUnits));
}
- private void checkResourceNameNotInUse(final String databaseName, final
Collection<String> toBeDroppedResourceNames, final boolean ignoreSingleTables) {
- Multimap<String, String> inUsedMultimap =
getInUsedResources(databaseName);
- Collection<String> inUsedResourceNames = inUsedMultimap.keySet();
- inUsedResourceNames.retainAll(toBeDroppedResourceNames);
- if (!inUsedResourceNames.isEmpty()) {
- if (ignoreSingleTables) {
- checkResourceNameNotInUseIgnoreSingleTableRule(new
HashSet<>(inUsedResourceNames), inUsedMultimap);
+ private void checkInUsed(final String databaseName, final
UnregisterStorageUnitStatement sqlStatement) {
+ Multimap<String, String> inUsedStorageUnits =
getInUsedResources(databaseName);
+ Collection<String> inUsedStorageUnitNames =
inUsedStorageUnits.keySet();
+ inUsedStorageUnitNames.retainAll(sqlStatement.getStorageUnitNames());
+ if (!inUsedStorageUnitNames.isEmpty()) {
+ if (sqlStatement.isIgnoreSingleTables()) {
+ checkInUsedIgnoreSingleTables(new
HashSet<>(inUsedStorageUnitNames), inUsedStorageUnits);
} else {
- String firstResource = inUsedResourceNames.iterator().next();
- throw new ResourceInUsedException(firstResource,
inUsedMultimap.get(firstResource));
+ String firstResource =
inUsedStorageUnitNames.iterator().next();
+ throw new ResourceInUsedException(firstResource,
inUsedStorageUnits.get(firstResource));
}
}
}
- private void checkResourceNameNotInUseIgnoreSingleTableRule(final
Collection<String> inUsedResourceNames, final Multimap<String, String>
inUsedMultimap) {
- for (String each : inUsedResourceNames) {
- Collection<String> inUsedRules = inUsedMultimap.get(each);
- inUsedRules.remove(SingleTableRule.class.getSimpleName());
- ShardingSpherePreconditions.checkState(inUsedRules.isEmpty(), ()
-> new ResourceInUsedException(each, inUsedRules));
- }
- }
-
private Multimap<String, String> getInUsedResources(final String
databaseName) {
Multimap<String, String> result = LinkedListMultimap.create();
for (ShardingSphereRule each :
ProxyContext.getInstance().getDatabase(databaseName).getRuleMetaData().getRules())
{
if (each instanceof DataSourceContainedRule) {
- Collection<String> inUsedResourceNames =
getInUsedResourceNames((DataSourceContainedRule) each);
- inUsedResourceNames.forEach(eachResource ->
result.put(eachResource, each.getType()));
+ getInUsedResourceNames((DataSourceContainedRule)
each).forEach(eachResource -> result.put(eachResource, each.getType()));
}
if (each instanceof DataNodeContainedRule) {
- Collection<String> inUsedResourceNames =
getInUsedResourceNames((DataNodeContainedRule) each);
- inUsedResourceNames.forEach(eachResource ->
result.put(eachResource, each.getType()));
+ getInUsedResourceNames((DataNodeContainedRule)
each).forEach(eachResource -> result.put(eachResource, each.getType()));
}
}
return result;
@@ -134,4 +123,12 @@ public final class UnregisterStorageUnitBackendHandler
extends DatabaseRequiredB
}
return result;
}
+
+ private void checkInUsedIgnoreSingleTables(final Collection<String>
inUsedResourceNames, final Multimap<String, String> inUsedStorageUnits) {
+ for (String each : inUsedResourceNames) {
+ Collection<String> inUsedRules = inUsedStorageUnits.get(each);
+ inUsedRules.remove(SingleTableRule.class.getSimpleName());
+ ShardingSpherePreconditions.checkState(inUsedRules.isEmpty(), ()
-> new ResourceInUsedException(each, inUsedRules));
+ }
+ }
}
diff --git
a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandlerTest.java
b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandlerTest.java
index a387277d5c1..c2d68553670 100644
---
a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandlerTest.java
+++
b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/resource/UnregisterStorageUnitBackendHandlerTest.java
@@ -104,7 +104,7 @@ public final class UnregisterStorageUnitBackendHandlerTest
extends ProxyContextR
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("test")).thenReturn(database);
UnregisterStorageUnitStatement unregisterStorageUnitStatement = new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), false);
assertThat(unregisterStorageUnitBackendHandler.execute("test",
unregisterStorageUnitStatement), instanceOf(UpdateResponseHeader.class));
- verify(contextManager).dropResources("test",
unregisterStorageUnitStatement.getNames());
+ verify(contextManager).dropResources("test",
unregisterStorageUnitStatement.getStorageUnitNames());
}
@Test(expected = MissingRequiredResourcesException.class)
@@ -148,14 +148,14 @@ public final class
UnregisterStorageUnitBackendHandlerTest extends ProxyContextR
when(contextManager.getMetaDataContexts().getMetaData().getDatabase("test")).thenReturn(database);
UnregisterStorageUnitStatement unregisterStorageUnitStatement = new
UnregisterStorageUnitStatement(Collections.singleton("foo_ds"), true);
assertThat(unregisterStorageUnitBackendHandler.execute("test",
unregisterStorageUnitStatement), instanceOf(UpdateResponseHeader.class));
- verify(contextManager).dropResources("test",
unregisterStorageUnitStatement.getNames());
+ verify(contextManager).dropResources("test",
unregisterStorageUnitStatement.getStorageUnitNames());
}
@Test
public void assertExecuteWithIfExists() throws SQLException {
UnregisterStorageUnitStatement unregisterStorageUnitStatement = new
UnregisterStorageUnitStatement(true, Collections.singleton("foo_ds"), true);
assertThat(unregisterStorageUnitBackendHandler.execute("test",
unregisterStorageUnitStatement), instanceOf(UpdateResponseHeader.class));
- verify(contextManager).dropResources("test",
unregisterStorageUnitStatement.getNames());
+ verify(contextManager).dropResources("test",
unregisterStorageUnitStatement.getStorageUnitNames());
}
@Test(expected = DistSQLException.class)
diff --git
a/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/alter/AlterStorageUnitStatementAssert.java
b/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/alter/AlterStorageUnitStatementAssert.java
index a678e2f1d72..ca7eac97b2e 100644
---
a/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/alter/AlterStorageUnitStatementAssert.java
+++
b/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/alter/AlterStorageUnitStatementAssert.java
@@ -30,9 +30,9 @@ import java.util.Collection;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
-import static org.hamcrest.MatcherAssert.assertThat;
/**
* Alter storage unit statement assert.
@@ -41,7 +41,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
public final class AlterStorageUnitStatementAssert {
/**
- * Assert alter resource statement is correct with expected parser result.
+ * Assert alter storage unit statement is correct with expected parser
result.
*
* @param assertContext assert context
* @param actual actual alter storage unit statement
@@ -52,16 +52,16 @@ public final class AlterStorageUnitStatementAssert {
assertNull(assertContext.getText("Actual statement should not
exist."), actual);
} else {
assertNotNull(assertContext.getText("Actual statement should
exist."), actual);
- assertDataSources(assertContext, actual.getDataSources(),
expected.getDataSources());
+ assertDataSources(assertContext, actual.getStorageUnits(),
expected.getDataSources());
}
}
private static void assertDataSources(final SQLCaseAssertContext
assertContext, final Collection<DataSourceSegment> actual, final
List<ExpectedDataSource> expected) {
if (null == expected) {
- assertNull(assertContext.getText("Actual datasource should not
exist."), actual);
+ assertNull(assertContext.getText("Actual storage unit should not
exist."), actual);
} else {
- assertNotNull(assertContext.getText("Actual datasource should
exist."), actual);
- assertThat(assertContext.getText(String.format("Actual datasource
size should be %s , but it was %s", expected.size(), actual.size())),
actual.size(), is(expected.size()));
+ assertNotNull(assertContext.getText("Actual storage unit should
exist."), actual);
+ assertThat(assertContext.getText(String.format("Actual storage
unit size should be %s , but it was %s", expected.size(), actual.size())),
actual.size(), is(expected.size()));
int count = 0;
for (DataSourceSegment actualDataSource : actual) {
DataSourceAssert.assertIs(assertContext, actualDataSource,
expected.get(count));
diff --git
a/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/create/RegisterStorageUnitStatementAssert.java
b/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/create/RegisterStorageUnitStatementAssert.java
index d6464f4ae20..dbdc97d1abc 100644
---
a/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/create/RegisterStorageUnitStatementAssert.java
+++
b/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/create/RegisterStorageUnitStatementAssert.java
@@ -30,9 +30,9 @@ import java.util.Collection;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
-import static org.hamcrest.MatcherAssert.assertThat;
/**
* Register storage unit statement assert.
@@ -41,7 +41,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
public final class RegisterStorageUnitStatementAssert {
/**
- * Assert add resource statement is correct with expected parser result.
+ * Assert register storage unit statement is correct with expected parser
result.
*
* @param assertContext assert context
* @param actual actual register storage unit statement
@@ -52,16 +52,16 @@ public final class RegisterStorageUnitStatementAssert {
assertNull(assertContext.getText("Actual statement should not
exist."), actual);
} else {
assertNotNull(assertContext.getText("Actual statement should
exist."), actual);
- assertDataSources(assertContext, actual.getDataSources(),
expected.getDataSources());
+ assertDataSources(assertContext, actual.getStorageUnits(),
expected.getDataSources());
}
}
private static void assertDataSources(final SQLCaseAssertContext
assertContext, final Collection<DataSourceSegment> actual, final
List<ExpectedDataSource> expected) {
if (null == expected) {
- assertNull(assertContext.getText("Actual datasource should not
exist."), actual);
+ assertNull(assertContext.getText("Actual storage unit should not
exist."), actual);
} else {
- assertNotNull(assertContext.getText("Actual datasource should
exist."), actual);
- assertThat(assertContext.getText(String.format("Actual datasource
size should be %s , but it was %s", expected.size(), actual.size())),
actual.size(), is(expected.size()));
+ assertNotNull(assertContext.getText("Actual storage unit should
exist."), actual);
+ assertThat(assertContext.getText(String.format("Actual storage
unit size should be %s , but it was %s", expected.size(), actual.size())),
actual.size(), is(expected.size()));
int count = 0;
for (DataSourceSegment actualDataSource : actual) {
DataSourceAssert.assertIs(assertContext, actualDataSource,
expected.get(count));
diff --git
a/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/drop/UnregisterStorageUnitStatementAssert.java
b/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/drop/UnregisterStorageUnitStatementAssert.java
index e9ce63b99c0..0c879b59b57 100644
---
a/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/drop/UnregisterStorageUnitStatementAssert.java
+++
b/test/parser/src/main/java/org/apache/shardingsphere/test/sql/parser/internal/asserts/statement/distsql/rdl/drop/UnregisterStorageUnitStatementAssert.java
@@ -24,8 +24,8 @@ import
org.apache.shardingsphere.test.sql.parser.internal.asserts.SQLCaseAssertC
import
org.apache.shardingsphere.test.sql.parser.internal.jaxb.cases.domain.statement.distsql.rdl.drop.UnregisterStorageUnitStatementTestCase;
import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertNull;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNull;
/**
* Unregister storage unit statement assert.
@@ -34,7 +34,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
public final class UnregisterStorageUnitStatementAssert {
/**
- * Assert drop resource statement is correct with expected parser result.
+ * Assert unregister storage unit statement is correct with expected
parser result.
*
* @param assertContext assert context
* @param actual actual unregister storage unit statement
@@ -42,11 +42,11 @@ public final class UnregisterStorageUnitStatementAssert {
*/
public static void assertIs(final SQLCaseAssertContext assertContext,
final UnregisterStorageUnitStatement actual, final
UnregisterStorageUnitStatementTestCase expected) {
if (null == expected.getDataSources()) {
- assertNull(assertContext.getText("Actual resource should not
exist."), actual);
+ assertNull(assertContext.getText("Actual storage unit should not
exist."), actual);
} else {
- assertThat(assertContext.getText("resource assertion error: "),
actual.getNames(), is(expected.getDataSources()));
- assertThat(assertContext.getText("resource assertion error: "),
actual.isIgnoreSingleTables(),
is(expected.getIgnoreSingleTables().iterator().next()));
- assertThat(assertContext.getText("resource assertion error: "),
actual.isIfExists(), is(expected.isIfExists()));
+ assertThat(assertContext.getText("storage unit assertion error:
"), actual.getStorageUnitNames(), is(expected.getDataSources()));
+ assertThat(assertContext.getText("storage unit assertion error:
"), actual.isIgnoreSingleTables(),
is(expected.getIgnoreSingleTables().iterator().next()));
+ assertThat(assertContext.getText("storage unit assertion error:
"), actual.isIfExists(), is(expected.isIfExists()));
}
}
}
