You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2022/12/24 10:32:15 UTC
[shardingsphere] branch master updated: Rename single table module to single module and SingleTableRuleConfiguration to SingleRuleConfiguration (#23076)
This is an automated email from the ASF dual-hosted git repository.
zhaojinchao 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 25ef2d562f7 Rename single table module to single module and SingleTableRuleConfiguration to SingleRuleConfiguration (#23076)
25ef2d562f7 is described below
commit 25ef2d562f78d6ebb9d6a8df25befdbe5de7238f
Author: Zhengqiang Duan <du...@apache.org>
AuthorDate: Sat Dec 24 18:32:08 2022 +0800
Rename single table module to single module and SingleTableRuleConfiguration to SingleRuleConfiguration (#23076)
* Rename single table module to single module and SingleTableRuleConfiguration to SingleRuleConfiguration
* rename param
* fix unit test
---
features/encrypt/core/pom.xml | 2 +-
features/sharding/core/pom.xml | 2 +-
.../engine/fixture/AbstractRoutingEngineTest.java | 8 ++--
.../engine/type/standard/AbstractSQLRouteTest.java | 8 ++--
jdbc/core/pom.xml | 2 +-
kernel/pom.xml | 2 +-
...atabase.DefaultDatabaseRuleConfigurationBuilder | 18 ---------
...onfig.swapper.rule.YamlRuleConfigurationSwapper | 18 ---------
kernel/{single-table => single}/api/pom.xml | 4 +-
.../api/config/SingleRuleConfiguration.java} | 6 +--
kernel/{single-table => single}/core/pom.xml | 6 +--
.../single/constant/SingleOrder.java} | 8 ++--
.../datanode/SingleTableDataNodeLoader.java | 4 +-
.../decider/SingleSQLFederationDecider.java} | 24 +++++------
.../exception/DropNotEmptySchemaException.java | 2 +-
.../exception/SingleTableNotFoundException.java | 2 +-
.../exception/SingleTablesLoadingException.java | 2 +-
.../UnsupportedDropCascadeTableException.java | 2 +-
.../metadata/SingleSchemaMetaDataDecorator.java} | 18 ++++-----
.../single/route/SingleSQLRouter.java} | 38 +++++++++---------
.../SingleDatabaseBroadcastRouteEngine.java} | 12 +++---
.../single/route/engine/SingleRouteEngine.java} | 12 +++---
.../route/engine/SingleRouteEngineFactory.java} | 14 +++----
.../route/engine/SingleStandardRouteEngine.java} | 24 +++++------
.../route/validator/SingleMetaDataValidator.java} | 10 ++---
.../validator/SingleMetaDataValidatorFactory.java} | 18 ++++-----
.../ddl/SingleDropSchemaMetaDataValidator.java} | 14 +++----
.../validator/ddl/SingleDropTableValidator.java} | 14 +++----
.../shardingsphere/single/rule/SingleRule.java} | 18 ++++-----
.../DefaultSingleRuleConfigurationBuilder.java} | 20 +++++-----
.../single/rule/builder/SingleRuleBuilder.java} | 24 +++++------
.../config/pojo/YamlSingleRuleConfiguration.java} | 12 +++---
.../YamlSingleRuleConfigurationSwapper.java} | 26 ++++++------
...phere.infra.binder.decider.SQLFederationDecider | 2 +-
....decorator.spi.RuleBasedSchemaMetaDataDecorator | 2 +-
...org.apache.shardingsphere.infra.route.SQLRouter | 2 +-
...infra.rule.builder.database.DatabaseRuleBuilder | 2 +-
...tabase.DefaultDatabaseRuleConfigurationBuilder} | 2 +-
...nfig.swapper.rule.YamlRuleConfigurationSwapper} | 2 +-
.../datanode/SingleTableDataNodeLoaderTest.java | 2 +-
.../decider/SingleSQLFederationDeciderTest.java} | 30 +++++++-------
.../SingleSchemaMetaDataDecoratorTest.java} | 14 +++----
.../single/route/SingleSQLRouterTest.java} | 32 +++++++--------
.../SingleDatabaseBroadcastRouteEngineTest.java} | 14 +++----
.../engine/SingleRouteEngineFactoryTest.java} | 14 +++----
.../engine/SingleStandardRouteEngineTest.java} | 46 +++++++++++-----------
.../SingleMetaDataValidatorFactoryTest.java} | 8 ++--
.../SingleDropSchemaMetaDataValidatorTest.java} | 14 +++----
.../single/rule/SingleRuleTest.java} | 40 +++++++++----------
...DefaultSingleRuleConfigurationBuilderTest.java} | 10 ++---
.../rule/builder/SingleRuleBuilderTest.java} | 16 ++++----
.../YamlSingleRuleConfigurationSwapperTest.java} | 20 +++++-----
kernel/{single-table => single}/pom.xml | 2 +-
mode/type/cluster/core/pom.xml | 2 +-
proxy/backend/pom.xml | 2 +-
.../ExportDatabaseConfigurationHandler.java | 6 +--
.../UnregisterStorageUnitBackendHandler.java | 4 +-
...aultSingleTableStorageUnitStatementUpdater.java | 16 ++++----
.../rql/rule/CountSingleTableRuleResultSet.java | 6 +--
.../distsql/rql/rule/SingleTableResultSet.java | 6 +--
.../distsql/rql/rule/SingleTableRuleResultSet.java | 4 +-
.../UnregisterStorageUnitBackendHandlerTest.java | 6 +--
...etDefaultSingleTableStorageUnitUpdaterTest.java | 14 +++----
.../rql/CountSingleTableRuleResultSetTest.java | 10 ++---
.../distsql/rql/SingleTableResultSetTest.java | 6 +--
.../distsql/rql/SingleTableRuleResultSetTest.java | 10 ++---
test/it/rewriter/pom.xml | 2 +-
.../it/rewrite/scenario/EncryptSQLRewriterIT.java | 4 +-
.../it/rewrite/scenario/ShardingSQLRewriterIT.java | 4 +-
69 files changed, 367 insertions(+), 403 deletions(-)
diff --git a/features/encrypt/core/pom.xml b/features/encrypt/core/pom.xml
index 302cae3937e..579fd5c89d1 100644
--- a/features/encrypt/core/pom.xml
+++ b/features/encrypt/core/pom.xml
@@ -57,7 +57,7 @@
</dependency>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table-core</artifactId>
+ <artifactId>shardingsphere-single-core</artifactId>
<version>${project.version}</version>
<scope>test</scope>
</dependency>
diff --git a/features/sharding/core/pom.xml b/features/sharding/core/pom.xml
index 49a5b444d65..73c485560e8 100644
--- a/features/sharding/core/pom.xml
+++ b/features/sharding/core/pom.xml
@@ -88,7 +88,7 @@
</dependency>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table-core</artifactId>
+ <artifactId>shardingsphere-single-core</artifactId>
<version>${project.version}</version>
<scope>test</scope>
</dependency>
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/AbstractRoutingEngineTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/AbstractRoutingEngineTest.java
index 6165c42e3be..b21b1ca8d66 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/AbstractRoutingEngineTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/AbstractRoutingEngineTest.java
@@ -34,8 +34,8 @@ import org.apache.shardingsphere.sharding.route.engine.condition.ShardingConditi
import org.apache.shardingsphere.sharding.route.engine.condition.value.ListShardingConditionValue;
import org.apache.shardingsphere.sharding.route.engine.condition.value.ShardingConditionValue;
import org.apache.shardingsphere.sharding.rule.ShardingRule;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
import javax.sql.DataSource;
@@ -239,9 +239,9 @@ public abstract class AbstractRoutingEngineTest {
return Arrays.asList("ds_0", "ds_1");
}
- protected final SingleTableRule createSingleTableRule(final Collection<ShardingSphereRule> rules) {
+ protected final SingleRule createSingleRule(final Collection<ShardingSphereRule> rules) {
Map<String, DataSource> dataSourceMap = createDataSourceMap();
- SingleTableRule result = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, rules);
+ SingleRule result = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, rules);
result.put(dataSourceMap.keySet().iterator().next(), DefaultDatabase.LOGIC_NAME, "t_category");
return result;
}
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/type/standard/AbstractSQLRouteTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/type/standard/AbstractSQLRouteTest.java
index 395e03712e7..0fa13cabc63 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/type/standard/AbstractSQLRouteTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/type/standard/AbstractSQLRouteTest.java
@@ -37,7 +37,7 @@ import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.engine.SQLRouteEngine;
import org.apache.shardingsphere.sharding.route.engine.fixture.AbstractRoutingEngineTest;
import org.apache.shardingsphere.sharding.rule.ShardingRule;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.api.CacheOption;
import java.sql.Types;
@@ -56,19 +56,19 @@ public abstract class AbstractSQLRouteTest extends AbstractRoutingEngineTest {
protected final RouteContext assertRoute(final String sql, final List<Object> params) {
ShardingRule shardingRule = createAllShardingRule();
- SingleTableRule singleTableRule = createSingleTableRule(Collections.singletonList(shardingRule));
+ SingleRule singleRule = createSingleRule(Collections.singletonList(shardingRule));
Map<String, ShardingSphereSchema> schemas = buildSchemas();
ConfigurationProperties props = new ConfigurationProperties(new Properties());
SQLStatementParserEngine sqlStatementParserEngine = new SQLStatementParserEngine("MySQL",
new CacheOption(2000, 65535L), new CacheOption(128, 1024L), false);
- ShardingSphereRuleMetaData ruleMetaData = new ShardingSphereRuleMetaData(Arrays.asList(shardingRule, singleTableRule));
+ ShardingSphereRuleMetaData ruleMetaData = new ShardingSphereRuleMetaData(Arrays.asList(shardingRule, singleRule));
ShardingSphereResourceMetaData resourceMetaData = mock(ShardingSphereResourceMetaData.class, RETURNS_DEEP_STUBS);
when(resourceMetaData.getStorageTypes()).thenReturn(Collections.singletonMap("ds_0", new MySQLDatabaseType()));
ShardingSphereDatabase database = new ShardingSphereDatabase(DefaultDatabase.LOGIC_NAME, DatabaseTypeFactory.getInstance("MySQL"), resourceMetaData, ruleMetaData, schemas);
SQLStatementContext<?> sqlStatementContext =
SQLStatementContextFactory.newInstance(createShardingSphereMetaData(database), params, sqlStatementParserEngine.parse(sql, false), DefaultDatabase.LOGIC_NAME);
QueryContext queryContext = new QueryContext(sqlStatementContext, sql, params);
- return new SQLRouteEngine(Arrays.asList(shardingRule, singleTableRule), props).route(new ConnectionContext(), queryContext, database);
+ return new SQLRouteEngine(Arrays.asList(shardingRule, singleRule), props).route(new ConnectionContext(), queryContext, database);
}
private ShardingSphereMetaData createShardingSphereMetaData(final ShardingSphereDatabase database) {
diff --git a/jdbc/core/pom.xml b/jdbc/core/pom.xml
index 63391be7601..8aab9232919 100644
--- a/jdbc/core/pom.xml
+++ b/jdbc/core/pom.xml
@@ -82,7 +82,7 @@
</dependency>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table-core</artifactId>
+ <artifactId>shardingsphere-single-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
diff --git a/kernel/pom.xml b/kernel/pom.xml
index 93c50e4b8e3..089febb6aec 100644
--- a/kernel/pom.xml
+++ b/kernel/pom.xml
@@ -30,7 +30,7 @@
<modules>
<module>parser</module>
- <module>single-table</module>
+ <module>single</module>
<module>authority</module>
<module>transaction</module>
<module>schedule</module>
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder b/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder
deleted file mode 100644
index da3bf4db815..00000000000
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder
+++ /dev/null
@@ -1,18 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-org.apache.shardingsphere.singletable.rule.builder.DefaultSingleTableDatabaseRuleConfigurationBuilder
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper b/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper
deleted file mode 100644
index 2f52918197f..00000000000
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper
+++ /dev/null
@@ -1,18 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-org.apache.shardingsphere.singletable.yaml.config.swapper.YamlSingleTableRuleConfigurationSwapper
diff --git a/kernel/single-table/api/pom.xml b/kernel/single/api/pom.xml
similarity index 92%
rename from kernel/single-table/api/pom.xml
rename to kernel/single/api/pom.xml
index d5f04bc55a5..d11e90b0828 100644
--- a/kernel/single-table/api/pom.xml
+++ b/kernel/single/api/pom.xml
@@ -21,10 +21,10 @@
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table</artifactId>
+ <artifactId>shardingsphere-single</artifactId>
<version>5.3.1-SNAPSHOT</version>
</parent>
- <artifactId>shardingsphere-single-table-api</artifactId>
+ <artifactId>shardingsphere-single-api</artifactId>
<name>${project.artifactId}</name>
<dependencies>
diff --git a/kernel/single-table/api/src/main/java/org/apache/shardingsphere/singletable/config/SingleTableRuleConfiguration.java b/kernel/single/api/src/main/java/org/apache/shardingsphere/single/api/config/SingleRuleConfiguration.java
similarity index 87%
rename from kernel/single-table/api/src/main/java/org/apache/shardingsphere/singletable/config/SingleTableRuleConfiguration.java
rename to kernel/single/api/src/main/java/org/apache/shardingsphere/single/api/config/SingleRuleConfiguration.java
index bf815c3139d..8b98a6db138 100644
--- a/kernel/single-table/api/src/main/java/org/apache/shardingsphere/singletable/config/SingleTableRuleConfiguration.java
+++ b/kernel/single/api/src/main/java/org/apache/shardingsphere/single/api/config/SingleRuleConfiguration.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.config;
+package org.apache.shardingsphere.single.api.config;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
@@ -26,12 +26,12 @@ import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfigurati
import java.util.Optional;
/**
- * Single table rule configuration.
+ * Single rule configuration.
*/
@AllArgsConstructor
@NoArgsConstructor
@Setter
-public final class SingleTableRuleConfiguration implements DatabaseRuleConfiguration, EnhancedRuleConfiguration {
+public final class SingleRuleConfiguration implements DatabaseRuleConfiguration, EnhancedRuleConfiguration {
private String defaultDataSource;
diff --git a/kernel/single-table/core/pom.xml b/kernel/single/core/pom.xml
similarity index 91%
rename from kernel/single-table/core/pom.xml
rename to kernel/single/core/pom.xml
index fa98c41d9bb..9bb4671437d 100644
--- a/kernel/single-table/core/pom.xml
+++ b/kernel/single/core/pom.xml
@@ -21,16 +21,16 @@
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table</artifactId>
+ <artifactId>shardingsphere-single</artifactId>
<version>5.3.1-SNAPSHOT</version>
</parent>
- <artifactId>shardingsphere-single-table-core</artifactId>
+ <artifactId>shardingsphere-single-core</artifactId>
<name>${project.artifactId}</name>
<dependencies>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table-api</artifactId>
+ <artifactId>shardingsphere-single-api</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/constant/SingleTableOrder.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/constant/SingleOrder.java
similarity index 87%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/constant/SingleTableOrder.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/constant/SingleOrder.java
index 47764109a6f..461eeb7526c 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/constant/SingleTableOrder.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/constant/SingleOrder.java
@@ -15,19 +15,19 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.constant;
+package org.apache.shardingsphere.single.constant;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
/**
- * Single table order.
+ * Single order.
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class SingleTableOrder {
+public final class SingleOrder {
/**
- * Single table order.
+ * Single order.
*/
public static final int ORDER = 0;
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/datanode/SingleTableDataNodeLoader.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoader.java
similarity index 96%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/datanode/SingleTableDataNodeLoader.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoader.java
index a023e877a82..7a605b8e57d 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/datanode/SingleTableDataNodeLoader.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoader.java
@@ -15,14 +15,14 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.datanode;
+package org.apache.shardingsphere.single.datanode;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.metadata.database.schema.loader.common.SchemaMetaDataLoader;
-import org.apache.shardingsphere.singletable.exception.SingleTablesLoadingException;
+import org.apache.shardingsphere.single.exception.SingleTablesLoadingException;
import javax.sql.DataSource;
import java.sql.SQLException;
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/decider/SingleTableSQLFederationDecider.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDecider.java
similarity index 86%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/decider/SingleTableSQLFederationDecider.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDecider.java
index 02cc7b500ef..5de1955e8a0 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/decider/SingleTableSQLFederationDecider.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDecider.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.decider;
+package org.apache.shardingsphere.single.decider;
import org.apache.shardingsphere.infra.binder.QueryContext;
import org.apache.shardingsphere.infra.binder.decider.SQLFederationDecider;
@@ -30,8 +30,8 @@ import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
import org.apache.shardingsphere.infra.metadata.database.schema.util.IndexMetaDataUtil;
-import org.apache.shardingsphere.singletable.constant.SingleTableOrder;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.constant.SingleOrder;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.SimpleTableSegment;
import java.util.Collection;
@@ -39,13 +39,13 @@ import java.util.LinkedList;
import java.util.Optional;
/**
- * Single table SQL federation decider.
+ * Single SQL federation decider.
*/
-public final class SingleTableSQLFederationDecider implements SQLFederationDecider<SingleTableRule> {
+public final class SingleSQLFederationDecider implements SQLFederationDecider<SingleRule> {
@Override
public void decide(final SQLFederationDeciderContext deciderContext, final QueryContext queryContext,
- final ShardingSphereDatabase database, final SingleTableRule rule, final ConfigurationProperties props) {
+ final ShardingSphereDatabase database, final SingleRule rule, final ConfigurationProperties props) {
SelectStatementContext select = (SelectStatementContext) queryContext.getSqlStatementContext();
Collection<QualifiedTable> singleTableNames = getSingleTableNames(select, database, rule);
if (singleTableNames.isEmpty()) {
@@ -59,13 +59,13 @@ public final class SingleTableSQLFederationDecider implements SQLFederationDecid
addTableDataNodes(deciderContext, rule, singleTableNames);
}
- private static void addTableDataNodes(final SQLFederationDeciderContext deciderContext, final SingleTableRule rule, final Collection<QualifiedTable> singleTableNames) {
+ private static void addTableDataNodes(final SQLFederationDeciderContext deciderContext, final SingleRule rule, final Collection<QualifiedTable> singleTableNames) {
for (QualifiedTable each : singleTableNames) {
rule.findSingleTableDataNode(each.getSchemaName(), each.getTableName()).ifPresent(optional -> deciderContext.getDataNodes().add(optional));
}
}
- private static boolean isAllTablesInSameDataSource(final SQLFederationDeciderContext deciderContext, final SingleTableRule rule, final Collection<QualifiedTable> singleTableNames) {
+ private static boolean isAllTablesInSameDataSource(final SQLFederationDeciderContext deciderContext, final SingleRule rule, final Collection<QualifiedTable> singleTableNames) {
if (!rule.isSingleTablesInSameDataSource(singleTableNames)) {
return false;
}
@@ -83,7 +83,7 @@ public final class SingleTableSQLFederationDecider implements SQLFederationDecid
}
private static Collection<QualifiedTable> getSingleTableNames(final SQLStatementContext<?> sqlStatementContext,
- final ShardingSphereDatabase database, final SingleTableRule rule) {
+ final ShardingSphereDatabase database, final SingleRule rule) {
DatabaseType databaseType = sqlStatementContext.getDatabaseType();
Collection<QualifiedTable> result = getQualifiedTables(database, databaseType, sqlStatementContext.getTablesContext().getTables());
if (result.isEmpty() && sqlStatementContext instanceof IndexAvailable) {
@@ -113,11 +113,11 @@ public final class SingleTableSQLFederationDecider implements SQLFederationDecid
@Override
public int getOrder() {
- return SingleTableOrder.ORDER;
+ return SingleOrder.ORDER;
}
@Override
- public Class<SingleTableRule> getTypeClass() {
- return SingleTableRule.class;
+ public Class<SingleRule> getTypeClass() {
+ return SingleRule.class;
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/DropNotEmptySchemaException.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/DropNotEmptySchemaException.java
similarity index 96%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/DropNotEmptySchemaException.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/DropNotEmptySchemaException.java
index 7b3a863cbd4..4346fb91f72 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/DropNotEmptySchemaException.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/DropNotEmptySchemaException.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.exception;
+package org.apache.shardingsphere.single.exception;
import org.apache.shardingsphere.infra.exception.MetaDataSQLException;
import org.apache.shardingsphere.infra.util.exception.external.sql.sqlstate.XOpenSQLState;
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/SingleTableNotFoundException.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/SingleTableNotFoundException.java
similarity index 95%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/SingleTableNotFoundException.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/SingleTableNotFoundException.java
index 9582268f9fe..564a8f0be25 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/SingleTableNotFoundException.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/SingleTableNotFoundException.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.exception;
+package org.apache.shardingsphere.single.exception;
import org.apache.shardingsphere.infra.exception.MetaDataSQLException;
import org.apache.shardingsphere.infra.util.exception.external.sql.sqlstate.XOpenSQLState;
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/SingleTablesLoadingException.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/SingleTablesLoadingException.java
similarity index 96%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/SingleTablesLoadingException.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/SingleTablesLoadingException.java
index 1b1af3dccc6..a0546f5b1ba 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/SingleTablesLoadingException.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/SingleTablesLoadingException.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.exception;
+package org.apache.shardingsphere.single.exception;
import org.apache.shardingsphere.infra.exception.MetaDataSQLException;
import org.apache.shardingsphere.infra.util.exception.external.sql.sqlstate.XOpenSQLState;
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/UnsupportedDropCascadeTableException.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/UnsupportedDropCascadeTableException.java
similarity index 95%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/UnsupportedDropCascadeTableException.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/UnsupportedDropCascadeTableException.java
index e966b08d5fe..305fae2f37d 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/exception/UnsupportedDropCascadeTableException.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/exception/UnsupportedDropCascadeTableException.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.exception;
+package org.apache.shardingsphere.single.exception;
import org.apache.shardingsphere.infra.exception.SyntaxSQLException;
import org.apache.shardingsphere.infra.util.exception.external.sql.sqlstate.XOpenSQLState;
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/metadata/SingleTableSchemaMetaDataDecorator.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/metadata/SingleSchemaMetaDataDecorator.java
similarity index 84%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/metadata/SingleTableSchemaMetaDataDecorator.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/metadata/SingleSchemaMetaDataDecorator.java
index 52a20e4e91e..e7e45316860 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/metadata/SingleTableSchemaMetaDataDecorator.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/metadata/SingleSchemaMetaDataDecorator.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.metadata;
+package org.apache.shardingsphere.single.metadata;
import org.apache.shardingsphere.infra.metadata.database.schema.builder.GenericSchemaBuilderMaterial;
import org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator;
@@ -24,8 +24,8 @@ import org.apache.shardingsphere.infra.metadata.database.schema.loader.model.Ind
import org.apache.shardingsphere.infra.metadata.database.schema.loader.model.SchemaMetaData;
import org.apache.shardingsphere.infra.metadata.database.schema.loader.model.TableMetaData;
import org.apache.shardingsphere.infra.metadata.database.schema.util.IndexMetaDataUtil;
-import org.apache.shardingsphere.singletable.constant.SingleTableOrder;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.constant.SingleOrder;
+import org.apache.shardingsphere.single.rule.SingleRule;
import java.util.Collection;
import java.util.LinkedHashMap;
@@ -35,12 +35,12 @@ import java.util.Map.Entry;
import java.util.stream.Collectors;
/**
- * Schema meta data decorator for single table.
+ * Schema meta data decorator for single.
*/
-public final class SingleTableSchemaMetaDataDecorator implements RuleBasedSchemaMetaDataDecorator<SingleTableRule> {
+public final class SingleSchemaMetaDataDecorator implements RuleBasedSchemaMetaDataDecorator<SingleRule> {
@Override
- public Map<String, SchemaMetaData> decorate(final Map<String, SchemaMetaData> schemaMetaDataMap, final SingleTableRule rule, final GenericSchemaBuilderMaterial material) {
+ public Map<String, SchemaMetaData> decorate(final Map<String, SchemaMetaData> schemaMetaDataMap, final SingleRule rule, final GenericSchemaBuilderMaterial material) {
Map<String, SchemaMetaData> result = new LinkedHashMap<>();
for (Entry<String, SchemaMetaData> entry : schemaMetaDataMap.entrySet()) {
Collection<TableMetaData> tables = new LinkedList<>();
@@ -67,11 +67,11 @@ public final class SingleTableSchemaMetaDataDecorator implements RuleBasedSchema
@Override
public int getOrder() {
- return SingleTableOrder.ORDER;
+ return SingleOrder.ORDER;
}
@Override
- public Class<SingleTableRule> getTypeClass() {
- return SingleTableRule.class;
+ public Class<SingleRule> getTypeClass() {
+ return SingleRule.class;
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouter.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/SingleSQLRouter.java
similarity index 80%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouter.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/SingleSQLRouter.java
index b27d5c3ddfb..b0d0f0400c4 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouter.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/SingleSQLRouter.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route;
+package org.apache.shardingsphere.single.route;
import com.google.common.base.Preconditions;
import org.apache.shardingsphere.infra.binder.QueryContext;
@@ -34,11 +34,11 @@ import org.apache.shardingsphere.infra.route.SQLRouter;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
-import org.apache.shardingsphere.singletable.constant.SingleTableOrder;
-import org.apache.shardingsphere.singletable.route.engine.SingleTableRouteEngineFactory;
-import org.apache.shardingsphere.singletable.route.validator.SingleTableMetaDataValidator;
-import org.apache.shardingsphere.singletable.route.validator.SingleTableMetaDataValidatorFactory;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.constant.SingleOrder;
+import org.apache.shardingsphere.single.route.engine.SingleRouteEngineFactory;
+import org.apache.shardingsphere.single.route.validator.SingleMetaDataValidator;
+import org.apache.shardingsphere.single.route.validator.SingleMetaDataValidatorFactory;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.SimpleTableSegment;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.CreateTableStatement;
@@ -48,42 +48,42 @@ import java.util.LinkedList;
import java.util.Optional;
/**
- * Single table SQL router.
+ * Single SQL router.
*/
-public final class SingleTableSQLRouter implements SQLRouter<SingleTableRule> {
+public final class SingleSQLRouter implements SQLRouter<SingleRule> {
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
- public RouteContext createRouteContext(final QueryContext queryContext, final ShardingSphereDatabase database, final SingleTableRule rule,
+ public RouteContext createRouteContext(final QueryContext queryContext, final ShardingSphereDatabase database, final SingleRule rule,
final ConfigurationProperties props, final ConnectionContext connectionContext) {
if (1 == database.getResourceMetaData().getDataSources().size()) {
return createSingleDataSourceRouteContext(rule, database);
}
RouteContext result = new RouteContext();
SQLStatementContext<?> sqlStatementContext = queryContext.getSqlStatementContext();
- Optional<SingleTableMetaDataValidator> validator = SingleTableMetaDataValidatorFactory.newInstance(sqlStatementContext.getSqlStatement());
+ Optional<SingleMetaDataValidator> validator = SingleMetaDataValidatorFactory.newInstance(sqlStatementContext.getSqlStatement());
validator.ifPresent(optional -> optional.validate(rule, sqlStatementContext, database));
Collection<QualifiedTable> singleTableNames = getSingleTableNames(sqlStatementContext, database, rule, result);
if (!singleTableNames.isEmpty()) {
validateSameDataSource(sqlStatementContext, rule, props, singleTableNames, result);
}
- SingleTableRouteEngineFactory.newInstance(singleTableNames, sqlStatementContext.getSqlStatement()).ifPresent(optional -> optional.route(result, rule));
+ SingleRouteEngineFactory.newInstance(singleTableNames, sqlStatementContext.getSqlStatement()).ifPresent(optional -> optional.route(result, rule));
return result;
}
@Override
public void decorateRouteContext(final RouteContext routeContext, final QueryContext queryContext, final ShardingSphereDatabase database,
- final SingleTableRule rule, final ConfigurationProperties props, final ConnectionContext connectionContext) {
+ final SingleRule rule, final ConfigurationProperties props, final ConnectionContext connectionContext) {
SQLStatementContext<?> sqlStatementContext = queryContext.getSqlStatementContext();
Collection<QualifiedTable> singleTableNames = getSingleTableNames(sqlStatementContext, database, rule, routeContext);
if (singleTableNames.isEmpty()) {
return;
}
validateSameDataSource(sqlStatementContext, rule, props, singleTableNames, routeContext);
- SingleTableRouteEngineFactory.newInstance(singleTableNames, sqlStatementContext.getSqlStatement()).ifPresent(optional -> optional.route(routeContext, rule));
+ SingleRouteEngineFactory.newInstance(singleTableNames, sqlStatementContext.getSqlStatement()).ifPresent(optional -> optional.route(routeContext, rule));
}
- private RouteContext createSingleDataSourceRouteContext(final SingleTableRule rule, final ShardingSphereDatabase database) {
+ private RouteContext createSingleDataSourceRouteContext(final SingleRule rule, final ShardingSphereDatabase database) {
String logicDataSource = rule.getDataSourceNames().iterator().next();
String actualDataSource = database.getResourceMetaData().getDataSources().keySet().iterator().next();
RouteContext result = new RouteContext();
@@ -92,7 +92,7 @@ public final class SingleTableSQLRouter implements SQLRouter<SingleTableRule> {
}
private static Collection<QualifiedTable> getSingleTableNames(final SQLStatementContext<?> sqlStatementContext,
- final ShardingSphereDatabase database, final SingleTableRule rule, final RouteContext routeContext) {
+ final ShardingSphereDatabase database, final SingleRule rule, final RouteContext routeContext) {
DatabaseType databaseType = sqlStatementContext.getDatabaseType();
Collection<QualifiedTable> result = getQualifiedTables(database, databaseType, sqlStatementContext.getTablesContext().getTables());
if (result.isEmpty() && sqlStatementContext instanceof IndexAvailable) {
@@ -111,7 +111,7 @@ public final class SingleTableSQLRouter implements SQLRouter<SingleTableRule> {
return result;
}
- private static void validateSameDataSource(final SQLStatementContext<?> sqlStatementContext, final SingleTableRule rule,
+ private static void validateSameDataSource(final SQLStatementContext<?> sqlStatementContext, final SingleRule rule,
final ConfigurationProperties props, final Collection<QualifiedTable> singleTableNames, final RouteContext routeContext) {
String sqlFederationType = props.getValue(ConfigurationPropertyKey.SQL_FEDERATION_TYPE);
boolean allTablesInSameDataSource = !"NONE".equals(sqlFederationType)
@@ -122,11 +122,11 @@ public final class SingleTableSQLRouter implements SQLRouter<SingleTableRule> {
@Override
public int getOrder() {
- return SingleTableOrder.ORDER;
+ return SingleOrder.ORDER;
}
@Override
- public Class<SingleTableRule> getTypeClass() {
- return SingleTableRule.class;
+ public Class<SingleRule> getTypeClass() {
+ return SingleRule.class;
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableDatabaseBroadcastRouteEngine.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngine.java
similarity index 77%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableDatabaseBroadcastRouteEngine.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngine.java
index 2f09f22bfc3..6df1e847cea 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableDatabaseBroadcastRouteEngine.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngine.java
@@ -15,23 +15,23 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.engine;
+package org.apache.shardingsphere.single.route.engine;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import java.util.Collections;
/**
- * Single table databases broadcast route engine.
+ * Single databases broadcast route engine.
*/
-public final class SingleTableDatabaseBroadcastRouteEngine implements SingleTableRouteEngine {
+public final class SingleDatabaseBroadcastRouteEngine implements SingleRouteEngine {
@Override
- public void route(final RouteContext routeContext, final SingleTableRule singleTableRule) {
- for (String each : singleTableRule.getDataSourceNames()) {
+ public void route(final RouteContext routeContext, final SingleRule singleRule) {
+ for (String each : singleRule.getDataSourceNames()) {
routeContext.getRouteUnits().add(new RouteUnit(new RouteMapper(each, each), Collections.emptyList()));
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngine.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngine.java
similarity index 74%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngine.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngine.java
index 4e4d6c4cd85..64de553484a 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngine.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngine.java
@@ -15,21 +15,21 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.engine;
+package org.apache.shardingsphere.single.route.engine;
import org.apache.shardingsphere.infra.route.context.RouteContext;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
/**
- * Single table route engine.
+ * Single route engine.
*/
-public interface SingleTableRouteEngine {
+public interface SingleRouteEngine {
/**
* Route.
*
* @param routeContext route context
- * @param singleTableRule single table rule
+ * @param singleRule single rule
*/
- void route(RouteContext routeContext, SingleTableRule singleTableRule);
+ void route(RouteContext routeContext, SingleRule singleRule);
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngineFactory.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngineFactory.java
similarity index 79%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngineFactory.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngineFactory.java
index acd9a3f9d83..01983c4501b 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngineFactory.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngineFactory.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.engine;
+package org.apache.shardingsphere.single.route.engine;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
@@ -29,25 +29,25 @@ import java.util.Collection;
import java.util.Optional;
/**
- * Single table route engine factory.
+ * Single route engine factory.
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class SingleTableRouteEngineFactory {
+public final class SingleRouteEngineFactory {
/**
- * Create new instance of single table route engine.
+ * Create new instance of single route engine.
*
* @param singleTableNames single table names
* @param sqlStatement SQL statement
* @return created instance
*/
- public static Optional<SingleTableRouteEngine> newInstance(final Collection<QualifiedTable> singleTableNames, final SQLStatement sqlStatement) {
+ public static Optional<SingleRouteEngine> newInstance(final Collection<QualifiedTable> singleTableNames, final SQLStatement sqlStatement) {
// TODO Consider to add route logic for more statements
if (!singleTableNames.isEmpty()) {
- return Optional.of(new SingleTableStandardRouteEngine(singleTableNames, sqlStatement));
+ return Optional.of(new SingleStandardRouteEngine(singleTableNames, sqlStatement));
}
if (isSchemaDDLStatement(sqlStatement)) {
- return Optional.of(new SingleTableDatabaseBroadcastRouteEngine());
+ return Optional.of(new SingleDatabaseBroadcastRouteEngine());
}
return Optional.empty();
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableStandardRouteEngine.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngine.java
similarity index 87%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableStandardRouteEngine.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngine.java
index 888468985a2..48c957ffa18 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/engine/SingleTableStandardRouteEngine.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngine.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.engine;
+package org.apache.shardingsphere.single.route.engine;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.dialect.exception.syntax.table.TableExistsException;
@@ -24,8 +24,8 @@ import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
-import org.apache.shardingsphere.singletable.exception.SingleTableNotFoundException;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.exception.SingleTableNotFoundException;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.AlterTableStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.CreateTableStatement;
@@ -42,10 +42,10 @@ import java.util.function.Function;
import java.util.stream.Collectors;
/**
- * Single table standard route engine.
+ * Single standard route engine.
*/
@RequiredArgsConstructor
-public final class SingleTableStandardRouteEngine implements SingleTableRouteEngine {
+public final class SingleStandardRouteEngine implements SingleRouteEngine {
private final Collection<QualifiedTable> singleTableNames;
@@ -55,14 +55,14 @@ public final class SingleTableStandardRouteEngine implements SingleTableRouteEng
* Route for single table.
*
* @param routeContext route context
- * @param rule single table rule
+ * @param singleRule single table rule
*/
- public void route(final RouteContext routeContext, final SingleTableRule rule) {
+ public void route(final RouteContext routeContext, final SingleRule singleRule) {
if (routeContext.getRouteUnits().isEmpty() || sqlStatement instanceof SelectStatement) {
- route0(routeContext, rule);
+ route0(routeContext, singleRule);
} else {
RouteContext newRouteContext = new RouteContext();
- route0(newRouteContext, rule);
+ route0(newRouteContext, singleRule);
combineRouteContext(routeContext, newRouteContext);
}
}
@@ -79,7 +79,7 @@ public final class SingleTableStandardRouteEngine implements SingleTableRouteEng
return newRouteContext.getRouteUnits().stream().collect(Collectors.toMap(each -> each.getDataSourceMapper().getLogicName(), Function.identity()));
}
- private void route0(final RouteContext routeContext, final SingleTableRule rule) {
+ private void route0(final RouteContext routeContext, final SingleRule rule) {
if (sqlStatement instanceof CreateTableStatement) {
QualifiedTable table = singleTableNames.iterator().next();
Optional<DataNode> dataNodeOptional = rule.findSingleTableDataNode(table.getSchemaName(), table.getTableName());
@@ -97,10 +97,10 @@ public final class SingleTableStandardRouteEngine implements SingleTableRouteEng
}
}
- private void fillRouteContext(final SingleTableRule singleTableRule, final RouteContext routeContext, final Collection<QualifiedTable> logicTables) {
+ private void fillRouteContext(final SingleRule singleRule, final RouteContext routeContext, final Collection<QualifiedTable> logicTables) {
for (QualifiedTable each : logicTables) {
String tableName = each.getTableName();
- Optional<DataNode> dataNode = singleTableRule.findSingleTableDataNode(each.getSchemaName(), tableName);
+ Optional<DataNode> dataNode = singleRule.findSingleTableDataNode(each.getSchemaName(), tableName);
if (!dataNode.isPresent()) {
throw new SingleTableNotFoundException(tableName);
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidator.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
similarity index 78%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidator.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
index b4b6f75ffd6..8e347c97fad 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidator.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidator.java
@@ -15,19 +15,19 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.validator;
+package org.apache.shardingsphere.single.route.validator;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
/**
- * Single table meta data validator.
+ * Single meta data validator.
*
* @param <T> type of SQL statement
*/
-public interface SingleTableMetaDataValidator<T extends SQLStatement> {
+public interface SingleMetaDataValidator<T extends SQLStatement> {
/**
* Validate single table meta data.
@@ -36,5 +36,5 @@ public interface SingleTableMetaDataValidator<T extends SQLStatement> {
* @param sqlStatementContext SQL statement context
* @param database database
*/
- void validate(SingleTableRule rule, SQLStatementContext<T> sqlStatementContext, ShardingSphereDatabase database);
+ void validate(SingleRule rule, SQLStatementContext<T> sqlStatementContext, ShardingSphereDatabase database);
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidatorFactory.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidatorFactory.java
similarity index 69%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidatorFactory.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidatorFactory.java
index c9c06a69502..3861aad0dec 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidatorFactory.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidatorFactory.java
@@ -15,12 +15,12 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.validator;
+package org.apache.shardingsphere.single.route.validator;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
-import org.apache.shardingsphere.singletable.route.validator.ddl.SingleTableDropSchemaMetaDataValidator;
-import org.apache.shardingsphere.singletable.route.validator.ddl.SingleTableDropTableValidator;
+import org.apache.shardingsphere.single.route.validator.ddl.SingleDropSchemaMetaDataValidator;
+import org.apache.shardingsphere.single.route.validator.ddl.SingleDropTableValidator;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropSchemaStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropTableStatement;
@@ -28,24 +28,24 @@ import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropTableSt
import java.util.Optional;
/**
- * Single table meta data validator factory.
+ * Single meta data validator factory.
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class SingleTableMetaDataValidatorFactory {
+public final class SingleMetaDataValidatorFactory {
/**
- * New instance of single table meta data validator.
+ * New instance of single meta data validator.
*
* @param sqlStatement SQL statement
* @return created instance
*/
@SuppressWarnings("rawtypes")
- public static Optional<SingleTableMetaDataValidator> newInstance(final SQLStatement sqlStatement) {
+ public static Optional<SingleMetaDataValidator> newInstance(final SQLStatement sqlStatement) {
if (sqlStatement instanceof DropSchemaStatement) {
- return Optional.of(new SingleTableDropSchemaMetaDataValidator());
+ return Optional.of(new SingleDropSchemaMetaDataValidator());
}
if (sqlStatement instanceof DropTableStatement) {
- return Optional.of(new SingleTableDropTableValidator());
+ return Optional.of(new SingleDropTableValidator());
}
return Optional.empty();
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropSchemaMetaDataValidator.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropSchemaMetaDataValidator.java
similarity index 76%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropSchemaMetaDataValidator.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropSchemaMetaDataValidator.java
index 1490f4c5c2c..113e9ebade2 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropSchemaMetaDataValidator.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropSchemaMetaDataValidator.java
@@ -15,27 +15,27 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.validator.ddl;
+package org.apache.shardingsphere.single.route.validator.ddl;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
import org.apache.shardingsphere.infra.exception.SchemaNotFoundException;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereSchema;
import org.apache.shardingsphere.infra.util.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.singletable.exception.DropNotEmptySchemaException;
-import org.apache.shardingsphere.singletable.route.validator.SingleTableMetaDataValidator;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.exception.DropNotEmptySchemaException;
+import org.apache.shardingsphere.single.route.validator.SingleMetaDataValidator;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropSchemaStatement;
import org.apache.shardingsphere.sql.parser.sql.common.value.identifier.IdentifierValue;
import org.apache.shardingsphere.sql.parser.sql.dialect.handler.ddl.DropSchemaStatementHandler;
/**
- * Single table drop schema meta data validator.
+ * Single drop schema meta data validator.
*/
-public final class SingleTableDropSchemaMetaDataValidator implements SingleTableMetaDataValidator<DropSchemaStatement> {
+public final class SingleDropSchemaMetaDataValidator implements SingleMetaDataValidator<DropSchemaStatement> {
@Override
- public void validate(final SingleTableRule rule, final SQLStatementContext<DropSchemaStatement> sqlStatementContext, final ShardingSphereDatabase database) {
+ public void validate(final SingleRule rule, final SQLStatementContext<DropSchemaStatement> sqlStatementContext, final ShardingSphereDatabase database) {
boolean containsCascade = DropSchemaStatementHandler.containsCascade(sqlStatementContext.getSqlStatement());
for (IdentifierValue each : sqlStatementContext.getSqlStatement().getSchemaNames()) {
String schemaName = each.getValue();
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropTableValidator.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropTableValidator.java
similarity index 68%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropTableValidator.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropTableValidator.java
index 5675426a717..55c05854751 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropTableValidator.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropTableValidator.java
@@ -15,23 +15,23 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.validator.ddl;
+package org.apache.shardingsphere.single.route.validator.ddl;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.singletable.exception.UnsupportedDropCascadeTableException;
-import org.apache.shardingsphere.singletable.route.validator.SingleTableMetaDataValidator;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.exception.UnsupportedDropCascadeTableException;
+import org.apache.shardingsphere.single.route.validator.SingleMetaDataValidator;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropTableStatement;
import org.apache.shardingsphere.sql.parser.sql.dialect.handler.ddl.DropTableStatementHandler;
/**
- * Single table drop table validator.
+ * Single drop table validator.
*/
-public final class SingleTableDropTableValidator implements SingleTableMetaDataValidator<DropTableStatement> {
+public final class SingleDropTableValidator implements SingleMetaDataValidator<DropTableStatement> {
@Override
- public void validate(final SingleTableRule rule, final SQLStatementContext<DropTableStatement> sqlStatementContext, final ShardingSphereDatabase database) {
+ public void validate(final SingleRule rule, final SQLStatementContext<DropTableStatement> sqlStatementContext, final ShardingSphereDatabase database) {
if (DropTableStatementHandler.containsCascade(sqlStatementContext.getSqlStatement())) {
throw new UnsupportedDropCascadeTableException();
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableRule.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/SingleRule.java
similarity index 93%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableRule.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/SingleRule.java
index 74a1f2a4ec9..2307d7500ec 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableRule.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/SingleRule.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.rule;
+package org.apache.shardingsphere.single.rule;
import lombok.Getter;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
@@ -33,8 +33,8 @@ import org.apache.shardingsphere.infra.rule.identifier.type.MutableDataNodeRule;
import org.apache.shardingsphere.infra.rule.identifier.type.TableContainedRule;
import org.apache.shardingsphere.infra.rule.identifier.type.exportable.ExportableRule;
import org.apache.shardingsphere.infra.rule.identifier.type.exportable.constant.ExportableConstants;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.datanode.SingleTableDataNodeLoader;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.datanode.SingleTableDataNodeLoader;
import javax.sql.DataSource;
import java.util.ArrayList;
@@ -52,12 +52,12 @@ import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
/**
- * Single table rule.
+ * Single rule.
*/
-public final class SingleTableRule implements DatabaseRule, DataNodeContainedRule, TableContainedRule, MutableDataNodeRule, ExportableRule {
+public final class SingleRule implements DatabaseRule, DataNodeContainedRule, TableContainedRule, MutableDataNodeRule, ExportableRule {
@Getter
- private final SingleTableRuleConfiguration configuration;
+ private final SingleRuleConfiguration configuration;
private final String defaultDataSource;
@@ -69,7 +69,7 @@ public final class SingleTableRule implements DatabaseRule, DataNodeContainedRul
private final Map<String, String> tableNames;
- public SingleTableRule(final SingleTableRuleConfiguration ruleConfig, final String databaseName, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
+ public SingleRule(final SingleRuleConfiguration ruleConfig, final String databaseName, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
configuration = ruleConfig;
defaultDataSource = ruleConfig.getDefaultDataSource().orElse(null);
Map<String, DataSource> enabledDataSources = DataSourceStateManager.getInstance().getEnabledDataSourceMap(databaseName, dataSourceMap);
@@ -232,7 +232,7 @@ public final class SingleTableRule implements DatabaseRule, DataNodeContainedRul
@Override
public ShardingSphereRule reloadRule(final RuleConfiguration config, final String databaseName, final Map<String, DataSource> dataSourceMap,
final Collection<ShardingSphereRule> builtRules) {
- return new SingleTableRule((SingleTableRuleConfiguration) config, databaseName, dataSourceMap, builtRules);
+ return new SingleRule((SingleRuleConfiguration) config, databaseName, dataSourceMap, builtRules);
}
@Override
@@ -284,6 +284,6 @@ public final class SingleTableRule implements DatabaseRule, DataNodeContainedRul
@Override
public String getType() {
- return SingleTableRule.class.getSimpleName();
+ return SingleRule.class.getSimpleName();
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/DefaultSingleTableDatabaseRuleConfigurationBuilder.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/DefaultSingleRuleConfigurationBuilder.java
similarity index 59%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/DefaultSingleTableDatabaseRuleConfigurationBuilder.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/DefaultSingleRuleConfigurationBuilder.java
index 98ac2b2088b..dfbf1864f29 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/DefaultSingleTableDatabaseRuleConfigurationBuilder.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/DefaultSingleRuleConfigurationBuilder.java
@@ -15,29 +15,29 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.rule.builder;
+package org.apache.shardingsphere.single.rule.builder;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.constant.SingleTableOrder;
import org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.constant.SingleOrder;
/**
- * Default single table rule configuration builder.
+ * Default single rule configuration builder.
*/
-public final class DefaultSingleTableDatabaseRuleConfigurationBuilder implements DefaultDatabaseRuleConfigurationBuilder<SingleTableRuleConfiguration, SingleTableRuleBuilder> {
+public final class DefaultSingleRuleConfigurationBuilder implements DefaultDatabaseRuleConfigurationBuilder<SingleRuleConfiguration, SingleRuleBuilder> {
@Override
- public SingleTableRuleConfiguration build() {
- return new SingleTableRuleConfiguration();
+ public SingleRuleConfiguration build() {
+ return new SingleRuleConfiguration();
}
@Override
public int getOrder() {
- return SingleTableOrder.ORDER;
+ return SingleOrder.ORDER;
}
@Override
- public Class<SingleTableRuleBuilder> getTypeClass() {
- return SingleTableRuleBuilder.class;
+ public Class<SingleRuleBuilder> getTypeClass() {
+ return SingleRuleBuilder.class;
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilder.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilder.java
similarity index 56%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilder.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilder.java
index b7408c293b7..5aae2785646 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilder.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilder.java
@@ -15,37 +15,37 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.rule.builder;
+package org.apache.shardingsphere.single.rule.builder;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.constant.SingleTableOrder;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.constant.SingleOrder;
+import org.apache.shardingsphere.single.rule.SingleRule;
import javax.sql.DataSource;
import java.util.Collection;
import java.util.Map;
/**
- * Single table rule builder.
+ * Single rule builder.
*/
-public final class SingleTableRuleBuilder implements DatabaseRuleBuilder<SingleTableRuleConfiguration> {
+public final class SingleRuleBuilder implements DatabaseRuleBuilder<SingleRuleConfiguration> {
@Override
- public SingleTableRule build(final SingleTableRuleConfiguration config, final String databaseName,
- final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
- return new SingleTableRule(config, databaseName, dataSources, builtRules);
+ public SingleRule build(final SingleRuleConfiguration config, final String databaseName,
+ final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
+ return new SingleRule(config, databaseName, dataSources, builtRules);
}
@Override
public int getOrder() {
- return SingleTableOrder.ORDER;
+ return SingleOrder.ORDER;
}
@Override
- public Class<SingleTableRuleConfiguration> getTypeClass() {
- return SingleTableRuleConfiguration.class;
+ public Class<SingleRuleConfiguration> getTypeClass() {
+ return SingleRuleConfiguration.class;
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/pojo/YamlSingleTableRuleConfiguration.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/pojo/YamlSingleRuleConfiguration.java
similarity index 71%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/pojo/YamlSingleTableRuleConfiguration.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/pojo/YamlSingleRuleConfiguration.java
index f4306a6dd58..3e3ff212bad 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/pojo/YamlSingleTableRuleConfiguration.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/pojo/YamlSingleRuleConfiguration.java
@@ -15,24 +15,24 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.yaml.config.pojo;
+package org.apache.shardingsphere.single.yaml.config.pojo;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.infra.yaml.config.pojo.rule.YamlRuleConfiguration;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
/**
- * Single table rule configuration for YAML.
+ * Single rule configuration for YAML.
*/
@Getter
@Setter
-public final class YamlSingleTableRuleConfiguration implements YamlRuleConfiguration {
+public final class YamlSingleRuleConfiguration implements YamlRuleConfiguration {
private String defaultDataSource;
@Override
- public Class<SingleTableRuleConfiguration> getRuleConfigurationType() {
- return SingleTableRuleConfiguration.class;
+ public Class<SingleRuleConfiguration> getRuleConfigurationType() {
+ return SingleRuleConfiguration.class;
}
}
diff --git a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/swapper/YamlSingleTableRuleConfigurationSwapper.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/swapper/YamlSingleRuleConfigurationSwapper.java
similarity index 55%
rename from kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/swapper/YamlSingleTableRuleConfigurationSwapper.java
rename to kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/swapper/YamlSingleRuleConfigurationSwapper.java
index 6f21a8eb799..42e52b2c291 100644
--- a/kernel/single-table/core/src/main/java/org/apache/shardingsphere/singletable/yaml/config/swapper/YamlSingleTableRuleConfigurationSwapper.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/yaml/config/swapper/YamlSingleRuleConfigurationSwapper.java
@@ -15,35 +15,35 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.yaml.config.swapper;
+package org.apache.shardingsphere.single.yaml.config.swapper;
import org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.constant.SingleTableOrder;
-import org.apache.shardingsphere.singletable.yaml.config.pojo.YamlSingleTableRuleConfiguration;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.constant.SingleOrder;
+import org.apache.shardingsphere.single.yaml.config.pojo.YamlSingleRuleConfiguration;
/**
- * YAML single table rule configuration swapper.
+ * YAML single rule configuration swapper.
*/
-public final class YamlSingleTableRuleConfigurationSwapper implements YamlRuleConfigurationSwapper<YamlSingleTableRuleConfiguration, SingleTableRuleConfiguration> {
+public final class YamlSingleRuleConfigurationSwapper implements YamlRuleConfigurationSwapper<YamlSingleRuleConfiguration, SingleRuleConfiguration> {
@Override
- public YamlSingleTableRuleConfiguration swapToYamlConfiguration(final SingleTableRuleConfiguration data) {
- YamlSingleTableRuleConfiguration result = new YamlSingleTableRuleConfiguration();
+ public YamlSingleRuleConfiguration swapToYamlConfiguration(final SingleRuleConfiguration data) {
+ YamlSingleRuleConfiguration result = new YamlSingleRuleConfiguration();
data.getDefaultDataSource().ifPresent(result::setDefaultDataSource);
return result;
}
@Override
- public SingleTableRuleConfiguration swapToObject(final YamlSingleTableRuleConfiguration yamlConfig) {
- SingleTableRuleConfiguration result = new SingleTableRuleConfiguration();
+ public SingleRuleConfiguration swapToObject(final YamlSingleRuleConfiguration yamlConfig) {
+ SingleRuleConfiguration result = new SingleRuleConfiguration();
result.setDefaultDataSource(yamlConfig.getDefaultDataSource());
return result;
}
@Override
- public Class<SingleTableRuleConfiguration> getTypeClass() {
- return SingleTableRuleConfiguration.class;
+ public Class<SingleRuleConfiguration> getTypeClass() {
+ return SingleRuleConfiguration.class;
}
@Override
@@ -53,6 +53,6 @@ public final class YamlSingleTableRuleConfigurationSwapper implements YamlRuleCo
@Override
public int getOrder() {
- return SingleTableOrder.ORDER;
+ return SingleOrder.ORDER;
}
}
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.binder.decider.SQLFederationDecider b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.binder.decider.SQLFederationDecider
similarity index 90%
rename from kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.binder.decider.SQLFederationDecider
rename to kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.binder.decider.SQLFederationDecider
index 93721f0c2e2..b7a4aa81be7 100644
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.binder.decider.SQLFederationDecider
+++ b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.binder.decider.SQLFederationDecider
@@ -15,4 +15,4 @@
# limitations under the License.
#
-org.apache.shardingsphere.singletable.decider.SingleTableSQLFederationDecider
+org.apache.shardingsphere.single.decider.SingleSQLFederationDecider
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
similarity index 90%
copy from kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
copy to kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
index be441e1a4b7..a3f0f576f90 100644
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
+++ b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
@@ -15,4 +15,4 @@
# limitations under the License.
#
-org.apache.shardingsphere.singletable.metadata.SingleTableSchemaMetaDataDecorator
+org.apache.shardingsphere.single.metadata.SingleSchemaMetaDataDecorator
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.route.SQLRouter b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.route.SQLRouter
similarity index 92%
rename from kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.route.SQLRouter
rename to kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.route.SQLRouter
index 57e99606e4e..4b7efe6125e 100644
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.route.SQLRouter
+++ b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.route.SQLRouter
@@ -15,4 +15,4 @@
# limitations under the License.
#
-org.apache.shardingsphere.singletable.route.SingleTableSQLRouter
+org.apache.shardingsphere.single.route.SingleSQLRouter
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder
similarity index 91%
rename from kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder
rename to kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder
index 9a8d9bb2d51..06e50108be3 100644
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder
+++ b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder
@@ -15,4 +15,4 @@
# limitations under the License.
#
-org.apache.shardingsphere.singletable.rule.builder.SingleTableRuleBuilder
+org.apache.shardingsphere.single.rule.builder.SingleRuleBuilder
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder
similarity index 90%
copy from kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
copy to kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder
index be441e1a4b7..d6e2ae1fbff 100644
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
+++ b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder
@@ -15,4 +15,4 @@
# limitations under the License.
#
-org.apache.shardingsphere.singletable.metadata.SingleTableSchemaMetaDataDecorator
+org.apache.shardingsphere.single.rule.builder.DefaultSingleRuleConfigurationBuilder
diff --git a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper
similarity index 89%
rename from kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
rename to kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper
index be441e1a4b7..c06ededb21a 100644
--- a/kernel/single-table/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecorator
+++ b/kernel/single/core/src/main/resources/META-INF/services/org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper
@@ -15,4 +15,4 @@
# limitations under the License.
#
-org.apache.shardingsphere.singletable.metadata.SingleTableSchemaMetaDataDecorator
+org.apache.shardingsphere.single.yaml.config.swapper.YamlSingleRuleConfigurationSwapper
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/datanode/SingleTableDataNodeLoaderTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoaderTest.java
similarity index 99%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/datanode/SingleTableDataNodeLoaderTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoaderTest.java
index 01816c07402..e552cc64747 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/datanode/SingleTableDataNodeLoaderTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoaderTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.datanode;
+package org.apache.shardingsphere.single.datanode;
import org.apache.shardingsphere.infra.database.DefaultDatabase;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/decider/SingleTableSQLFederationDeciderTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDeciderTest.java
similarity index 85%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/decider/SingleTableSQLFederationDeciderTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDeciderTest.java
index 8cfc6709c6d..0b4acc50844 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/decider/SingleTableSQLFederationDeciderTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/decider/SingleSQLFederationDeciderTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.decider;
+package org.apache.shardingsphere.single.decider;
import org.apache.shardingsphere.infra.binder.QueryContext;
import org.apache.shardingsphere.infra.binder.decider.context.SQLFederationDeciderContext;
@@ -27,7 +27,7 @@ import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
import org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereSchema;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.Test;
import java.util.Arrays;
@@ -45,15 +45,15 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class SingleTableSQLFederationDeciderTest {
+public final class SingleSQLFederationDeciderTest {
@Test
public void assertDecideWhenNotContainsSingleTable() {
- SingleTableSQLFederationDecider federationDecider = new SingleTableSQLFederationDecider();
+ SingleSQLFederationDecider federationDecider = new SingleSQLFederationDecider();
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
SQLFederationDeciderContext actual = new SQLFederationDeciderContext();
- federationDecider.decide(actual, queryContext, createDatabase(), mock(SingleTableRule.class), new ConfigurationProperties(new Properties()));
+ federationDecider.decide(actual, queryContext, createDatabase(), mock(SingleRule.class), new ConfigurationProperties(new Properties()));
assertTrue(actual.getDataNodes().isEmpty());
assertFalse(actual.isUseSQLFederation());
}
@@ -61,12 +61,12 @@ public final class SingleTableSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllSingleTablesInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleTableRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleTableRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(true);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
SQLFederationDeciderContext actual = new SQLFederationDeciderContext();
- SingleTableSQLFederationDecider federationDecider = new SingleTableSQLFederationDecider();
+ SingleSQLFederationDecider federationDecider = new SingleSQLFederationDecider();
federationDecider.decide(actual, queryContext, createDatabase(), rule, new ConfigurationProperties(new Properties()));
assertThat(actual.getDataNodes().size(), is(2));
assertFalse(actual.isUseSQLFederation());
@@ -75,12 +75,12 @@ public final class SingleTableSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllSingleTablesNotInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleTableRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleTableRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(false);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
SQLFederationDeciderContext actual = new SQLFederationDeciderContext();
- SingleTableSQLFederationDecider federationDecider = new SingleTableSQLFederationDecider();
+ SingleSQLFederationDecider federationDecider = new SingleSQLFederationDecider();
federationDecider.decide(actual, queryContext, createDatabase(), rule, new ConfigurationProperties(new Properties()));
assertThat(actual.getDataNodes().size(), is(2));
assertTrue(actual.isUseSQLFederation());
@@ -89,13 +89,13 @@ public final class SingleTableSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllTablesInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleTableRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleTableRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(true);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
SQLFederationDeciderContext actual = new SQLFederationDeciderContext();
actual.getDataNodes().add(new DataNode("ds_0", "t_user"));
- SingleTableSQLFederationDecider federationDecider = new SingleTableSQLFederationDecider();
+ SingleSQLFederationDecider federationDecider = new SingleSQLFederationDecider();
federationDecider.decide(actual, queryContext, createDatabase(), rule, new ConfigurationProperties(new Properties()));
assertThat(actual.getDataNodes().size(), is(3));
assertFalse(actual.isUseSQLFederation());
@@ -104,20 +104,20 @@ public final class SingleTableSQLFederationDeciderTest {
@Test
public void assertDecideWhenAllTablesNotInSameDataSource() {
Collection<QualifiedTable> qualifiedTables = Arrays.asList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order"), new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order_item"));
- SingleTableRule rule = createSingleTableRule(qualifiedTables);
+ SingleRule rule = createSingleTableRule(qualifiedTables);
when(rule.isSingleTablesInSameDataSource(qualifiedTables)).thenReturn(true);
SelectStatementContext select = createStatementContext();
QueryContext queryContext = new QueryContext(select, "", Collections.emptyList());
SQLFederationDeciderContext actual = new SQLFederationDeciderContext();
actual.getDataNodes().add(new DataNode("ds_1", "t_user"));
- SingleTableSQLFederationDecider federationDecider = new SingleTableSQLFederationDecider();
+ SingleSQLFederationDecider federationDecider = new SingleSQLFederationDecider();
federationDecider.decide(actual, queryContext, createDatabase(), rule, new ConfigurationProperties(new Properties()));
assertThat(actual.getDataNodes().size(), is(3));
assertTrue(actual.isUseSQLFederation());
}
- private static SingleTableRule createSingleTableRule(final Collection<QualifiedTable> qualifiedTables) {
- SingleTableRule result = mock(SingleTableRule.class);
+ private static SingleRule createSingleTableRule(final Collection<QualifiedTable> qualifiedTables) {
+ SingleRule result = mock(SingleRule.class);
when(result.getSingleTableNames(any())).thenReturn(qualifiedTables);
when(result.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "t_order")).thenReturn(Optional.of(new DataNode("ds_0", "t_order")));
when(result.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "t_order_item")).thenReturn(Optional.of(new DataNode("ds_0", "t_order_item")));
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/metadata/SingleTableSchemaMetaDataDecoratorTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/metadata/SingleSchemaMetaDataDecoratorTest.java
similarity index 86%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/metadata/SingleTableSchemaMetaDataDecoratorTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/metadata/SingleSchemaMetaDataDecoratorTest.java
index c13c7624711..c795dd125d7 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/metadata/SingleTableSchemaMetaDataDecoratorTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/metadata/SingleSchemaMetaDataDecoratorTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.metadata;
+package org.apache.shardingsphere.single.metadata;
import org.apache.shardingsphere.infra.metadata.database.schema.builder.GenericSchemaBuilderMaterial;
import org.apache.shardingsphere.infra.metadata.database.schema.decorator.spi.RuleBasedSchemaMetaDataDecoratorFactory;
@@ -24,7 +24,7 @@ import org.apache.shardingsphere.infra.metadata.database.schema.loader.model.Ind
import org.apache.shardingsphere.infra.metadata.database.schema.loader.model.SchemaMetaData;
import org.apache.shardingsphere.infra.metadata.database.schema.loader.model.TableMetaData;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.Test;
import java.sql.Types;
@@ -39,17 +39,17 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.mock;
-public final class SingleTableSchemaMetaDataDecoratorTest {
+public final class SingleSchemaMetaDataDecoratorTest {
private static final String TABLE_NAME = "t_single";
@Test
public void assertDecorate() {
- SingleTableRule singleTableRule = mock(SingleTableRule.class);
- Collection<ShardingSphereRule> rules = Collections.singletonList(singleTableRule);
- SingleTableSchemaMetaDataDecorator builder = (SingleTableSchemaMetaDataDecorator) RuleBasedSchemaMetaDataDecoratorFactory.getInstances(rules).get(singleTableRule);
+ SingleRule singleRule = mock(SingleRule.class);
+ Collection<ShardingSphereRule> rules = Collections.singletonList(singleRule);
+ SingleSchemaMetaDataDecorator builder = (SingleSchemaMetaDataDecorator) RuleBasedSchemaMetaDataDecoratorFactory.getInstances(rules).get(singleRule);
Map<String, SchemaMetaData> schemaMetaDataMap = mockSchemaMetaDataMap();
- TableMetaData tableMetaData = builder.decorate(schemaMetaDataMap, singleTableRule, mock(GenericSchemaBuilderMaterial.class)).get("sharding_db").getTables().iterator().next();
+ TableMetaData tableMetaData = builder.decorate(schemaMetaDataMap, singleRule, mock(GenericSchemaBuilderMaterial.class)).get("sharding_db").getTables().iterator().next();
Iterator<ColumnMetaData> columnsIterator = tableMetaData.getColumns().iterator();
assertThat(columnsIterator.next(), is(new ColumnMetaData("id", Types.INTEGER, true, false, false, true, false)));
assertThat(columnsIterator.next(), is(new ColumnMetaData("name", Types.VARCHAR, false, false, false, true, false)));
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouterTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/SingleSQLRouterTest.java
similarity index 85%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouterTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/SingleSQLRouterTest.java
index fac6db24bc4..ce13f69bc16 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/SingleTableSQLRouterTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/SingleSQLRouterTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route;
+package org.apache.shardingsphere.single.route;
import org.apache.shardingsphere.infra.binder.QueryContext;
import org.apache.shardingsphere.infra.binder.statement.ddl.CreateTableStatementContext;
@@ -31,8 +31,8 @@ import org.apache.shardingsphere.infra.route.SQLRouterFactory;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.SimpleTableSegment;
import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.TableNameSegment;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.CreateTableStatement;
@@ -60,15 +60,15 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class SingleTableSQLRouterTest {
+public final class SingleSQLRouterTest {
@Test
public void assertCreateRouteContextWithSingleDataSource() throws SQLException {
- SingleTableRule rule = new SingleTableRule(new SingleTableRuleConfiguration(),
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
DefaultDatabase.LOGIC_NAME, Collections.singletonMap("foo_ds", new MockedDataSource(mockConnection())), Collections.emptyList());
rule.getSingleTableDataNodes().put("t_order", Collections.singletonList(createDataNode("foo_ds")));
ShardingSphereDatabase database = mockSingleDatabase();
- RouteContext actual = new SingleTableSQLRouter().createRouteContext(createQueryContext(), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
+ RouteContext actual = new SingleSQLRouter().createRouteContext(createQueryContext(), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
assertThat(actual.getRouteUnits().size(), is(1));
RouteUnit routeUnit = actual.getRouteUnits().iterator().next();
assertThat(routeUnit.getDataSourceMapper().getLogicName(), is("foo_ds"));
@@ -84,11 +84,11 @@ public final class SingleTableSQLRouterTest {
@Test
public void assertCreateRouteContextWithReadwriteSplittingDataSource() throws SQLException {
- SingleTableRule rule = new SingleTableRule(new SingleTableRuleConfiguration(),
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
DefaultDatabase.LOGIC_NAME, Collections.singletonMap("readwrite_ds", new MockedDataSource(mockConnection())), Collections.emptyList());
rule.getSingleTableDataNodes().put("t_order", Collections.singletonList(createDataNode("write_ds")));
ShardingSphereDatabase database = mockReadwriteSplittingDatabase();
- RouteContext actual = new SingleTableSQLRouter().createRouteContext(createQueryContext(), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
+ RouteContext actual = new SingleSQLRouter().createRouteContext(createQueryContext(), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
assertThat(actual.getRouteUnits().size(), is(1));
RouteUnit routeUnit = actual.getRouteUnits().iterator().next();
assertThat(routeUnit.getDataSourceMapper().getLogicName(), is("readwrite_ds"));
@@ -105,9 +105,9 @@ public final class SingleTableSQLRouterTest {
@Test
public void assertCreateRouteContextWithMultiDataSource() throws SQLException {
- SingleTableRule rule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createMultiDataSourceMap(), Collections.emptyList());
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createMultiDataSourceMap(), Collections.emptyList());
ShardingSphereDatabase database = mockDatabaseWithMultipleResources();
- RouteContext actual = new SingleTableSQLRouter().createRouteContext(createQueryContext(), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
+ RouteContext actual = new SingleSQLRouter().createRouteContext(createQueryContext(), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
List<RouteUnit> routeUnits = new ArrayList<>(actual.getRouteUnits());
assertThat(actual.getRouteUnits().size(), is(1));
assertThat(routeUnits.get(0).getDataSourceMapper().getLogicName(), is(routeUnits.get(0).getDataSourceMapper().getActualName()));
@@ -149,11 +149,11 @@ public final class SingleTableSQLRouterTest {
@Test
public void assertDecorateRouteContextWithSingleDataSource() {
- SingleTableRule rule = new SingleTableRule(new SingleTableRuleConfiguration(),
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
DefaultDatabase.LOGIC_NAME, Collections.singletonMap("foo_ds", new MockedDataSource()), Collections.emptyList());
RouteContext routeContext = new RouteContext();
routeContext.getRouteUnits().add(new RouteUnit(new RouteMapper("foo_ds", "foo_ds"), Collections.singletonList(new RouteMapper("t_order", "t_order"))));
- SingleTableSQLRouter sqlRouter = (SingleTableSQLRouter) SQLRouterFactory.getInstances(Collections.singleton(rule)).get(rule);
+ SingleSQLRouter sqlRouter = (SingleSQLRouter) SQLRouterFactory.getInstances(Collections.singleton(rule)).get(rule);
sqlRouter.decorateRouteContext(routeContext, createQueryContext(), mockReadwriteSplittingDatabase(), rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
Iterator<String> routedDataSourceNames = routeContext.getActualDataSourceNames().iterator();
assertThat(routedDataSourceNames.next(), is("foo_ds"));
@@ -161,14 +161,14 @@ public final class SingleTableSQLRouterTest {
@Test
public void assertDecorateRouteContextWithReadwriteSplittingDataSource() {
- SingleTableRule rule = new SingleTableRule(new SingleTableRuleConfiguration(),
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
DefaultDatabase.LOGIC_NAME, Collections.singletonMap("readwrite_ds", new MockedDataSource()), Collections.emptyList());
RouteContext routeContext = new RouteContext();
RouteUnit readWriteRouteUnit = new RouteUnit(new RouteMapper("readwrite_ds", "readwrite_ds"), Collections.emptyList());
RouteUnit writeRouteUnit = new RouteUnit(new RouteMapper("write_ds", "write_ds"), Collections.singletonList(new RouteMapper("t_order", "t_order")));
routeContext.getRouteUnits().add(readWriteRouteUnit);
routeContext.getRouteUnits().add(writeRouteUnit);
- SingleTableSQLRouter sqlRouter = (SingleTableSQLRouter) SQLRouterFactory.getInstances(Collections.singleton(rule)).get(rule);
+ SingleSQLRouter sqlRouter = (SingleSQLRouter) SQLRouterFactory.getInstances(Collections.singleton(rule)).get(rule);
ShardingSphereDatabase database = new ShardingSphereDatabase(DefaultDatabase.LOGIC_NAME, mock(DatabaseType.class), mock(ShardingSphereResourceMetaData.class, RETURNS_DEEP_STUBS),
new ShardingSphereRuleMetaData(Collections.singleton(rule)), Collections.emptyMap());
sqlRouter.decorateRouteContext(routeContext, createQueryContext(), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
@@ -179,11 +179,11 @@ public final class SingleTableSQLRouterTest {
@Test
public void assertDecorateRouteContextWithMultiDataSource() throws SQLException {
- SingleTableRule rule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createMultiDataSourceMap(), Collections.emptyList());
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createMultiDataSourceMap(), Collections.emptyList());
RouteContext routeContext = new RouteContext();
routeContext.getRouteUnits().add(new RouteUnit(new RouteMapper("ds_0", "ds_0"), Collections.emptyList()));
routeContext.getRouteUnits().add(new RouteUnit(new RouteMapper("ds_1", "ds_1"), Collections.emptyList()));
- SingleTableSQLRouter sqlRouter = (SingleTableSQLRouter) SQLRouterFactory.getInstances(Collections.singleton(rule)).get(rule);
+ SingleSQLRouter sqlRouter = (SingleSQLRouter) SQLRouterFactory.getInstances(Collections.singleton(rule)).get(rule);
sqlRouter.decorateRouteContext(routeContext, createQueryContext(), mockDatabaseWithMultipleResources(), rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
Iterator<String> routedDataSourceNames = routeContext.getActualDataSourceNames().iterator();
assertThat(routedDataSourceNames.next(), is("ds_1"));
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableDatabaseBroadcastRouteEngineTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngineTest.java
similarity index 81%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableDatabaseBroadcastRouteEngineTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngineTest.java
index 46cce083528..d78d2b2118f 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableDatabaseBroadcastRouteEngineTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngineTest.java
@@ -15,13 +15,13 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.engine;
+package org.apache.shardingsphere.single.route.engine;
import org.apache.shardingsphere.infra.database.DefaultDatabase;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
import org.junit.Test;
@@ -41,14 +41,14 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class SingleTableDatabaseBroadcastRouteEngineTest {
+public final class SingleDatabaseBroadcastRouteEngineTest {
@Test
public void assertRoute() throws SQLException {
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
RouteContext routeContext = new RouteContext();
- SingleTableDatabaseBroadcastRouteEngine engine = new SingleTableDatabaseBroadcastRouteEngine();
- engine.route(routeContext, singleTableRule);
+ SingleDatabaseBroadcastRouteEngine engine = new SingleDatabaseBroadcastRouteEngine();
+ engine.route(routeContext, singleRule);
List<RouteUnit> routeUnits = new ArrayList<>(routeContext.getRouteUnits());
assertThat(routeContext.getRouteUnits().size(), is(2));
assertThat(routeUnits.get(0).getDataSourceMapper().getActualName(), is("ds_0"));
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngineFactoryTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngineFactoryTest.java
similarity index 70%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngineFactoryTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngineFactoryTest.java
index cb0f46a7cb1..3442f640d05 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableRouteEngineFactoryTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleRouteEngineFactoryTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.engine;
+package org.apache.shardingsphere.single.route.engine;
import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
@@ -30,30 +30,30 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
-public final class SingleTableRouteEngineFactoryTest {
+public final class SingleRouteEngineFactoryTest {
@Test
public void assertNewInstanceWithNotEmptySingleTableNames() {
- assertTrue(SingleTableRouteEngineFactory.newInstance(Collections.singleton(new QualifiedTable("demo_ds", "t_order")), mock(SQLStatement.class)).isPresent());
+ assertTrue(SingleRouteEngineFactory.newInstance(Collections.singleton(new QualifiedTable("demo_ds", "t_order")), mock(SQLStatement.class)).isPresent());
}
@Test
public void assertNewInstanceWithEmptySingleTableNameAndCreateSchemaStatement() {
- assertTrue(SingleTableRouteEngineFactory.newInstance(Collections.emptyList(), mock(CreateSchemaStatement.class)).isPresent());
+ assertTrue(SingleRouteEngineFactory.newInstance(Collections.emptyList(), mock(CreateSchemaStatement.class)).isPresent());
}
@Test
public void assertNewInstanceWithEmptySingleTableNameAndAlterSchemaStatement() {
- assertTrue(SingleTableRouteEngineFactory.newInstance(Collections.emptyList(), mock(AlterSchemaStatement.class)).isPresent());
+ assertTrue(SingleRouteEngineFactory.newInstance(Collections.emptyList(), mock(AlterSchemaStatement.class)).isPresent());
}
@Test
public void assertNewInstanceWithEmptySingleTableNameAndDropSchemaStatement() {
- assertTrue(SingleTableRouteEngineFactory.newInstance(Collections.emptyList(), mock(DropSchemaStatement.class)).isPresent());
+ assertTrue(SingleRouteEngineFactory.newInstance(Collections.emptyList(), mock(DropSchemaStatement.class)).isPresent());
}
@Test
public void assertNewInstanceWithEmptySingleTableNameAndOtherStatement() {
- assertFalse(SingleTableRouteEngineFactory.newInstance(Collections.emptyList(), mock(SQLStatement.class)).isPresent());
+ assertFalse(SingleRouteEngineFactory.newInstance(Collections.emptyList(), mock(SQLStatement.class)).isPresent());
}
}
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableStandardRouteEngineTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngineTest.java
similarity index 72%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableStandardRouteEngineTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngineTest.java
index cec13c2d9ba..6ecaf20d85c 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/engine/SingleTableStandardRouteEngineTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngineTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.engine;
+package org.apache.shardingsphere.single.route.engine;
import org.apache.shardingsphere.dialect.exception.syntax.table.TableExistsException;
import org.apache.shardingsphere.infra.database.DefaultDatabase;
@@ -24,8 +24,8 @@ import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.SimpleTableSegment;
import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.TableNameSegment;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
@@ -53,16 +53,16 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class SingleTableStandardRouteEngineTest {
+public final class SingleStandardRouteEngineTest {
@Test
public void assertRouteInSameDataSource() throws SQLException {
- SingleTableStandardRouteEngine engine = new SingleTableStandardRouteEngine(mockQualifiedTables(), null);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
- singleTableRule.getSingleTableDataNodes().put("t_order", Collections.singletonList(mockDataNode("t_order")));
- singleTableRule.getSingleTableDataNodes().put("t_order_item", Collections.singletonList(mockDataNode("t_order_item")));
+ SingleStandardRouteEngine engine = new SingleStandardRouteEngine(mockQualifiedTables(), null);
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ singleRule.getSingleTableDataNodes().put("t_order", Collections.singletonList(mockDataNode("t_order")));
+ singleRule.getSingleTableDataNodes().put("t_order_item", Collections.singletonList(mockDataNode("t_order_item")));
RouteContext routeContext = new RouteContext();
- engine.route(routeContext, singleTableRule);
+ engine.route(routeContext, singleRule);
List<RouteUnit> routeUnits = new ArrayList<>(routeContext.getRouteUnits());
assertThat(routeContext.getRouteUnits().size(), is(1));
assertThat(routeUnits.get(0).getDataSourceMapper().getActualName(), is("ds_0"));
@@ -87,11 +87,11 @@ public final class SingleTableStandardRouteEngineTest {
}
@Test
- public void assertRouteWithoutSingleTableRule() throws SQLException {
- SingleTableStandardRouteEngine engine = new SingleTableStandardRouteEngine(mockQualifiedTables(), new MySQLCreateTableStatement(false));
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ public void assertRouteWithoutSingleRule() throws SQLException {
+ SingleStandardRouteEngine engine = new SingleStandardRouteEngine(mockQualifiedTables(), new MySQLCreateTableStatement(false));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
RouteContext routeContext = new RouteContext();
- engine.route(routeContext, singleTableRule);
+ engine.route(routeContext, singleRule);
List<RouteUnit> routeUnits = new ArrayList<>(routeContext.getRouteUnits());
assertThat(routeContext.getRouteUnits().size(), is(1));
assertThat(routeUnits.get(0).getTableMappers().size(), is(1));
@@ -102,11 +102,11 @@ public final class SingleTableStandardRouteEngineTest {
}
@Test
- public void assertRouteWithDefaultSingleTableRule() throws SQLException {
- SingleTableStandardRouteEngine engine = new SingleTableStandardRouteEngine(mockQualifiedTables(), new MySQLCreateTableStatement(false));
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration("ds_0"), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ public void assertRouteWithDefaultSingleRule() throws SQLException {
+ SingleStandardRouteEngine engine = new SingleStandardRouteEngine(mockQualifiedTables(), new MySQLCreateTableStatement(false));
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration("ds_0"), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
RouteContext routeContext = new RouteContext();
- engine.route(routeContext, singleTableRule);
+ engine.route(routeContext, singleRule);
List<RouteUnit> routeUnits = new ArrayList<>(routeContext.getRouteUnits());
assertThat(routeContext.getRouteUnits().size(), is(1));
assertThat(routeUnits.get(0).getDataSourceMapper().getActualName(), is("ds_0"));
@@ -128,14 +128,14 @@ public final class SingleTableStandardRouteEngineTest {
@Test(expected = TableExistsException.class)
public void assertRouteDuplicateSingleTable() {
- SingleTableStandardRouteEngine engine = new SingleTableStandardRouteEngine(Collections.singletonList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order")), mockStatement(false));
- engine.route(new RouteContext(), mockSingleTableRule());
+ SingleStandardRouteEngine engine = new SingleStandardRouteEngine(Collections.singletonList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order")), mockStatement(false));
+ engine.route(new RouteContext(), mockSingleRule());
}
@Test
public void assertRouteIfNotExistsDuplicateSingleTable() {
- SingleTableStandardRouteEngine engine = new SingleTableStandardRouteEngine(Collections.singletonList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order")), mockStatement(true));
- engine.route(new RouteContext(), mockSingleTableRule());
+ SingleStandardRouteEngine engine = new SingleStandardRouteEngine(Collections.singletonList(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "t_order")), mockStatement(true));
+ engine.route(new RouteContext(), mockSingleRule());
}
private SQLStatement mockStatement(final boolean ifNotExists) {
@@ -144,8 +144,8 @@ public final class SingleTableStandardRouteEngineTest {
return result;
}
- private SingleTableRule mockSingleTableRule() {
- SingleTableRule result = mock(SingleTableRule.class);
+ private SingleRule mockSingleRule() {
+ SingleRule result = mock(SingleRule.class);
DataNode dataNode = mock(DataNode.class);
when(result.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "t_order")).thenReturn(Optional.of(dataNode));
return result;
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidatorFactoryTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidatorFactoryTest.java
similarity index 78%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidatorFactoryTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidatorFactoryTest.java
index 8b6c126cea5..1d0e12fd63e 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/validator/SingleTableMetaDataValidatorFactoryTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/validator/SingleMetaDataValidatorFactoryTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.validator;
+package org.apache.shardingsphere.single.route.validator;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropSchemaStatement;
@@ -25,15 +25,15 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
-public final class SingleTableMetaDataValidatorFactoryTest {
+public final class SingleMetaDataValidatorFactoryTest {
@Test
public void assertNewInstanceForDropSchemaStatement() {
- assertTrue(SingleTableMetaDataValidatorFactory.newInstance(mock(DropSchemaStatement.class)).isPresent());
+ assertTrue(SingleMetaDataValidatorFactory.newInstance(mock(DropSchemaStatement.class)).isPresent());
}
@Test
public void assertNewInstanceForNotDropSchemaStatement() {
- assertFalse(SingleTableMetaDataValidatorFactory.newInstance(mock(SQLStatement.class)).isPresent());
+ assertFalse(SingleMetaDataValidatorFactory.newInstance(mock(SQLStatement.class)).isPresent());
}
}
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropSchemaMetaDataValidatorTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropSchemaMetaDataValidatorTest.java
similarity index 79%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropSchemaMetaDataValidatorTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropSchemaMetaDataValidatorTest.java
index 67dbd63f9c9..7f6d1a73634 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/route/validator/ddl/SingleTableDropSchemaMetaDataValidatorTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/validator/ddl/SingleDropSchemaMetaDataValidatorTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.route.validator.ddl;
+package org.apache.shardingsphere.single.route.validator.ddl;
import org.apache.shardingsphere.infra.binder.statement.CommonSQLStatementContext;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
@@ -23,8 +23,8 @@ import org.apache.shardingsphere.infra.exception.SchemaNotFoundException;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereSchema;
import org.apache.shardingsphere.infra.metadata.database.schema.decorator.model.ShardingSphereTable;
-import org.apache.shardingsphere.singletable.exception.DropNotEmptySchemaException;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.exception.DropNotEmptySchemaException;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.DropSchemaStatement;
import org.apache.shardingsphere.sql.parser.sql.common.value.identifier.IdentifierValue;
import org.apache.shardingsphere.sql.parser.sql.dialect.statement.postgresql.ddl.PostgreSQLDropSchemaStatement;
@@ -36,23 +36,23 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class SingleTableDropSchemaMetaDataValidatorTest {
+public final class SingleDropSchemaMetaDataValidatorTest {
@Test(expected = DropNotEmptySchemaException.class)
public void assertValidateWithoutCascadeSchema() {
- new SingleTableDropSchemaMetaDataValidator().validate(mock(SingleTableRule.class, RETURNS_DEEP_STUBS), createSQLStatementContext("foo_schema", false), mockDatabase());
+ new SingleDropSchemaMetaDataValidator().validate(mock(SingleRule.class, RETURNS_DEEP_STUBS), createSQLStatementContext("foo_schema", false), mockDatabase());
}
@Test(expected = SchemaNotFoundException.class)
public void assertValidateWithNotExistedSchema() {
ShardingSphereDatabase database = mockDatabase();
when(database.getSchema("not_existed_schema")).thenReturn(null);
- new SingleTableDropSchemaMetaDataValidator().validate(mock(SingleTableRule.class, RETURNS_DEEP_STUBS), createSQLStatementContext("not_existed_schema", true), database);
+ new SingleDropSchemaMetaDataValidator().validate(mock(SingleRule.class, RETURNS_DEEP_STUBS), createSQLStatementContext("not_existed_schema", true), database);
}
@Test
public void assertValidate() {
- new SingleTableDropSchemaMetaDataValidator().validate(mock(SingleTableRule.class, RETURNS_DEEP_STUBS), createSQLStatementContext("foo_schema", true), mockDatabase());
+ new SingleDropSchemaMetaDataValidator().validate(mock(SingleRule.class, RETURNS_DEEP_STUBS), createSQLStatementContext("foo_schema", true), mockDatabase());
}
private ShardingSphereDatabase mockDatabase() {
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableRuleTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
similarity index 78%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableRuleTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
index 4d029a20435..f2dc0416a9b 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableRuleTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.rule;
+package org.apache.shardingsphere.single.rule;
import org.apache.shardingsphere.infra.database.DefaultDatabase;
import org.apache.shardingsphere.infra.datanode.DataNode;
@@ -23,7 +23,7 @@ import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.rule.identifier.type.DataNodeContainedRule;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
import org.junit.Before;
import org.junit.Test;
@@ -50,7 +50,7 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-public final class SingleTableRuleTest {
+public final class SingleRuleTest {
private static final String TABLE_TYPE = "TABLE";
@@ -92,7 +92,7 @@ public final class SingleTableRuleTest {
public void assertGetSingleTableDataNodes() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
when(dataNodeContainedRule.getAllTables()).thenReturn(Arrays.asList("t_order", "t_order_0", "t_order_1"));
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Map<String, Collection<DataNode>> actual = singleTableRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
@@ -103,7 +103,7 @@ public final class SingleTableRuleTest {
public void assertGetSingleTableDataNodesWithUpperCase() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
when(dataNodeContainedRule.getAllTables()).thenReturn(Arrays.asList("T_ORDER", "T_ORDER_0", "T_ORDER_1"));
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Map<String, Collection<DataNode>> actual = singleTableRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
@@ -113,7 +113,7 @@ public final class SingleTableRuleTest {
@Test
public void assertFindSingleTableDataNode() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Optional<DataNode> actual = singleTableRule.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "employee");
assertTrue(actual.isPresent());
assertThat(actual.get().getDataSourceName(), is("foo_ds"));
@@ -123,7 +123,7 @@ public final class SingleTableRuleTest {
@Test
public void assertFindSingleTableDataNodeWithUpperCase() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Optional<DataNode> actual = singleTableRule.findSingleTableDataNode(DefaultDatabase.LOGIC_NAME, "EMPLOYEE");
assertTrue(actual.isPresent());
assertThat(actual.get().getDataSourceName(), is("foo_ds"));
@@ -133,7 +133,7 @@ public final class SingleTableRuleTest {
@Test
public void assertIsSingleTablesInSameDataSource() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Collection<QualifiedTable> singleTableNames = new LinkedList<>();
singleTableNames.add(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "employee"));
assertTrue(singleTableRule.isSingleTablesInSameDataSource(singleTableNames));
@@ -149,23 +149,23 @@ public final class SingleTableRuleTest {
RouteContext routeContext = new RouteContext();
routeContext.putRouteUnit(dataSourceMapper, tableMappers);
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertTrue(singleTableRule.isAllTablesInSameDataSource(routeContext, singleTableNames));
}
@Test
public void assertAssignNewDataSourceName() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRuleConfiguration singleTableRuleConfig = new SingleTableRuleConfiguration();
+ SingleRuleConfiguration singleTableRuleConfig = new SingleRuleConfiguration();
singleTableRuleConfig.setDefaultDataSource("foo_ds");
- SingleTableRule singleTableRule = new SingleTableRule(singleTableRuleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(singleTableRuleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertThat(singleTableRule.assignNewDataSourceName(), is("foo_ds"));
}
@Test
public void assertGetSingleTableNames() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Collection<QualifiedTable> tableNames = new LinkedList<>();
tableNames.add(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "employee"));
assertThat(singleTableRule.getSingleTableNames(tableNames).iterator().next().getSchemaName(), is(DefaultDatabase.LOGIC_NAME));
@@ -175,7 +175,7 @@ public final class SingleTableRuleTest {
@Test
public void assertPut() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String tableName = "teacher";
String dataSourceName = "foo_ds";
singleTableRule.put(dataSourceName, DefaultDatabase.LOGIC_NAME, tableName);
@@ -193,7 +193,7 @@ public final class SingleTableRuleTest {
@Test
public void assertRemove() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String tableName = "employee";
singleTableRule.remove(DefaultDatabase.LOGIC_NAME, tableName);
Collection<QualifiedTable> tableNames = new LinkedList<>();
@@ -207,7 +207,7 @@ public final class SingleTableRuleTest {
@Test
public void assertGetAllDataNodes() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertTrue(singleTableRule.getAllDataNodes().containsKey("employee"));
assertTrue(singleTableRule.getAllDataNodes().containsKey("student"));
assertTrue(singleTableRule.getAllDataNodes().containsKey("t_order_0"));
@@ -217,7 +217,7 @@ public final class SingleTableRuleTest {
@Test
public void assertGetDataNodesByTableName() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
Collection<DataNode> actual = singleTableRule.getDataNodesByTableName("EMPLOYEE");
assertThat(actual.size(), is(1));
DataNode dataNode = actual.iterator().next();
@@ -228,7 +228,7 @@ public final class SingleTableRuleTest {
@Test
public void assertFindFirstActualTable() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String logicTable = "employee";
assertFalse(singleTableRule.findFirstActualTable(logicTable).isPresent());
}
@@ -236,14 +236,14 @@ public final class SingleTableRuleTest {
@Test
public void assertIsNeedAccumulate() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertFalse(singleTableRule.isNeedAccumulate(Collections.emptyList()));
}
@Test
public void assertFindLogicTableByActualTable() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String actualTable = "student";
assertFalse(singleTableRule.findLogicTableByActualTable(actualTable).isPresent());
}
@@ -251,7 +251,7 @@ public final class SingleTableRuleTest {
@Test
public void assertFindActualTableByCatalog() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleTableRule singleTableRule = new SingleTableRule(new SingleTableRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleTableRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
String catalog = "employee";
String logicTable = "t_order_0";
assertFalse(singleTableRule.findActualTableByCatalog(catalog, logicTable).isPresent());
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/builder/DefaultSingleTableDatabaseRuleConfigurationBuilderTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/DefaultSingleRuleConfigurationBuilderTest.java
similarity index 77%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/builder/DefaultSingleTableDatabaseRuleConfigurationBuilderTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/DefaultSingleRuleConfigurationBuilderTest.java
index 99595cccf24..f6ec13373f5 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/builder/DefaultSingleTableDatabaseRuleConfigurationBuilderTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/DefaultSingleRuleConfigurationBuilderTest.java
@@ -15,11 +15,11 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.rule.builder;
+package org.apache.shardingsphere.single.rule.builder;
import org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilder;
import org.apache.shardingsphere.infra.rule.builder.database.DefaultDatabaseRuleConfigurationBuilderFactory;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
import org.junit.Test;
import java.util.Collections;
@@ -27,13 +27,13 @@ import java.util.Collections;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
-public final class DefaultSingleTableDatabaseRuleConfigurationBuilderTest {
+public final class DefaultSingleRuleConfigurationBuilderTest {
@SuppressWarnings("rawtypes")
@Test
public void assertBuild() {
DefaultDatabaseRuleConfigurationBuilder builder =
- DefaultDatabaseRuleConfigurationBuilderFactory.getInstances(Collections.singletonList(new SingleTableRuleBuilder())).values().iterator().next();
- assertThat(builder.build(), instanceOf(SingleTableRuleConfiguration.class));
+ DefaultDatabaseRuleConfigurationBuilderFactory.getInstances(Collections.singletonList(new SingleRuleBuilder())).values().iterator().next();
+ assertThat(builder.build(), instanceOf(SingleRuleConfiguration.class));
}
}
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilderTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilderTest.java
similarity index 71%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilderTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilderTest.java
index ef48957a073..f1ad99edc31 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/rule/builder/SingleTableRuleBuilderTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilderTest.java
@@ -15,15 +15,15 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.rule.builder;
+package org.apache.shardingsphere.single.rule.builder;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilderFactory;
import org.apache.shardingsphere.infra.rule.identifier.scope.DatabaseRule;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.Test;
import java.util.Collections;
@@ -32,14 +32,14 @@ import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.mock;
-public final class SingleTableRuleBuilderTest {
+public final class SingleRuleBuilderTest {
@SuppressWarnings({"rawtypes", "unchecked"})
@Test
public void assertBuild() {
DatabaseRuleBuilder builder = DatabaseRuleBuilderFactory.getInstances().iterator().next();
- DatabaseRule actual = builder.build(mock(SingleTableRuleConfiguration.class), "", Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)), mock(InstanceContext.class));
- assertThat(actual, instanceOf(SingleTableRule.class));
+ DatabaseRule actual = builder.build(mock(SingleRuleConfiguration.class), "", Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)), mock(InstanceContext.class));
+ assertThat(actual, instanceOf(SingleRule.class));
}
@SuppressWarnings({"rawtypes", "unchecked"})
@@ -47,7 +47,7 @@ public final class SingleTableRuleBuilderTest {
public void assertBuildWithDefaultDataSource() {
DatabaseRuleBuilder builder = DatabaseRuleBuilderFactory.getInstances().iterator().next();
DatabaseRule actual = builder.build(
- new SingleTableRuleConfiguration("foo_ds"), "", Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)), mock(InstanceContext.class));
- assertThat(actual, instanceOf(SingleTableRule.class));
+ new SingleRuleConfiguration("foo_ds"), "", Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)), mock(InstanceContext.class));
+ assertThat(actual, instanceOf(SingleRule.class));
}
}
diff --git a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/swapper/YamlSingleTableRuleConfigurationSwapperTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/swapper/YamlSingleRuleConfigurationSwapperTest.java
similarity index 58%
rename from kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/swapper/YamlSingleTableRuleConfigurationSwapperTest.java
rename to kernel/single/core/src/test/java/org/apache/shardingsphere/single/swapper/YamlSingleRuleConfigurationSwapperTest.java
index 4d1ac07337c..86adc4d96e5 100644
--- a/kernel/single-table/core/src/test/java/org/apache/shardingsphere/singletable/swapper/YamlSingleTableRuleConfigurationSwapperTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/swapper/YamlSingleRuleConfigurationSwapperTest.java
@@ -15,11 +15,11 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.singletable.swapper;
+package org.apache.shardingsphere.single.swapper;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.yaml.config.pojo.YamlSingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.yaml.config.swapper.YamlSingleTableRuleConfigurationSwapper;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.yaml.config.pojo.YamlSingleRuleConfiguration;
+import org.apache.shardingsphere.single.yaml.config.swapper.YamlSingleRuleConfigurationSwapper;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.is;
@@ -28,29 +28,29 @@ import static org.junit.Assert.assertNull;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertTrue;
-public final class YamlSingleTableRuleConfigurationSwapperTest {
+public final class YamlSingleRuleConfigurationSwapperTest {
@Test
public void assertSwapToObject() {
- YamlSingleTableRuleConfiguration yamlConfig = new YamlSingleTableRuleConfiguration();
+ YamlSingleRuleConfiguration yamlConfig = new YamlSingleRuleConfiguration();
yamlConfig.setDefaultDataSource("ds_0");
- SingleTableRuleConfiguration ruleConfig = new YamlSingleTableRuleConfigurationSwapper().swapToObject(yamlConfig);
+ SingleRuleConfiguration ruleConfig = new YamlSingleRuleConfigurationSwapper().swapToObject(yamlConfig);
assertTrue(ruleConfig.getDefaultDataSource().isPresent());
assertThat(ruleConfig.getDefaultDataSource().get(), is("ds_0"));
}
@Test
public void assertSwapToObjectWithoutDataSource() {
- assertFalse(new YamlSingleTableRuleConfigurationSwapper().swapToObject(new YamlSingleTableRuleConfiguration()).getDefaultDataSource().isPresent());
+ assertFalse(new YamlSingleRuleConfigurationSwapper().swapToObject(new YamlSingleRuleConfiguration()).getDefaultDataSource().isPresent());
}
@Test
public void assertSwapToYaml() {
- assertThat(new YamlSingleTableRuleConfigurationSwapper().swapToYamlConfiguration(new SingleTableRuleConfiguration("ds_0")).getDefaultDataSource(), is("ds_0"));
+ assertThat(new YamlSingleRuleConfigurationSwapper().swapToYamlConfiguration(new SingleRuleConfiguration("ds_0")).getDefaultDataSource(), is("ds_0"));
}
@Test
public void assertSwapToYamlWithoutDataSource() {
- assertNull(new YamlSingleTableRuleConfigurationSwapper().swapToYamlConfiguration(new SingleTableRuleConfiguration()).getDefaultDataSource());
+ assertNull(new YamlSingleRuleConfigurationSwapper().swapToYamlConfiguration(new SingleRuleConfiguration()).getDefaultDataSource());
}
}
diff --git a/kernel/single-table/pom.xml b/kernel/single/pom.xml
similarity index 96%
rename from kernel/single-table/pom.xml
rename to kernel/single/pom.xml
index 92713ee71fe..cbb7c10a6f9 100644
--- a/kernel/single-table/pom.xml
+++ b/kernel/single/pom.xml
@@ -24,7 +24,7 @@
<artifactId>shardingsphere-kernel</artifactId>
<version>5.3.1-SNAPSHOT</version>
</parent>
- <artifactId>shardingsphere-single-table</artifactId>
+ <artifactId>shardingsphere-single</artifactId>
<packaging>pom</packaging>
<name>${project.artifactId}</name>
diff --git a/mode/type/cluster/core/pom.xml b/mode/type/cluster/core/pom.xml
index bafed015d00..230a591d2d8 100644
--- a/mode/type/cluster/core/pom.xml
+++ b/mode/type/cluster/core/pom.xml
@@ -45,7 +45,7 @@
</dependency>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table-core</artifactId>
+ <artifactId>shardingsphere-single-core</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/proxy/backend/pom.xml b/proxy/backend/pom.xml
index 959161d7e1d..ec5d854dfe0 100644
--- a/proxy/backend/pom.xml
+++ b/proxy/backend/pom.xml
@@ -160,7 +160,7 @@
</dependency>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table-core</artifactId>
+ <artifactId>shardingsphere-single-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
diff --git a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/ExportDatabaseConfigurationHandler.java b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/ExportDatabaseConfigurationHandler.java
index 1edbd051496..87cdb7c560f 100644
--- a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/ExportDatabaseConfigurationHandler.java
+++ b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/ExportDatabaseConfigurationHandler.java
@@ -38,7 +38,7 @@ import org.apache.shardingsphere.proxy.backend.handler.distsql.ral.QueryableRALB
import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
import javax.sql.DataSource;
import java.io.File;
@@ -137,8 +137,8 @@ public final class ExportDatabaseConfigurationHandler extends QueryableRALBacken
return ((EncryptRuleConfiguration) ruleConfig).getTables().isEmpty();
} else if (ruleConfig instanceof ShadowRuleConfiguration) {
return ((ShadowRuleConfiguration) ruleConfig).getTables().isEmpty();
- } else if (ruleConfig instanceof SingleTableRuleConfiguration) {
- return !((SingleTableRuleConfiguration) ruleConfig).getDefaultDataSource().isPresent();
+ } else if (ruleConfig instanceof SingleRuleConfiguration) {
+ return !((SingleRuleConfiguration) ruleConfig).getDefaultDataSource().isPresent();
}
return false;
}
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 950e15da8a9..7931b29755f 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
@@ -35,7 +35,7 @@ import org.apache.shardingsphere.proxy.backend.handler.DatabaseRequiredBackendHa
import org.apache.shardingsphere.proxy.backend.response.header.ResponseHeader;
import org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResponseHeader;
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import javax.sql.DataSource;
import java.sql.SQLException;
@@ -127,7 +127,7 @@ public final class UnregisterStorageUnitBackendHandler extends DatabaseRequiredB
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());
+ inUsedRules.remove(SingleRule.class.getSimpleName());
ShardingSpherePreconditions.checkState(inUsedRules.isEmpty(), () -> new ResourceInUsedException(each, inUsedRules));
}
}
diff --git a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitStatementUpdater.java b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitStatementUpdater.java
index 2db26837121..15074ec2516 100644
--- a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitStatementUpdater.java
+++ b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitStatementUpdater.java
@@ -23,7 +23,7 @@ import org.apache.shardingsphere.distsql.handler.exception.resource.MissingRequi
import org.apache.shardingsphere.distsql.handler.update.RuleDefinitionCreateUpdater;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.util.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
import java.util.Collection;
import java.util.Collections;
@@ -31,10 +31,10 @@ import java.util.Collections;
/**
* Set default single table storage unit statement updater.
*/
-public final class SetDefaultSingleTableStorageUnitStatementUpdater implements RuleDefinitionCreateUpdater<SetDefaultSingleTableStorageUnitStatement, SingleTableRuleConfiguration> {
+public final class SetDefaultSingleTableStorageUnitStatementUpdater implements RuleDefinitionCreateUpdater<SetDefaultSingleTableStorageUnitStatement, SingleRuleConfiguration> {
@Override
- public void checkSQLStatement(final ShardingSphereDatabase database, final SetDefaultSingleTableStorageUnitStatement sqlStatement, final SingleTableRuleConfiguration currentRuleConfig) {
+ public void checkSQLStatement(final ShardingSphereDatabase database, final SetDefaultSingleTableStorageUnitStatement sqlStatement, final SingleRuleConfiguration currentRuleConfig) {
checkStorageUnitExist(database, sqlStatement);
}
@@ -47,20 +47,20 @@ public final class SetDefaultSingleTableStorageUnitStatementUpdater implements R
}
@Override
- public SingleTableRuleConfiguration buildToBeCreatedRuleConfiguration(final SetDefaultSingleTableStorageUnitStatement sqlStatement) {
- SingleTableRuleConfiguration result = new SingleTableRuleConfiguration();
+ public SingleRuleConfiguration buildToBeCreatedRuleConfiguration(final SetDefaultSingleTableStorageUnitStatement sqlStatement) {
+ SingleRuleConfiguration result = new SingleRuleConfiguration();
result.setDefaultDataSource(sqlStatement.getDefaultStorageUnit());
return result;
}
@Override
- public void updateCurrentRuleConfiguration(final SingleTableRuleConfiguration currentRuleConfig, final SingleTableRuleConfiguration toBeCreatedRuleConfig) {
+ public void updateCurrentRuleConfiguration(final SingleRuleConfiguration currentRuleConfig, final SingleRuleConfiguration toBeCreatedRuleConfig) {
currentRuleConfig.setDefaultDataSource(toBeCreatedRuleConfig.getDefaultDataSource().orElse(null));
}
@Override
- public Class<SingleTableRuleConfiguration> getRuleConfigurationClass() {
- return SingleTableRuleConfiguration.class;
+ public Class<SingleRuleConfiguration> getRuleConfigurationClass() {
+ return SingleRuleConfiguration.class;
}
@Override
diff --git a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/CountSingleTableRuleResultSet.java b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/CountSingleTableRuleResultSet.java
index efe6e8f963d..2e8fa1101e1 100644
--- a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/CountSingleTableRuleResultSet.java
+++ b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/CountSingleTableRuleResultSet.java
@@ -20,7 +20,7 @@ package org.apache.shardingsphere.proxy.backend.handler.distsql.rql.rule;
import org.apache.shardingsphere.distsql.parser.statement.rql.show.CountSingleTableRuleStatement;
import org.apache.shardingsphere.distsql.handler.resultset.DatabaseDistSQLResultSet;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import java.util.Arrays;
@@ -49,13 +49,13 @@ public final class CountSingleTableRuleResultSet implements DatabaseDistSQLResul
@Override
public void init(final ShardingSphereDatabase database, final SQLStatement sqlStatement) {
- Optional<SingleTableRule> rule = database.getRuleMetaData().findSingleRule(SingleTableRule.class);
+ Optional<SingleRule> rule = database.getRuleMetaData().findSingleRule(SingleRule.class);
Map<String, LinkedList<Object>> result = new LinkedHashMap<>();
rule.ifPresent(optional -> addSingleTableData(result, database.getName(), rule.get()));
data = result.entrySet().iterator();
}
- private void addSingleTableData(final Map<String, LinkedList<Object>> rowMap, final String databaseName, final SingleTableRule rule) {
+ private void addSingleTableData(final Map<String, LinkedList<Object>> rowMap, final String databaseName, final SingleRule rule) {
rowMap.compute(SINGLE_TABLE, (key, value) -> buildRow(value, databaseName, rule.getAllTables().size()));
}
diff --git a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableResultSet.java b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableResultSet.java
index cb994c5d27c..90bd55a3fbc 100644
--- a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableResultSet.java
+++ b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableResultSet.java
@@ -22,7 +22,7 @@ import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.distsql.handler.resultset.DatabaseDistSQLResultSet;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.proxy.backend.util.RegularUtil;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.util.SQLUtil;
@@ -45,8 +45,8 @@ public final class SingleTableResultSet implements DatabaseDistSQLResultSet {
@Override
public void init(final ShardingSphereDatabase database, final SQLStatement sqlStatement) {
ShowSingleTableStatement showSingleTableStatement = (ShowSingleTableStatement) sqlStatement;
- Stream<DataNode> singleTableRules = database.getRuleMetaData().getRules().stream().filter(each -> each instanceof SingleTableRule)
- .map(each -> (SingleTableRule) each).map(each -> each.getSingleTableDataNodes().values()).flatMap(Collection::stream).filter(Objects::nonNull).map(each -> each.iterator().next());
+ Stream<DataNode> singleTableRules = database.getRuleMetaData().getRules().stream().filter(each -> each instanceof SingleRule)
+ .map(each -> (SingleRule) each).map(each -> each.getSingleTableDataNodes().values()).flatMap(Collection::stream).filter(Objects::nonNull).map(each -> each.iterator().next());
if (null != showSingleTableStatement.getTableName()) {
singleTableRules = singleTableRules.filter(each -> showSingleTableStatement.getTableName().equals(each.getTableName()));
}
diff --git a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableRuleResultSet.java b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableRuleResultSet.java
index 1f07e96011a..e571a3194ab 100644
--- a/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableRuleResultSet.java
+++ b/proxy/backend/src/main/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/rule/SingleTableRuleResultSet.java
@@ -20,7 +20,7 @@ package org.apache.shardingsphere.proxy.backend.handler.distsql.rql.rule;
import org.apache.shardingsphere.distsql.parser.statement.rql.show.ShowDefaultSingleTableStorageUnitStatement;
import org.apache.shardingsphere.distsql.handler.resultset.DatabaseDistSQLResultSet;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import java.util.Collection;
@@ -36,7 +36,7 @@ public final class SingleTableRuleResultSet implements DatabaseDistSQLResultSet
@Override
public void init(final ShardingSphereDatabase database, final SQLStatement sqlStatement) {
- SingleTableRule rule = database.getRuleMetaData().getSingleRule(SingleTableRule.class);
+ SingleRule rule = database.getRuleMetaData().getSingleRule(SingleRule.class);
data = Collections.singleton(rule.getConfiguration().getDefaultDataSource().orElse("RANDOM")).iterator();
}
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 bb626cfaf34..8192c5e8511 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
@@ -33,7 +33,7 @@ import org.apache.shardingsphere.proxy.backend.response.header.update.UpdateResp
import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
import org.apache.shardingsphere.proxy.backend.util.ProxyContextRestorer;
import org.apache.shardingsphere.shadow.rule.ShadowRule;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -76,7 +76,7 @@ public final class UnregisterStorageUnitBackendHandlerTest extends ProxyContextR
private ShadowRule shadowRule;
@Mock
- private SingleTableRule singleTableRule;
+ private SingleRule singleTableRule;
private ContextManager contextManager;
@@ -144,7 +144,7 @@ public final class UnregisterStorageUnitBackendHandlerTest extends ProxyContextR
@Test
public void assertStorageUnitNameInUseIgnoreSingleTables() throws SQLException {
when(ruleMetaData.getRules()).thenReturn(Collections.singleton(singleTableRule));
- when(singleTableRule.getType()).thenReturn("SingleTableRule");
+ when(singleTableRule.getType()).thenReturn("SingleRule");
DataNode dataNode = mock(DataNode.class);
when(dataNode.getDataSourceName()).thenReturn("foo_ds");
when(singleTableRule.getAllDataNodes()).thenReturn(Collections.singletonMap("", Collections.singleton(dataNode)));
diff --git a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitUpdaterTest.java b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitUpdaterTest.java
index 48e1f550a6e..0f23398adcd 100644
--- a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitUpdaterTest.java
+++ b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rdl/rule/SetDefaultSingleTableStorageUnitUpdaterTest.java
@@ -20,7 +20,7 @@ package org.apache.shardingsphere.proxy.backend.handler.distsql.rdl.rule;
import org.apache.shardingsphere.distsql.parser.statement.rdl.create.SetDefaultSingleTableStorageUnitStatement;
import org.apache.shardingsphere.distsql.handler.exception.resource.MissingRequiredResourcesException;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
import org.junit.Before;
import org.junit.Test;
@@ -46,7 +46,7 @@ public final class SetDefaultSingleTableStorageUnitUpdaterTest {
private ShardingSphereDatabase database;
@Mock
- private SingleTableRuleConfiguration currentConfig;
+ private SingleRuleConfiguration currentConfig;
@Before
public void setUp() {
@@ -61,15 +61,15 @@ public final class SetDefaultSingleTableStorageUnitUpdaterTest {
@Test
public void assertBuild() {
- SingleTableRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement("ds_0"));
+ SingleRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement("ds_0"));
assertTrue(toBeCreatedRuleConfig.getDefaultDataSource().isPresent());
assertThat(toBeCreatedRuleConfig.getDefaultDataSource().get(), is("ds_0"));
}
@Test
public void assertUpdate() {
- SingleTableRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement("ds_0"));
- SingleTableRuleConfiguration currentConfig = new SingleTableRuleConfiguration();
+ SingleRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement("ds_0"));
+ SingleRuleConfiguration currentConfig = new SingleRuleConfiguration();
updater.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
assertTrue(currentConfig.getDefaultDataSource().isPresent());
assertThat(currentConfig.getDefaultDataSource().get(), is("ds_0"));
@@ -77,8 +77,8 @@ public final class SetDefaultSingleTableStorageUnitUpdaterTest {
@Test
public void assertRandom() {
- SingleTableRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement(null));
- SingleTableRuleConfiguration currentConfig = new SingleTableRuleConfiguration();
+ SingleRuleConfiguration toBeCreatedRuleConfig = updater.buildToBeCreatedRuleConfiguration(new SetDefaultSingleTableStorageUnitStatement(null));
+ SingleRuleConfiguration currentConfig = new SingleRuleConfiguration();
updater.updateCurrentRuleConfiguration(currentConfig, toBeCreatedRuleConfig);
assertFalse(currentConfig.getDefaultDataSource().isPresent());
}
diff --git a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableRuleResultSetTest.java b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableRuleResultSetTest.java
index 884e3ba07ac..1d34ea2b57b 100644
--- a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableRuleResultSetTest.java
+++ b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/CountSingleTableRuleResultSetTest.java
@@ -21,7 +21,7 @@ import org.apache.shardingsphere.distsql.parser.statement.rql.show.CountSingleTa
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.rule.ShardingSphereRuleMetaData;
import org.apache.shardingsphere.proxy.backend.handler.distsql.rql.rule.CountSingleTableRuleResultSet;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.Test;
import java.util.ArrayList;
@@ -56,14 +56,14 @@ public final class CountSingleTableRuleResultSetTest {
ShardingSphereDatabase result = mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
when(result.getName()).thenReturn("db_1");
ShardingSphereRuleMetaData ruleMetaData = mock(ShardingSphereRuleMetaData.class);
- SingleTableRule singleTableRule = mockSingleTableRule();
- when(ruleMetaData.findSingleRule(SingleTableRule.class)).thenReturn(Optional.of(singleTableRule));
+ SingleRule singleTableRule = mockSingleTableRule();
+ when(ruleMetaData.findSingleRule(SingleRule.class)).thenReturn(Optional.of(singleTableRule));
when(result.getRuleMetaData()).thenReturn(ruleMetaData);
return result;
}
- private SingleTableRule mockSingleTableRule() {
- SingleTableRule result = mock(SingleTableRule.class);
+ private SingleRule mockSingleTableRule() {
+ SingleRule result = mock(SingleRule.class);
when(result.getAllTables()).thenReturn(Arrays.asList("single_table_1", "single_table_2"));
return result;
}
diff --git a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableResultSetTest.java b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableResultSetTest.java
index c466460a314..06963feffc1 100644
--- a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableResultSetTest.java
+++ b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableResultSetTest.java
@@ -26,7 +26,7 @@ import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.proxy.backend.handler.distsql.rql.rule.SingleTableResultSet;
import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
import org.apache.shardingsphere.shadow.rule.ShadowRule;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -139,8 +139,8 @@ public final class SingleTableResultSetTest {
assertThat(iterator.next(), is("ds_2"));
}
- private SingleTableRule mockSingleTableRule(final Map<String, Collection<DataNode>> singleTableDataNodeMap) {
- SingleTableRule result = mock(SingleTableRule.class);
+ private SingleRule mockSingleTableRule(final Map<String, Collection<DataNode>> singleTableDataNodeMap) {
+ SingleRule result = mock(SingleRule.class);
when(result.getSingleTableDataNodes()).thenReturn(singleTableDataNodeMap);
return result;
}
diff --git a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableRuleResultSetTest.java b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableRuleResultSetTest.java
index 97173df5461..a212dfdcbe3 100644
--- a/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableRuleResultSetTest.java
+++ b/proxy/backend/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/rql/SingleTableRuleResultSetTest.java
@@ -22,8 +22,8 @@ import org.apache.shardingsphere.distsql.handler.resultset.DatabaseDistSQLResult
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.rule.ShardingSphereRuleMetaData;
import org.apache.shardingsphere.proxy.backend.handler.distsql.rql.rule.SingleTableRuleResultSet;
-import org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.junit.Test;
import java.util.Collection;
@@ -48,10 +48,10 @@ public final class SingleTableRuleResultSetTest {
private ShardingSphereDatabase mockDatabase() {
ShardingSphereDatabase result = mock(ShardingSphereDatabase.class);
- SingleTableRule rule = mock(SingleTableRule.class);
- when(rule.getConfiguration()).thenReturn(new SingleTableRuleConfiguration("foo_ds"));
+ SingleRule rule = mock(SingleRule.class);
+ when(rule.getConfiguration()).thenReturn(new SingleRuleConfiguration("foo_ds"));
ShardingSphereRuleMetaData ruleMetaData = mock(ShardingSphereRuleMetaData.class);
- when(ruleMetaData.getSingleRule(SingleTableRule.class)).thenReturn(rule);
+ when(ruleMetaData.getSingleRule(SingleRule.class)).thenReturn(rule);
when(result.getRuleMetaData()).thenReturn(ruleMetaData);
return result;
}
diff --git a/test/it/rewriter/pom.xml b/test/it/rewriter/pom.xml
index 7e16b3a717d..07e1e348066 100644
--- a/test/it/rewriter/pom.xml
+++ b/test/it/rewriter/pom.xml
@@ -36,7 +36,7 @@
</dependency>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-single-table-core</artifactId>
+ <artifactId>shardingsphere-single-core</artifactId>
<version>${project.version}</version>
<scope>test</scope>
</dependency>
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/EncryptSQLRewriterIT.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/EncryptSQLRewriterIT.java
index 123d9c928f4..4de4f73ce95 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/EncryptSQLRewriterIT.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/EncryptSQLRewriterIT.java
@@ -26,7 +26,7 @@ import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
import org.apache.shardingsphere.test.it.rewrite.engine.AbstractSQLRewriterIT;
import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParametersBuilder;
import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.CreateTableStatement;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
@@ -89,7 +89,7 @@ public final class EncryptSQLRewriterIT extends AbstractSQLRewriterIT {
@Override
protected void mockRules(final Collection<ShardingSphereRule> rules, final String schemaName, final SQLStatement sqlStatement) {
- Optional<SingleTableRule> singleTableRule = rules.stream().filter(each -> each instanceof SingleTableRule).map(each -> (SingleTableRule) each).findFirst();
+ Optional<SingleRule> singleTableRule = rules.stream().filter(each -> each instanceof SingleRule).map(each -> (SingleRule) each).findFirst();
if (singleTableRule.isPresent() && !(sqlStatement instanceof CreateTableStatement)) {
singleTableRule.get().put("encrypt_ds", schemaName, "t_account");
singleTableRule.get().put("encrypt_ds", schemaName, "t_account_bak");
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/ShardingSQLRewriterIT.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/ShardingSQLRewriterIT.java
index f35f10fc0a0..fabd13ce2a2 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/ShardingSQLRewriterIT.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/scenario/ShardingSQLRewriterIT.java
@@ -28,7 +28,7 @@ import org.apache.shardingsphere.infra.yaml.config.pojo.YamlRootConfiguration;
import org.apache.shardingsphere.test.it.rewrite.engine.AbstractSQLRewriterIT;
import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParametersBuilder;
import org.apache.shardingsphere.test.it.rewrite.engine.parameter.SQLRewriteEngineTestParameters;
-import org.apache.shardingsphere.singletable.rule.SingleTableRule;
+import org.apache.shardingsphere.single.rule.SingleRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.CreateTableStatement;
import org.junit.runners.Parameterized.Parameters;
@@ -71,7 +71,7 @@ public final class ShardingSQLRewriterIT extends AbstractSQLRewriterIT {
@Override
protected void mockRules(final Collection<ShardingSphereRule> rules, final String schemaName, final SQLStatement sqlStatement) {
- Optional<SingleTableRule> singleTableRule = rules.stream().filter(each -> each instanceof SingleTableRule).map(each -> (SingleTableRule) each).findFirst();
+ Optional<SingleRule> singleTableRule = rules.stream().filter(each -> each instanceof SingleRule).map(each -> (SingleRule) each).findFirst();
if (singleTableRule.isPresent() && !(sqlStatement instanceof CreateTableStatement)) {
singleTableRule.get().put("db", schemaName, "t_single");
singleTableRule.get().put("db", schemaName, "t_single_extend");