You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by ch...@apache.org on 2023/10/18 10:29:05 UTC
[shardingsphere] branch master updated: Refactor SingleRule to pass protocolType for heterogeneous database scenario single table load (#28795)
This is an automated email from the ASF dual-hosted git repository.
chengzhang 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 10dc2ddfd44 Refactor SingleRule to pass protocolType for heterogeneous database scenario single table load (#28795)
10dc2ddfd44 is described below
commit 10dc2ddfd4497f2eafee892bbba5e0fe5b737f08
Author: Zhengqiang Duan <du...@apache.org>
AuthorDate: Wed Oct 18 18:28:58 2023 +0800
Refactor SingleRule to pass protocolType for heterogeneous database scenario single table load (#28795)
* Refactor SingleRule to pass protocolType for heterogeneous database scenario single table load
* fix unit test
* Revert oracle pom dependency
---
.../rule/builder/BroadcastRuleBuilder.java | 5 ++--
.../rule/builder/BroadcastRuleBuilderTest.java | 3 ++-
.../rule/builder/CompatibleEncryptRuleBuilder.java | 3 ++-
.../encrypt/rule/builder/EncryptRuleBuilder.java | 3 ++-
.../rule/builder/EncryptRuleBuilderTest.java | 3 ++-
.../mask/rule/builder/MaskRuleBuilder.java | 3 ++-
.../mask/rule/builder/MaskRuleBuilderTest.java | 3 ++-
.../builder/ReadwriteSplittingRuleBuilder.java | 3 ++-
.../builder/ReadwriteSplittingRuleBuilderTest.java | 3 ++-
.../shadow/rule/builder/ShadowRuleBuilder.java | 3 ++-
.../shadow/rule/builder/ShadowRuleBuilderTest.java | 3 ++-
.../sharding/rule/builder/ShardingRuleBuilder.java | 5 ++--
.../ShardingRoutingEngineFixtureBuilder.java | 3 ++-
.../rule/builder/ShardingRuleBuilderTest.java | 7 ++---
.../metadata/database/ShardingSphereDatabase.java | 2 +-
.../rule/builder/database/DatabaseRuleBuilder.java | 4 ++-
.../builder/database/DatabaseRulesBuilder.java | 13 +++++----
.../builder/database/DatabaseRulesBuilderTest.java | 5 ++--
.../fixture/FixtureDatabaseRuleBuilder.java | 3 ++-
.../metadata/factory/InternalMetaDataFactory.java | 7 ++---
.../factory/NewInternalMetaDataFactory.java | 7 ++---
.../single/datanode/SingleTableDataNodeLoader.java | 29 ++++++++++----------
.../SingleRuleConfigurationDecorator.java | 4 +--
.../shardingsphere/single/rule/SingleRule.java | 26 +++++++++---------
.../single/rule/builder/SingleRuleBuilder.java | 5 ++--
.../datanode/SingleTableDataNodeLoaderTest.java | 1 +
.../single/route/SingleSQLRouterTest.java | 13 ++++-----
.../SingleDatabaseBroadcastRouteEngineTest.java | 3 ++-
.../engine/SingleStandardRouteEngineTest.java | 8 +++---
.../shardingsphere/single/rule/SingleRuleTest.java | 31 +++++++++++-----------
.../single/rule/builder/SingleRuleBuilderTest.java | 7 +++--
.../query/ShowUnloadedSingleTableExecutor.java | 2 +-
.../update/LoadSingleTableStatementUpdater.java | 4 ++-
.../context/ConfigurationContextManager.java | 4 +--
.../mode/fixture/ModeRuleBuilderFixture.java | 3 ++-
.../YamlDatabaseConfigurationImportExecutor.java | 2 +-
.../org/apache/shardingsphere/proxy/Bootstrap.java | 6 ++---
.../test/it/rewrite/engine/SQLRewriterIT.java | 6 ++---
38 files changed, 140 insertions(+), 105 deletions(-)
diff --git a/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilder.java b/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilder.java
index c3cb032add4..1d1365af371 100644
--- a/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilder.java
+++ b/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilder.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.broadcast.rule.builder;
import org.apache.shardingsphere.broadcast.api.config.BroadcastRuleConfiguration;
import org.apache.shardingsphere.broadcast.constant.BroadcastOrder;
import org.apache.shardingsphere.broadcast.rule.BroadcastRule;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -34,8 +35,8 @@ import java.util.Map;
public final class BroadcastRuleBuilder implements DatabaseRuleBuilder<BroadcastRuleConfiguration> {
@Override
- public BroadcastRule build(final BroadcastRuleConfiguration config, final String databaseName, final Map<String, DataSource> dataSources,
- final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
+ public BroadcastRule build(final BroadcastRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
+ final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new BroadcastRule(config, databaseName, dataSources);
}
diff --git a/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilderTest.java b/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilderTest.java
index cc6d18d1ab4..e0c579de250 100644
--- a/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilderTest.java
+++ b/features/broadcast/core/src/test/java/org/apache/shardingsphere/broadcast/rule/builder/BroadcastRuleBuilderTest.java
@@ -22,6 +22,7 @@ import org.apache.shardingsphere.broadcast.rule.BroadcastRule;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
+import org.apache.shardingsphere.test.fixture.database.MockedDatabaseType;
import org.junit.jupiter.api.Test;
import java.util.Collections;
@@ -37,6 +38,6 @@ class BroadcastRuleBuilderTest {
void assertBuild() {
BroadcastRuleConfiguration ruleConfig = mock(BroadcastRuleConfiguration.class);
DatabaseRuleBuilder builder = OrderedSPILoader.getServices(DatabaseRuleBuilder.class, Collections.singleton(ruleConfig)).get(ruleConfig);
- assertThat(builder.build(ruleConfig, "", Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(BroadcastRule.class));
+ assertThat(builder.build(ruleConfig, "", new MockedDatabaseType(), Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(BroadcastRule.class));
}
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/CompatibleEncryptRuleBuilder.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/CompatibleEncryptRuleBuilder.java
index 57bfc21ccef..20a2ad62e28 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/CompatibleEncryptRuleBuilder.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/CompatibleEncryptRuleBuilder.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.encrypt.rule.builder;
import org.apache.shardingsphere.encrypt.api.config.CompatibleEncryptRuleConfiguration;
import org.apache.shardingsphere.encrypt.constant.EncryptOrder;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -37,7 +38,7 @@ import java.util.Map;
public final class CompatibleEncryptRuleBuilder implements DatabaseRuleBuilder<CompatibleEncryptRuleConfiguration> {
@Override
- public EncryptRule build(final CompatibleEncryptRuleConfiguration config, final String databaseName,
+ public EncryptRule build(final CompatibleEncryptRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new EncryptRule(databaseName, config);
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilder.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilder.java
index 34b8d7622bb..d65d87539e8 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilder.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilder.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.encrypt.rule.builder;
import org.apache.shardingsphere.encrypt.api.config.EncryptRuleConfiguration;
import org.apache.shardingsphere.encrypt.constant.EncryptOrder;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -34,7 +35,7 @@ import java.util.Map;
public final class EncryptRuleBuilder implements DatabaseRuleBuilder<EncryptRuleConfiguration> {
@Override
- public EncryptRule build(final EncryptRuleConfiguration config, final String databaseName,
+ public EncryptRule build(final EncryptRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new EncryptRule(databaseName, config);
}
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilderTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilderTest.java
index e002840e9a4..ad27b325c8b 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilderTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rule/builder/EncryptRuleBuilderTest.java
@@ -22,6 +22,7 @@ import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
+import org.apache.shardingsphere.test.fixture.database.MockedDatabaseType;
import org.junit.jupiter.api.Test;
import java.util.Collections;
@@ -37,6 +38,6 @@ class EncryptRuleBuilderTest {
void assertBuild() {
EncryptRuleConfiguration ruleConfig = mock(EncryptRuleConfiguration.class);
DatabaseRuleBuilder builder = OrderedSPILoader.getServices(DatabaseRuleBuilder.class, Collections.singleton(ruleConfig)).get(ruleConfig);
- assertThat(builder.build(ruleConfig, "", Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(EncryptRule.class));
+ assertThat(builder.build(ruleConfig, "", new MockedDatabaseType(), Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(EncryptRule.class));
}
}
diff --git a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilder.java b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilder.java
index afa30544624..6b5c00d9b28 100644
--- a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilder.java
+++ b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilder.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.mask.rule.builder;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -34,7 +35,7 @@ import java.util.Map;
public final class MaskRuleBuilder implements DatabaseRuleBuilder<MaskRuleConfiguration> {
@Override
- public MaskRule build(final MaskRuleConfiguration config, final String databaseName,
+ public MaskRule build(final MaskRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new MaskRule(config);
}
diff --git a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilderTest.java b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilderTest.java
index efb3efc7c36..997e3b46024 100644
--- a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilderTest.java
+++ b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/rule/builder/MaskRuleBuilderTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.mask.rule.builder;
+import org.apache.shardingsphere.infra.database.mysql.type.MySQLDatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
@@ -37,6 +38,6 @@ class MaskRuleBuilderTest {
void assertBuild() {
MaskRuleConfiguration ruleConfig = mock(MaskRuleConfiguration.class);
DatabaseRuleBuilder builder = OrderedSPILoader.getServices(DatabaseRuleBuilder.class, Collections.singleton(ruleConfig)).get(ruleConfig);
- assertThat(builder.build(ruleConfig, "", Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(MaskRule.class));
+ assertThat(builder.build(ruleConfig, "", new MySQLDatabaseType(), Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(MaskRule.class));
}
}
diff --git a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilder.java b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilder.java
index ba9ebde6989..be4c696272f 100644
--- a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilder.java
+++ b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilder.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.readwritesplitting.rule.builder;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -34,7 +35,7 @@ import java.util.Map;
public final class ReadwriteSplittingRuleBuilder implements DatabaseRuleBuilder<ReadwriteSplittingRuleConfiguration> {
@Override
- public ReadwriteSplittingRule build(final ReadwriteSplittingRuleConfiguration config, final String databaseName,
+ public ReadwriteSplittingRule build(final ReadwriteSplittingRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new ReadwriteSplittingRule(databaseName, config, instanceContext);
}
diff --git a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java
index 8aa3af15ada..e0b79221ec6 100644
--- a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java
+++ b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java
@@ -23,6 +23,7 @@ import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
import org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
+import org.apache.shardingsphere.test.fixture.database.MockedDatabaseType;
import org.junit.jupiter.api.Test;
import java.util.Collections;
@@ -39,6 +40,6 @@ class ReadwriteSplittingRuleBuilderTest {
ReadwriteSplittingRuleConfiguration ruleConfig = new ReadwriteSplittingRuleConfiguration(Collections.singleton(
new ReadwriteSplittingDataSourceRuleConfiguration("name", "writeDataSourceName", Collections.singletonList("readDataSourceName"), "loadBalancerName")), Collections.emptyMap());
DatabaseRuleBuilder builder = OrderedSPILoader.getServices(DatabaseRuleBuilder.class, Collections.singleton(ruleConfig)).get(ruleConfig);
- assertThat(builder.build(ruleConfig, "", Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(ReadwriteSplittingRule.class));
+ assertThat(builder.build(ruleConfig, "", new MockedDatabaseType(), Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(ReadwriteSplittingRule.class));
}
}
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilder.java b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilder.java
index 7735cbf76fa..e68462d69ef 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilder.java
+++ b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilder.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.shadow.rule.builder;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -34,7 +35,7 @@ import java.util.Map;
public final class ShadowRuleBuilder implements DatabaseRuleBuilder<ShadowRuleConfiguration> {
@Override
- public ShadowRule build(final ShadowRuleConfiguration config, final String databaseName,
+ public ShadowRule build(final ShadowRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new ShadowRule(config);
}
diff --git a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilderTest.java b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilderTest.java
index 0f424f71d07..6a58968a095 100644
--- a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilderTest.java
+++ b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/rule/builder/ShadowRuleBuilderTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.shadow.rule.builder;
+import org.apache.shardingsphere.infra.database.mysql.type.MySQLDatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
@@ -37,6 +38,6 @@ class ShadowRuleBuilderTest {
void assertBuild() {
ShadowRuleConfiguration ruleConfig = new ShadowRuleConfiguration();
DatabaseRuleBuilder builder = OrderedSPILoader.getServices(DatabaseRuleBuilder.class, Collections.singleton(ruleConfig)).get(ruleConfig);
- assertThat(builder.build(ruleConfig, "", Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(ShadowRule.class));
+ assertThat(builder.build(ruleConfig, "", new MySQLDatabaseType(), Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(ShadowRule.class));
}
}
diff --git a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilder.java b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilder.java
index d0ea8dab04f..a239e23b194 100644
--- a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilder.java
+++ b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilder.java
@@ -17,10 +17,11 @@
package org.apache.shardingsphere.sharding.rule.builder;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
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.exception.core.ShardingSpherePreconditions;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.constant.ShardingOrder;
import org.apache.shardingsphere.sharding.exception.metadata.MissingRequiredShardingConfigurationException;
@@ -36,7 +37,7 @@ import java.util.Map;
public final class ShardingRuleBuilder implements DatabaseRuleBuilder<ShardingRuleConfiguration> {
@Override
- public ShardingRule build(final ShardingRuleConfiguration config, final String databaseName,
+ public ShardingRule build(final ShardingRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
ShardingSpherePreconditions.checkState(null != dataSources && !dataSources.isEmpty(), () -> new MissingRequiredShardingConfigurationException("Data source", databaseName));
return new ShardingRule(config, dataSources.keySet(), instanceContext);
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/ShardingRoutingEngineFixtureBuilder.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/ShardingRoutingEngineFixtureBuilder.java
index c07736b4aab..78baf5241e3 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/ShardingRoutingEngineFixtureBuilder.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/route/engine/fixture/ShardingRoutingEngineFixtureBuilder.java
@@ -23,6 +23,7 @@ import lombok.SneakyThrows;
import org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
+import org.apache.shardingsphere.infra.database.h2.type.H2DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
@@ -291,7 +292,7 @@ public final class ShardingRoutingEngineFixtureBuilder {
*/
public static SingleRule createSingleRule(final Collection<ShardingSphereRule> rules) {
Map<String, DataSource> dataSourceMap = createDataSourceMap();
- SingleRule result = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, dataSourceMap, rules);
+ SingleRule result = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), 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/rule/builder/ShardingRuleBuilderTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilderTest.java
index 37e7b5cfd9d..e1c80628f16 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilderTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/rule/builder/ShardingRuleBuilderTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.sharding.rule.builder;
+import org.apache.shardingsphere.infra.database.mysql.type.MySQLDatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
@@ -51,7 +52,7 @@ class ShardingRuleBuilderTest {
@SuppressWarnings("unchecked")
@Test
void assertBuild() {
- assertThat(builder.build(ruleConfig, "sharding_db",
+ assertThat(builder.build(ruleConfig, "sharding_db", new MySQLDatabaseType(),
Collections.singletonMap("name", mock(DataSource.class, RETURNS_DEEP_STUBS)), Collections.emptyList(), mock(InstanceContext.class)), instanceOf(ShardingRule.class));
}
@@ -59,13 +60,13 @@ class ShardingRuleBuilderTest {
@Test
void assertBuildWithNullDataSourceMap() {
assertThrows(MissingRequiredShardingConfigurationException.class,
- () -> builder.build(ruleConfig, "sharding_db", null, Collections.emptyList(), mock(InstanceContext.class)));
+ () -> builder.build(ruleConfig, "sharding_db", new MySQLDatabaseType(), null, Collections.emptyList(), mock(InstanceContext.class)));
}
@SuppressWarnings("unchecked")
@Test
void assertBuildWithEmptyDataSourceMap() {
assertThrows(MissingRequiredShardingConfigurationException.class,
- () -> builder.build(ruleConfig, "sharding_db", Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)));
+ () -> builder.build(ruleConfig, "sharding_db", new MySQLDatabaseType(), Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)));
}
}
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java
index 88a63a1861a..afde6bc5e49 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java
@@ -88,7 +88,7 @@ public final class ShardingSphereDatabase {
*/
public static ShardingSphereDatabase create(final String name, final DatabaseType protocolType, final Map<String, DatabaseType> storageTypes,
final DatabaseConfiguration databaseConfig, final ConfigurationProperties props, final InstanceContext instanceContext) throws SQLException {
- Collection<ShardingSphereRule> databaseRules = DatabaseRulesBuilder.build(name, databaseConfig, instanceContext);
+ Collection<ShardingSphereRule> databaseRules = DatabaseRulesBuilder.build(name, protocolType, databaseConfig, instanceContext);
Map<String, ShardingSphereSchema> schemas = new ConcurrentHashMap<>(GenericSchemaBuilder
.build(new GenericSchemaBuilderMaterial(protocolType, storageTypes, DataSourceStateManager.getInstance().getEnabledDataSources(name, databaseConfig), databaseRules,
props, new DatabaseTypeRegistry(protocolType).getDefaultSchemaName(name))));
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRuleBuilder.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRuleBuilder.java
index 1e3ab5be6ec..26feb2688e2 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRuleBuilder.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRuleBuilder.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.infra.rule.builder.database;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.RuleBuilder;
@@ -41,10 +42,11 @@ public interface DatabaseRuleBuilder<T extends RuleConfiguration> extends RuleBu
*
* @param config rule configuration
* @param databaseName database name
+ * @param protocolType protocol type
* @param dataSources data sources
* @param builtRules built rules
* @param instanceContext instance context
* @return built database rule
*/
- DatabaseRule build(T config, String databaseName, Map<String, DataSource> dataSources, Collection<ShardingSphereRule> builtRules, InstanceContext instanceContext);
+ DatabaseRule build(T config, String databaseName, DatabaseType protocolType, Map<String, DataSource> dataSources, Collection<ShardingSphereRule> builtRules, InstanceContext instanceContext);
}
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilder.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilder.java
index 18c8ca2dd4f..e1dce396d8a 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilder.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilder.java
@@ -24,6 +24,7 @@ import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.checker.RuleConfigurationChecker;
import org.apache.shardingsphere.infra.config.rule.function.DistributedRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.function.EnhancedRuleConfiguration;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
@@ -49,12 +50,13 @@ public final class DatabaseRulesBuilder {
* Build database rules.
*
* @param databaseName database name
+ * @param protocolType protocol type
* @param databaseConfig database configuration
* @param instanceContext instance context
* @return built rules
*/
@SuppressWarnings({"unchecked", "rawtypes"})
- public static Collection<ShardingSphereRule> build(final String databaseName, final DatabaseConfiguration databaseConfig, final InstanceContext instanceContext) {
+ public static Collection<ShardingSphereRule> build(final String databaseName, final DatabaseType protocolType, final DatabaseConfiguration databaseConfig, final InstanceContext instanceContext) {
Collection<ShardingSphereRule> result = new LinkedList<>();
for (Entry<RuleConfiguration, DatabaseRuleBuilder> entry : getRuleBuilderMap(databaseConfig).entrySet()) {
RuleConfigurationChecker configChecker = OrderedSPILoader.getServicesByClass(
@@ -63,7 +65,7 @@ public final class DatabaseRulesBuilder {
if (null != configChecker) {
configChecker.check(databaseName, entry.getKey(), dataSources, result);
}
- result.add(entry.getValue().build(entry.getKey(), databaseName, dataSources, result, instanceContext));
+ result.add(entry.getValue().build(entry.getKey(), databaseName, protocolType, dataSources, result, instanceContext));
}
return result;
}
@@ -72,6 +74,7 @@ public final class DatabaseRulesBuilder {
* Build database rules.
*
* @param databaseName database name
+ * @param protocolType protocol type
* @param dataSources data sources
* @param rules rules
* @param ruleConfig rule configuration
@@ -79,8 +82,8 @@ public final class DatabaseRulesBuilder {
* @return built rules
*/
@SuppressWarnings({"unchecked", "rawtypes"})
- public static Collection<ShardingSphereRule> build(final String databaseName, final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> rules,
- final RuleConfiguration ruleConfig, final InstanceContext instanceContext) {
+ public static Collection<ShardingSphereRule> build(final String databaseName, final DatabaseType protocolType, final Map<String, DataSource> dataSources,
+ final Collection<ShardingSphereRule> rules, final RuleConfiguration ruleConfig, final InstanceContext instanceContext) {
Collection<ShardingSphereRule> result = new LinkedList<>();
for (Entry<RuleConfiguration, DatabaseRuleBuilder> entry : OrderedSPILoader.getServices(DatabaseRuleBuilder.class,
Collections.singletonList(ruleConfig), Comparator.reverseOrder()).entrySet()) {
@@ -89,7 +92,7 @@ public final class DatabaseRulesBuilder {
if (null != configChecker) {
configChecker.check(databaseName, entry.getKey(), dataSources, rules);
}
- result.add(entry.getValue().build(entry.getKey(), databaseName, dataSources, rules, instanceContext));
+ result.add(entry.getValue().build(entry.getKey(), databaseName, protocolType, dataSources, rules, instanceContext));
}
return result;
}
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilderTest.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilderTest.java
index 39d50181480..96e03c96e2a 100644
--- a/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilderTest.java
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/database/DatabaseRulesBuilderTest.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.infra.rule.builder.database;
import org.apache.shardingsphere.infra.config.database.impl.DataSourceProvidedDatabaseConfiguration;
+import org.apache.shardingsphere.infra.database.mysql.type.MySQLDatabaseType;
import org.apache.shardingsphere.infra.fixture.FixtureRule;
import org.apache.shardingsphere.infra.fixture.FixtureRuleConfiguration;
import org.apache.shardingsphere.infra.instance.InstanceContext;
@@ -36,8 +37,8 @@ class DatabaseRulesBuilderTest {
@Test
void assertBuild() {
- Iterator<ShardingSphereRule> actual = DatabaseRulesBuilder.build(
- "foo_db", new DataSourceProvidedDatabaseConfiguration(Collections.emptyMap(), Collections.singleton(new FixtureRuleConfiguration())), mock(InstanceContext.class)).iterator();
+ Iterator<ShardingSphereRule> actual = DatabaseRulesBuilder.build("foo_db", new MySQLDatabaseType(),
+ new DataSourceProvidedDatabaseConfiguration(Collections.emptyMap(), Collections.singleton(new FixtureRuleConfiguration())), mock(InstanceContext.class)).iterator();
assertThat(actual.next(), instanceOf(FixtureRule.class));
assertFalse(actual.hasNext());
}
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/fixture/FixtureDatabaseRuleBuilder.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/fixture/FixtureDatabaseRuleBuilder.java
index 5ba9d3fad2d..c93695deeef 100644
--- a/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/fixture/FixtureDatabaseRuleBuilder.java
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/builder/fixture/FixtureDatabaseRuleBuilder.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.infra.rule.builder.fixture;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.fixture.FixtureRule;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
@@ -29,7 +30,7 @@ import java.util.Map;
public final class FixtureDatabaseRuleBuilder implements DatabaseRuleBuilder<FixtureDatabaseRuleConfiguration> {
@Override
- public FixtureRule build(final FixtureDatabaseRuleConfiguration config, final String databaseName,
+ public FixtureRule build(final FixtureDatabaseRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new FixtureRule();
}
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/InternalMetaDataFactory.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/InternalMetaDataFactory.java
index 58a8f3e780e..45cc2e6b933 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/InternalMetaDataFactory.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/InternalMetaDataFactory.java
@@ -21,8 +21,8 @@ import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
-import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRulesBuilder;
@@ -50,8 +50,9 @@ public final class InternalMetaDataFactory {
*/
public static ShardingSphereDatabase create(final String databaseName, final MetaDataBasedPersistService persistService, final DatabaseConfiguration databaseConfig,
final ConfigurationProperties props, final InstanceContext instanceContext) {
- return ShardingSphereDatabase.create(databaseName, DatabaseTypeEngine.getProtocolType(databaseName, databaseConfig, props), databaseConfig,
- DatabaseRulesBuilder.build(databaseName, databaseConfig, instanceContext), persistService.getDatabaseMetaDataService().loadSchemas(databaseName));
+ DatabaseType protocolType = DatabaseTypeEngine.getProtocolType(databaseName, databaseConfig, props);
+ return ShardingSphereDatabase.create(databaseName, protocolType, databaseConfig, DatabaseRulesBuilder.build(databaseName, protocolType, databaseConfig, instanceContext),
+ persistService.getDatabaseMetaDataService().loadSchemas(databaseName));
}
/**
diff --git a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/NewInternalMetaDataFactory.java b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/NewInternalMetaDataFactory.java
index 34c43929adc..f64a9ae9e66 100644
--- a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/NewInternalMetaDataFactory.java
+++ b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/factory/NewInternalMetaDataFactory.java
@@ -21,8 +21,8 @@ import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
-import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRulesBuilder;
@@ -51,8 +51,9 @@ public final class NewInternalMetaDataFactory {
*/
public static ShardingSphereDatabase create(final String databaseName, final NewMetaDataPersistService persistService, final DatabaseConfiguration databaseConfig,
final ConfigurationProperties props, final InstanceContext instanceContext) {
- return ShardingSphereDatabase.create(databaseName, DatabaseTypeEngine.getProtocolType(databaseName, databaseConfig, props), databaseConfig,
- DatabaseRulesBuilder.build(databaseName, databaseConfig, instanceContext), persistService.getDatabaseMetaDataService().loadSchemas(databaseName));
+ DatabaseType protocolType = DatabaseTypeEngine.getProtocolType(databaseName, databaseConfig, props);
+ return ShardingSphereDatabase.create(databaseName, protocolType, databaseConfig, DatabaseRulesBuilder.build(databaseName, protocolType, databaseConfig, instanceContext),
+ persistService.getDatabaseMetaDataService().loadSchemas(databaseName));
}
/**
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoader.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoader.java
index bb5d3ac96c5..2265e0bf91c 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoader.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoader.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.single.datanode;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
+import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.database.core.metadata.data.loader.type.SchemaMetaDataLoader;
@@ -48,25 +49,25 @@ public final class SingleTableDataNodeLoader {
* Load single table data nodes.
*
* @param databaseName database name
- * @param databaseType database type
+ * @param protocolType protocol type
* @param dataSourceMap data source map
* @param builtRules built rules
* @param configuredTables configured tables
* @return single table data node map
*/
- public static Map<String, Collection<DataNode>> load(final String databaseName, final DatabaseType databaseType, final Map<String, DataSource> dataSourceMap,
+ public static Map<String, Collection<DataNode>> load(final String databaseName, final DatabaseType protocolType, final Map<String, DataSource> dataSourceMap,
final Collection<ShardingSphereRule> builtRules, final Collection<String> configuredTables) {
Collection<String> featureRequiredSingleTables = SingleTableLoadUtils.getFeatureRequiredSingleTables(builtRules);
if (configuredTables.isEmpty() && featureRequiredSingleTables.isEmpty()) {
return new LinkedHashMap<>();
}
Collection<String> excludedTables = SingleTableLoadUtils.getExcludedTables(builtRules);
- Map<String, Collection<DataNode>> actualDataNodes = load(databaseName, databaseType, dataSourceMap, excludedTables);
+ Map<String, Collection<DataNode>> actualDataNodes = load(databaseName, dataSourceMap, excludedTables);
Collection<String> splitTables = SingleTableLoadUtils.splitTableLines(configuredTables);
if (splitTables.contains(SingleTableConstants.ALL_TABLES) || splitTables.contains(SingleTableConstants.ALL_SCHEMA_TABLES)) {
return actualDataNodes;
}
- Map<String, Map<String, Collection<String>>> configuredTableMap = getConfiguredTableMap(databaseName, databaseType, splitTables);
+ Map<String, Map<String, Collection<String>>> configuredTableMap = getConfiguredTableMap(databaseName, protocolType, splitTables);
return loadSpecifiedDataNodes(actualDataNodes, featureRequiredSingleTables, configuredTableMap);
}
@@ -74,16 +75,14 @@ public final class SingleTableDataNodeLoader {
* Load single table data nodes.
*
* @param databaseName database name
- * @param databaseType database type
* @param dataSourceMap data source map
* @param excludedTables excluded tables
* @return single table data node map
*/
- public static Map<String, Collection<DataNode>> load(final String databaseName, final DatabaseType databaseType,
- final Map<String, DataSource> dataSourceMap, final Collection<String> excludedTables) {
+ public static Map<String, Collection<DataNode>> load(final String databaseName, final Map<String, DataSource> dataSourceMap, final Collection<String> excludedTables) {
Map<String, Collection<DataNode>> result = new ConcurrentHashMap<>();
for (Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
- Map<String, Collection<DataNode>> dataNodeMap = load(databaseName, databaseType, entry.getKey(), entry.getValue(), excludedTables);
+ Map<String, Collection<DataNode>> dataNodeMap = load(databaseName, DatabaseTypeEngine.getStorageType(entry.getValue()), entry.getKey(), entry.getValue(), excludedTables);
for (Entry<String, Collection<DataNode>> each : dataNodeMap.entrySet()) {
Collection<DataNode> addedDataNodes = each.getValue();
Collection<DataNode> existDataNodes = result.getOrDefault(each.getKey().toLowerCase(), new LinkedHashSet<>(addedDataNodes.size(), 1F));
@@ -94,9 +93,9 @@ public final class SingleTableDataNodeLoader {
return result;
}
- private static Map<String, Collection<DataNode>> load(final String databaseName, final DatabaseType databaseType, final String dataSourceName,
+ private static Map<String, Collection<DataNode>> load(final String databaseName, final DatabaseType storageType, final String dataSourceName,
final DataSource dataSource, final Collection<String> excludedTables) {
- Map<String, Collection<String>> schemaTableNames = loadSchemaTableNames(databaseName, databaseType, dataSource, dataSourceName);
+ Map<String, Collection<String>> schemaTableNames = loadSchemaTableNames(databaseName, storageType, dataSource, dataSourceName);
Map<String, Collection<DataNode>> result = new LinkedHashMap<>();
for (Entry<String, Collection<String>> entry : schemaTableNames.entrySet()) {
for (String each : entry.getValue()) {
@@ -155,12 +154,12 @@ public final class SingleTableDataNodeLoader {
return result;
}
- private static Map<String, Map<String, Collection<String>>> getConfiguredTableMap(final String databaseName, final DatabaseType databaseType, final Collection<String> configuredTables) {
+ private static Map<String, Map<String, Collection<String>>> getConfiguredTableMap(final String databaseName, final DatabaseType protocolType, final Collection<String> configuredTables) {
if (configuredTables.isEmpty()) {
return Collections.emptyMap();
}
Map<String, Map<String, Collection<String>>> result = new LinkedHashMap<>();
- Collection<DataNode> dataNodes = SingleTableLoadUtils.convertToDataNodes(databaseName, databaseType, configuredTables);
+ Collection<DataNode> dataNodes = SingleTableLoadUtils.convertToDataNodes(databaseName, protocolType, configuredTables);
for (DataNode each : dataNodes) {
Map<String, Collection<String>> schemaTables = result.getOrDefault(each.getDataSourceName(), new LinkedHashMap<>());
Collection<String> tables = schemaTables.getOrDefault(each.getSchemaName(), new LinkedList<>());
@@ -175,15 +174,15 @@ public final class SingleTableDataNodeLoader {
* Load schema table names.
*
* @param databaseName database name
- * @param databaseType database type
+ * @param storageType storage type
* @param dataSource data source
* @param dataSourceName data source name
* @return schema table names
* @throws SingleTablesLoadingException Single tables loading exception
*/
- public static Map<String, Collection<String>> loadSchemaTableNames(final String databaseName, final DatabaseType databaseType, final DataSource dataSource, final String dataSourceName) {
+ public static Map<String, Collection<String>> loadSchemaTableNames(final String databaseName, final DatabaseType storageType, final DataSource dataSource, final String dataSourceName) {
try {
- return SchemaMetaDataLoader.loadSchemaTableNames(databaseName, databaseType, dataSource);
+ return SchemaMetaDataLoader.loadSchemaTableNames(databaseName, storageType, dataSource);
} catch (final SQLException ex) {
throw new SingleTablesLoadingException(databaseName, dataSourceName, ex);
}
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/decorator/SingleRuleConfigurationDecorator.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/decorator/SingleRuleConfigurationDecorator.java
index 3f427d2d94b..f7a9fb05a99 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/decorator/SingleRuleConfigurationDecorator.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/decorator/SingleRuleConfigurationDecorator.java
@@ -22,9 +22,9 @@ import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.database.core.type.DatabaseTypeRegistry;
import org.apache.shardingsphere.infra.datanode.DataNode;
-import org.apache.shardingsphere.infra.state.datasource.DataSourceStateManager;
import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
+import org.apache.shardingsphere.infra.state.datasource.DataSourceStateManager;
import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
import org.apache.shardingsphere.single.api.constant.SingleTableConstants;
import org.apache.shardingsphere.single.datanode.SingleTableDataNodeLoader;
@@ -65,7 +65,7 @@ public final class SingleRuleConfigurationDecorator implements RuleConfiguration
Map<String, DataSource> aggregatedDataSources = SingleTableLoadUtils.getAggregatedDataSourceMap(enabledDataSources, builtRules);
DatabaseType databaseType = enabledDataSources.isEmpty() ? DatabaseTypeEngine.getDefaultStorageType() : DatabaseTypeEngine.getStorageType(enabledDataSources.values().iterator().next());
Collection<String> excludedTables = SingleTableLoadUtils.getExcludedTables(builtRules);
- Map<String, Collection<DataNode>> actualDataNodes = SingleTableDataNodeLoader.load(databaseName, databaseType, aggregatedDataSources, excludedTables);
+ Map<String, Collection<DataNode>> actualDataNodes = SingleTableDataNodeLoader.load(databaseName, aggregatedDataSources, excludedTables);
Collection<DataNode> configuredDataNodes = SingleTableLoadUtils.convertToDataNodes(databaseName, databaseType, splitTables);
checkRuleConfiguration(databaseName, aggregatedDataSources, excludedTables, configuredDataNodes);
boolean isSchemaSupportedDatabaseType = new DatabaseTypeRegistry(databaseType).getDialectDatabaseMetaData().getDefaultSchema().isPresent();
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/SingleRule.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/SingleRule.java
index 871e2ce9172..443884a30f5 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/SingleRule.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/SingleRule.java
@@ -21,11 +21,9 @@ import lombok.Getter;
import org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
import org.apache.shardingsphere.infra.binder.context.type.IndexAvailable;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.database.core.type.DatabaseTypeRegistry;
import org.apache.shardingsphere.infra.datanode.DataNode;
-import org.apache.shardingsphere.infra.state.datasource.DataSourceStateManager;
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.IndexMetaDataUtils;
@@ -37,6 +35,7 @@ import org.apache.shardingsphere.infra.rule.identifier.type.TableContainedRule;
import org.apache.shardingsphere.infra.rule.identifier.type.TableNamesMapper;
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.infra.state.datasource.DataSourceStateManager;
import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
import org.apache.shardingsphere.single.datanode.SingleTableDataNodeLoader;
import org.apache.shardingsphere.single.util.SingleTableLoadUtils;
@@ -71,16 +70,17 @@ public final class SingleRule implements DatabaseRule, DataNodeContainedRule, Ta
private final TableNamesMapper tableNamesMapper = new TableNamesMapper();
- private final DatabaseType databaseType;
+ private final DatabaseType protocolType;
- public SingleRule(final SingleRuleConfiguration ruleConfig, final String databaseName, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
+ public SingleRule(final SingleRuleConfiguration ruleConfig, final String databaseName, final DatabaseType protocolType, final Map<String, DataSource> dataSourceMap,
+ final Collection<ShardingSphereRule> builtRules) {
configuration = ruleConfig;
defaultDataSource = ruleConfig.getDefaultDataSource().orElse(null);
Map<String, DataSource> enabledDataSources = DataSourceStateManager.getInstance().getEnabledDataSources(databaseName, dataSourceMap);
Map<String, DataSource> aggregateDataSourceMap = SingleTableLoadUtils.getAggregatedDataSourceMap(enabledDataSources, builtRules);
dataSourceNames = aggregateDataSourceMap.keySet();
- databaseType = enabledDataSources.isEmpty() ? DatabaseTypeEngine.getDefaultStorageType() : DatabaseTypeEngine.getStorageType(enabledDataSources.values().iterator().next());
- singleTableDataNodes = SingleTableDataNodeLoader.load(databaseName, databaseType, aggregateDataSourceMap, builtRules, configuration.getTables());
+ this.protocolType = protocolType;
+ singleTableDataNodes = SingleTableDataNodeLoader.load(databaseName, protocolType, aggregateDataSourceMap, builtRules, configuration.getTables());
singleTableDataNodes.forEach((key, value) -> tableNamesMapper.put(value.iterator().next().getTableName()));
}
@@ -172,9 +172,9 @@ public final class SingleRule implements DatabaseRule, DataNodeContainedRule, Ta
* @return qualified tables
*/
public Collection<QualifiedTable> getQualifiedTables(final SQLStatementContext sqlStatementContext, final ShardingSphereDatabase database) {
- Collection<QualifiedTable> result = getQualifiedTables(database, databaseType, sqlStatementContext.getTablesContext().getSimpleTableSegments());
+ Collection<QualifiedTable> result = getQualifiedTables(database, protocolType, sqlStatementContext.getTablesContext().getSimpleTableSegments());
if (result.isEmpty() && sqlStatementContext instanceof IndexAvailable) {
- result = IndexMetaDataUtils.getTableNames(database, databaseType, ((IndexAvailable) sqlStatementContext).getIndexes());
+ result = IndexMetaDataUtils.getTableNames(database, protocolType, ((IndexAvailable) sqlStatementContext).getIndexes());
}
return result;
}
@@ -203,11 +203,11 @@ public final class SingleRule implements DatabaseRule, DataNodeContainedRule, Ta
private void addTableConfiguration(final String dataSourceName, final String schemaName, final String tableName) {
Collection<String> splitTables = SingleTableLoadUtils.splitTableLines(configuration.getTables());
- if (splitTables.contains(SingleTableLoadUtils.getAllTablesNodeStr(databaseType))
- || splitTables.contains(SingleTableLoadUtils.getAllTablesNodeStrFromDataSource(databaseType, dataSourceName, schemaName))) {
+ if (splitTables.contains(SingleTableLoadUtils.getAllTablesNodeStr(protocolType))
+ || splitTables.contains(SingleTableLoadUtils.getAllTablesNodeStrFromDataSource(protocolType, dataSourceName, schemaName))) {
return;
}
- String dataNodeString = SingleTableLoadUtils.getDataNodeString(databaseType, dataSourceName, schemaName, tableName);
+ String dataNodeString = SingleTableLoadUtils.getDataNodeString(protocolType, dataSourceName, schemaName, tableName);
if (!configuration.getTables().contains(dataNodeString)) {
configuration.getTables().add(dataNodeString);
}
@@ -229,7 +229,7 @@ public final class SingleRule implements DatabaseRule, DataNodeContainedRule, Ta
DataNode each = iterator.next();
if (schemaNames.contains(each.getSchemaName().toLowerCase())) {
iterator.remove();
- configuration.getTables().remove(SingleTableLoadUtils.getDataNodeString(databaseType, each.getDataSourceName(), each.getSchemaName(), tableName));
+ configuration.getTables().remove(SingleTableLoadUtils.getDataNodeString(protocolType, each.getDataSourceName(), each.getSchemaName(), tableName));
}
}
if (dataNodes.isEmpty()) {
@@ -252,7 +252,7 @@ public final class SingleRule implements DatabaseRule, DataNodeContainedRule, Ta
@Override
public ShardingSphereRule reloadRule(final RuleConfiguration config, final String databaseName, final Map<String, DataSource> dataSourceMap,
final Collection<ShardingSphereRule> builtRules) {
- return new SingleRule((SingleRuleConfiguration) config, databaseName, dataSourceMap, builtRules);
+ return new SingleRule((SingleRuleConfiguration) config, databaseName, protocolType, dataSourceMap, builtRules);
}
@Override
diff --git a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilder.java b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilder.java
index 5aae2785646..60905895217 100644
--- a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilder.java
+++ b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilder.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.single.rule.builder;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -34,9 +35,9 @@ import java.util.Map;
public final class SingleRuleBuilder implements DatabaseRuleBuilder<SingleRuleConfiguration> {
@Override
- public SingleRule build(final SingleRuleConfiguration config, final String databaseName,
+ public SingleRule build(final SingleRuleConfiguration config, final String databaseName, final DatabaseType protocolType,
final Map<String, DataSource> dataSources, final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
- return new SingleRule(config, databaseName, dataSources, builtRules);
+ return new SingleRule(config, databaseName, protocolType, dataSources, builtRules);
}
@Override
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoaderTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoaderTest.java
index b516d60238e..3cd144e60ab 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoaderTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/datanode/SingleTableDataNodeLoaderTest.java
@@ -78,6 +78,7 @@ class SingleTableDataNodeLoaderTest {
when(connection.getCatalog()).thenReturn(dataSourceName);
ResultSet resultSet = mockResultSet(tableNames);
when(connection.getMetaData().getTables(dataSourceName, null, null, new String[]{TABLE_TYPE, VIEW_TYPE, SYSTEM_TABLE_TYPE, SYSTEM_VIEW_TYPE})).thenReturn(resultSet);
+ when(connection.getMetaData().getURL()).thenReturn("jdbc:mock://127.0.0.1/foo_ds");
return new MockedDataSource(connection);
}
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/SingleSQLRouterTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/SingleSQLRouterTest.java
index 3f03c668365..233784700fb 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/SingleSQLRouterTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/SingleSQLRouterTest.java
@@ -21,6 +21,7 @@ import org.apache.shardingsphere.infra.binder.context.statement.ddl.CreateTableS
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
+import org.apache.shardingsphere.infra.database.h2.type.H2DatabaseType;
import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
@@ -71,7 +72,7 @@ class SingleSQLRouterTest {
@Test
void assertCreateRouteContextWithSingleDataSource() throws SQLException {
SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
- DefaultDatabase.LOGIC_NAME, Collections.singletonMap("foo_ds", new MockedDataSource(mockConnection())), Collections.emptyList());
+ DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), 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 SingleSQLRouter().createRouteContext(createQueryContext(),
@@ -92,7 +93,7 @@ class SingleSQLRouterTest {
@Test
void assertCreateRouteContextWithReadwriteSplittingDataSource() throws SQLException {
SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
- DefaultDatabase.LOGIC_NAME, Collections.singletonMap("readwrite_ds", new MockedDataSource(mockConnection())), Collections.emptyList());
+ DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), 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 SingleSQLRouter().createRouteContext(createQueryContext(),
@@ -113,7 +114,7 @@ class SingleSQLRouterTest {
@Test
void assertCreateRouteContextWithMultiDataSource() throws SQLException {
- SingleRule rule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createMultiDataSourceMap(), Collections.emptyList());
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), createMultiDataSourceMap(), Collections.emptyList());
ShardingSphereDatabase database = mockDatabaseWithMultipleResources();
RouteContext actual = new SingleSQLRouter().createRouteContext(createQueryContext(),
mock(RuleMetaData.class), database, rule, new ConfigurationProperties(new Properties()), new ConnectionContext());
@@ -166,7 +167,7 @@ class SingleSQLRouterTest {
@Test
void assertDecorateRouteContextWithSingleDataSource() {
SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
- DefaultDatabase.LOGIC_NAME, Collections.singletonMap("foo_ds", new MockedDataSource()), Collections.emptyList());
+ DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), 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"))));
SingleSQLRouter sqlRouter = (SingleSQLRouter) OrderedSPILoader.getServices(SQLRouter.class, Collections.singleton(rule)).get(rule);
@@ -178,7 +179,7 @@ class SingleSQLRouterTest {
@Test
void assertDecorateRouteContextWithReadwriteSplittingDataSource() {
SingleRule rule = new SingleRule(new SingleRuleConfiguration(),
- DefaultDatabase.LOGIC_NAME, Collections.singletonMap("readwrite_ds", new MockedDataSource()), Collections.emptyList());
+ DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), 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")));
@@ -195,7 +196,7 @@ class SingleSQLRouterTest {
@Test
void assertDecorateRouteContextWithMultiDataSource() throws SQLException {
- SingleRule rule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createMultiDataSourceMap(), Collections.emptyList());
+ SingleRule rule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), 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()));
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngineTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngineTest.java
index 527b8071382..3c61e29e63a 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngineTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleDatabaseBroadcastRouteEngineTest.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.single.route.engine;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
+import org.apache.shardingsphere.infra.database.h2.type.H2DatabaseType;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
@@ -45,7 +46,7 @@ class SingleDatabaseBroadcastRouteEngineTest {
@Test
void assertRoute() throws SQLException {
- SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), createDataSourceMap(), Collections.emptyList());
RouteContext routeContext = new RouteContext();
SingleDatabaseBroadcastRouteEngine engine = new SingleDatabaseBroadcastRouteEngine();
engine.route(routeContext, singleRule);
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngineTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngineTest.java
index 55c072e28cb..a6507575165 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngineTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/route/engine/SingleStandardRouteEngineTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.single.route.engine;
+import org.apache.shardingsphere.infra.database.mysql.type.MySQLDatabaseType;
import org.apache.shardingsphere.infra.exception.dialect.exception.syntax.table.TableExistsException;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
import org.apache.shardingsphere.infra.datanode.DataNode;
@@ -60,7 +61,7 @@ class SingleStandardRouteEngineTest {
@Test
void assertRouteInSameDataSource() throws SQLException {
SingleStandardRouteEngine engine = new SingleStandardRouteEngine(mockQualifiedTables(), null);
- SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, new MySQLDatabaseType(), createDataSourceMap(), Collections.emptyList());
singleRule.getSingleTableDataNodes().put("t_order", Collections.singleton(mockDataNode("t_order")));
singleRule.getSingleTableDataNodes().put("t_order_item", Collections.singleton(mockDataNode("t_order_item")));
RouteContext routeContext = new RouteContext();
@@ -91,7 +92,7 @@ class SingleStandardRouteEngineTest {
@Test
void assertRouteWithoutSingleRule() throws SQLException {
SingleStandardRouteEngine engine = new SingleStandardRouteEngine(mockQualifiedTables(), new MySQLCreateTableStatement(false));
- SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(), DefaultDatabase.LOGIC_NAME, new MySQLDatabaseType(), createDataSourceMap(), Collections.emptyList());
RouteContext routeContext = new RouteContext();
engine.route(routeContext, singleRule);
List<RouteUnit> routeUnits = new ArrayList<>(routeContext.getRouteUnits());
@@ -106,7 +107,8 @@ class SingleStandardRouteEngineTest {
@Test
void assertRouteWithDefaultSingleRule() throws SQLException {
SingleStandardRouteEngine engine = new SingleStandardRouteEngine(mockQualifiedTables(), new MySQLCreateTableStatement(false));
- SingleRule singleRule = new SingleRule(new SingleRuleConfiguration(Collections.emptyList(), "ds_0"), DefaultDatabase.LOGIC_NAME, createDataSourceMap(), Collections.emptyList());
+ SingleRule singleRule =
+ new SingleRule(new SingleRuleConfiguration(Collections.emptyList(), "ds_0"), DefaultDatabase.LOGIC_NAME, new MySQLDatabaseType(), createDataSourceMap(), Collections.emptyList());
RouteContext routeContext = new RouteContext();
engine.route(routeContext, singleRule);
List<RouteUnit> routeUnits = new ArrayList<>(routeContext.getRouteUnits());
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
index 7bb44fbce66..1b107b9067b 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/SingleRuleTest.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.single.rule;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
+import org.apache.shardingsphere.infra.database.h2.type.H2DatabaseType;
import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
import org.apache.shardingsphere.infra.route.context.RouteContext;
@@ -102,7 +103,7 @@ class SingleRuleTest {
TableContainedRule tableContainedRule = mock(TableContainedRule.class, RETURNS_DEEP_STUBS);
when(tableContainedRule.getDistributedTableMapper().getTableNames()).thenReturn(Collections.singletonList("t_order"));
when(tableContainedRule.getActualTableMapper().getTableNames()).thenReturn(Arrays.asList("t_order_0", "t_order_1"));
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(tableContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(tableContainedRule));
Map<String, Collection<DataNode>> actual = singleRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
@@ -114,7 +115,7 @@ class SingleRuleTest {
TableContainedRule tableContainedRule = mock(TableContainedRule.class, RETURNS_DEEP_STUBS);
when(tableContainedRule.getDistributedTableMapper().getTableNames()).thenReturn(Collections.singletonList("T_ORDER"));
when(tableContainedRule.getActualTableMapper().getTableNames()).thenReturn(Arrays.asList("T_ORDER_0", "T_ORDER_1"));
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(tableContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(tableContainedRule));
Map<String, Collection<DataNode>> actual = singleRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
@@ -124,7 +125,7 @@ class SingleRuleTest {
@Test
void assertFindSingleTableDataNode() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
Optional<DataNode> actual = singleRule.findTableDataNode(DefaultDatabase.LOGIC_NAME, "employee");
assertTrue(actual.isPresent());
assertThat(actual.get().getDataSourceName(), is("foo_ds"));
@@ -134,7 +135,7 @@ class SingleRuleTest {
@Test
void assertFindSingleTableDataNodeWithUpperCase() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
Optional<DataNode> actual = singleRule.findTableDataNode(DefaultDatabase.LOGIC_NAME, "EMPLOYEE");
assertTrue(actual.isPresent());
assertThat(actual.get().getDataSourceName(), is("foo_ds"));
@@ -151,7 +152,7 @@ class SingleRuleTest {
RouteContext routeContext = new RouteContext();
routeContext.putRouteUnit(dataSourceMapper, tableMappers);
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertTrue(singleRule.isAllTablesInSameComputeNode(routeContext.getOriginalDataNodes().stream().flatMap(Collection::stream).collect(Collectors.toList()), singleTables));
}
@@ -160,14 +161,14 @@ class SingleRuleTest {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
SingleRuleConfiguration singleRuleConfig = new SingleRuleConfiguration();
singleRuleConfig.setDefaultDataSource("foo_ds");
- SingleRule singleRule = new SingleRule(singleRuleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(singleRuleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertThat(singleRule.assignNewDataSourceName(), is("foo_ds"));
}
@Test
void assertGetSingleTables() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
Collection<QualifiedTable> tableNames = new LinkedList<>();
tableNames.add(new QualifiedTable(DefaultDatabase.LOGIC_NAME, "employee"));
assertThat(singleRule.getSingleTables(tableNames).iterator().next().getSchemaName(), is(DefaultDatabase.LOGIC_NAME));
@@ -177,7 +178,7 @@ class SingleRuleTest {
@Test
void assertPut() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
String tableName = "teacher";
String dataSourceName = "foo_ds";
singleRule.put(dataSourceName, DefaultDatabase.LOGIC_NAME, tableName);
@@ -195,7 +196,7 @@ class SingleRuleTest {
@Test
void assertRemove() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
String tableName = "employee";
singleRule.remove(DefaultDatabase.LOGIC_NAME, tableName);
Collection<QualifiedTable> tableNames = new LinkedList<>();
@@ -209,7 +210,7 @@ class SingleRuleTest {
@Test
void assertGetAllDataNodes() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertTrue(singleRule.getAllDataNodes().containsKey("employee"));
assertTrue(singleRule.getAllDataNodes().containsKey("student"));
assertTrue(singleRule.getAllDataNodes().containsKey("t_order_0"));
@@ -219,7 +220,7 @@ class SingleRuleTest {
@Test
void assertGetDataNodesByTableName() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
Collection<DataNode> actual = singleRule.getDataNodesByTableName("EMPLOYEE");
assertThat(actual.size(), is(1));
DataNode dataNode = actual.iterator().next();
@@ -230,7 +231,7 @@ class SingleRuleTest {
@Test
void assertFindFirstActualTable() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
String logicTable = "employee";
assertFalse(singleRule.findFirstActualTable(logicTable).isPresent());
}
@@ -238,14 +239,14 @@ class SingleRuleTest {
@Test
void assertIsNeedAccumulate() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
assertFalse(singleRule.isNeedAccumulate(Collections.emptyList()));
}
@Test
void assertFindLogicTableByActualTable() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
String actualTable = "student";
assertFalse(singleRule.findLogicTableByActualTable(actualTable).isPresent());
}
@@ -253,7 +254,7 @@ class SingleRuleTest {
@Test
void assertFindActualTableByCatalog() {
DataNodeContainedRule dataNodeContainedRule = mock(DataNodeContainedRule.class);
- SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, dataSourceMap, Collections.singleton(dataNodeContainedRule));
+ SingleRule singleRule = new SingleRule(ruleConfig, DefaultDatabase.LOGIC_NAME, new H2DatabaseType(), dataSourceMap, Collections.singleton(dataNodeContainedRule));
String catalog = "employee";
String logicTable = "t_order_0";
assertFalse(singleRule.findActualTableByCatalog(catalog, logicTable).isPresent());
diff --git a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilderTest.java b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilderTest.java
index e0714c9ca6d..40b3d9765af 100644
--- a/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilderTest.java
+++ b/kernel/single/core/src/test/java/org/apache/shardingsphere/single/rule/builder/SingleRuleBuilderTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.single.rule.builder;
+import org.apache.shardingsphere.infra.database.mysql.type.MySQLDatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -38,7 +39,8 @@ class SingleRuleBuilderTest {
@Test
void assertBuild() {
DatabaseRuleBuilder builder = OrderedSPILoader.getServices(DatabaseRuleBuilder.class).iterator().next();
- DatabaseRule actual = builder.build(mock(SingleRuleConfiguration.class), "", Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)), mock(InstanceContext.class));
+ DatabaseRule actual = builder.build(mock(SingleRuleConfiguration.class), "", new MySQLDatabaseType(), Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)),
+ mock(InstanceContext.class));
assertThat(actual, instanceOf(SingleRule.class));
}
@@ -47,7 +49,8 @@ class SingleRuleBuilderTest {
void assertBuildWithDefaultDataSource() {
DatabaseRuleBuilder builder = OrderedSPILoader.getServices(DatabaseRuleBuilder.class).iterator().next();
DatabaseRule actual = builder.build(
- new SingleRuleConfiguration(Collections.emptyList(), "foo_ds"), "", Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)), mock(InstanceContext.class));
+ new SingleRuleConfiguration(Collections.emptyList(), "foo_ds"), "", new MySQLDatabaseType(), Collections.emptyMap(), Collections.singleton(mock(ShardingSphereRule.class)),
+ mock(InstanceContext.class));
assertThat(actual, instanceOf(SingleRule.class));
}
}
diff --git a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/query/ShowUnloadedSingleTableExecutor.java b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/query/ShowUnloadedSingleTableExecutor.java
index 8f23279e962..08d51d6bc90 100644
--- a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/query/ShowUnloadedSingleTableExecutor.java
+++ b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/query/ShowUnloadedSingleTableExecutor.java
@@ -68,7 +68,7 @@ public final class ShowUnloadedSingleTableExecutor implements RQLExecutor<ShowUn
.collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new)),
database.getRuleMetaData().getRules());
Collection<String> excludedTables = SingleTableLoadUtils.getExcludedTables(database.getRuleMetaData().getRules());
- return SingleTableDataNodeLoader.load(database.getName(), database.getProtocolType(), aggregateDataSourceMap, excludedTables);
+ return SingleTableDataNodeLoader.load(database.getName(), aggregateDataSourceMap, excludedTables);
}
@Override
diff --git a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableStatementUpdater.java b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableStatementUpdater.java
index 617082f91d8..3048f0a73a6 100644
--- a/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableStatementUpdater.java
+++ b/kernel/single/distsql/handler/src/main/java/org/apache/shardingsphere/single/distsql/handler/update/LoadSingleTableStatementUpdater.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.single.distsql.handler.update;
import org.apache.shardingsphere.distsql.handler.exception.storageunit.MissingRequiredStorageUnitsException;
import org.apache.shardingsphere.distsql.handler.update.RuleDefinitionCreateUpdater;
+import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import org.apache.shardingsphere.infra.database.core.metadata.database.DialectDatabaseMetaData;
import org.apache.shardingsphere.infra.database.core.type.DatabaseTypeRegistry;
import org.apache.shardingsphere.infra.exception.InvalidDataNodesFormatException;
@@ -119,7 +120,8 @@ public final class LoadSingleTableStatementUpdater implements RuleDefinitionCrea
database.getRuleMetaData().getRules());
Map<String, Map<String, Collection<String>>> actualTableNodes = new LinkedHashMap<>();
for (String each : requiredDataSources) {
- Map<String, Collection<String>> schemaTableNames = SingleTableDataNodeLoader.loadSchemaTableNames(database.getName(), database.getProtocolType(), aggregateDataSourceMap.get(each), each);
+ DataSource dataSource = aggregateDataSourceMap.get(each);
+ Map<String, Collection<String>> schemaTableNames = SingleTableDataNodeLoader.loadSchemaTableNames(database.getName(), DatabaseTypeEngine.getStorageType(dataSource), dataSource, each);
if (!schemaTableNames.isEmpty()) {
actualTableNodes.put(each, schemaTableNames);
}
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java
index 40d9ba91e09..d6db3fc9536 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java
@@ -172,7 +172,7 @@ public final class ConfigurationContextManager {
ShardingSphereDatabase database = metaDataContexts.get().getMetaData().getDatabase(databaseName);
Collection<ShardingSphereRule> rules = new LinkedList<>(database.getRuleMetaData().getRules());
rules.removeIf(each -> each.getConfiguration().getClass().isAssignableFrom(ruleConfig.getClass()));
- rules.addAll(DatabaseRulesBuilder.build(databaseName,
+ rules.addAll(DatabaseRulesBuilder.build(databaseName, database.getProtocolType(),
database.getResourceMetaData().getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new)),
database.getRuleMetaData().getRules(), ruleConfig, instanceContext));
@@ -194,7 +194,7 @@ public final class ConfigurationContextManager {
Collection<ShardingSphereRule> rules = new LinkedList<>(database.getRuleMetaData().getRules());
rules.removeIf(each -> each.getConfiguration().getClass().isAssignableFrom(ruleConfig.getClass()));
if (isNotEmptyConfig(ruleConfig)) {
- rules.addAll(DatabaseRulesBuilder.build(databaseName,
+ rules.addAll(DatabaseRulesBuilder.build(databaseName, database.getProtocolType(),
database.getResourceMetaData().getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new)),
database.getRuleMetaData().getRules(), ruleConfig, instanceContext));
diff --git a/mode/core/src/test/java/org/apache/shardingsphere/mode/fixture/ModeRuleBuilderFixture.java b/mode/core/src/test/java/org/apache/shardingsphere/mode/fixture/ModeRuleBuilderFixture.java
index f6c671eff9f..4509f8ff110 100644
--- a/mode/core/src/test/java/org/apache/shardingsphere/mode/fixture/ModeRuleBuilderFixture.java
+++ b/mode/core/src/test/java/org/apache/shardingsphere/mode/fixture/ModeRuleBuilderFixture.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.mode.fixture;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
@@ -28,7 +29,7 @@ import java.util.Map;
public final class ModeRuleBuilderFixture implements DatabaseRuleBuilder<ModeRuleConfigurationFixture> {
@Override
- public ModeRuleFixture build(final ModeRuleConfigurationFixture config, final String databaseName, final Map<String, DataSource> dataSources,
+ public ModeRuleFixture build(final ModeRuleConfigurationFixture config, final String databaseName, final DatabaseType databaseType, final Map<String, DataSource> dataSources,
final Collection<ShardingSphereRule> builtRules, final InstanceContext instanceContext) {
return new ModeRuleFixture();
}
diff --git a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
index cdc0fa74557..2adc0108c3c 100644
--- a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
+++ b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
@@ -292,7 +292,7 @@ public final class YamlDatabaseConfigurationImportExecutor {
private void addSingleRuleConfiguration(final SingleRuleConfiguration singleRuleConfig, final Collection<RuleConfiguration> allRuleConfigs, final ShardingSphereDatabase database) {
allRuleConfigs.add(singleRuleConfig);
database.getRuleMetaData().getRules().add(
- new SingleRule(singleRuleConfig, database.getName(),
+ new SingleRule(singleRuleConfig, database.getName(), database.getProtocolType(),
database.getResourceMetaData().getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSource(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new)),
database.getRuleMetaData().getRules()));
diff --git a/proxy/bootstrap/src/main/java/org/apache/shardingsphere/proxy/Bootstrap.java b/proxy/bootstrap/src/main/java/org/apache/shardingsphere/proxy/Bootstrap.java
index 0604d7675a0..620a6b5a042 100644
--- a/proxy/bootstrap/src/main/java/org/apache/shardingsphere/proxy/Bootstrap.java
+++ b/proxy/bootstrap/src/main/java/org/apache/shardingsphere/proxy/Bootstrap.java
@@ -56,8 +56,8 @@ public final class Bootstrap {
Optional.ofNullable((Integer) yamlConfig.getServerConfiguration().getProps().get(ConfigurationPropertyKey.CDC_SERVER_PORT.getKey()))
.ifPresent(optional -> new CDCServer(addresses, optional).start());
ProxySSLContext.init();
- ShardingSphereProxy shardingSphereProxy = new ShardingSphereProxy();
- bootstrapArgs.getSocketPath().ifPresent(shardingSphereProxy::start);
- shardingSphereProxy.start(port, addresses);
+ ShardingSphereProxy proxy = new ShardingSphereProxy();
+ bootstrapArgs.getSocketPath().ifPresent(proxy::start);
+ proxy.start(port, addresses);
}
}
diff --git a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterIT.java b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterIT.java
index aa641eadc83..f21492e1e76 100644
--- a/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterIT.java
+++ b/test/it/rewriter/src/test/java/org/apache/shardingsphere/test/it/rewrite/engine/SQLRewriterIT.java
@@ -128,7 +128,7 @@ public abstract class SQLRewriterIT {
SQLStatementParserEngine sqlStatementParserEngine = new SQLStatementParserEngine(TypedSPILoader.getService(DatabaseType.class, testParams.getDatabaseType()),
sqlParserRule.getSqlStatementCache(), sqlParserRule.getParseTreeCache(), sqlParserRule.isSqlCommentParseEnabled());
SQLStatement sqlStatement = sqlStatementParserEngine.parse(testParams.getInputSQL(), false);
- Collection<ShardingSphereRule> databaseRules = createDatabaseRules(databaseConfig, schemaName, sqlStatement);
+ Collection<ShardingSphereRule> databaseRules = createDatabaseRules(databaseConfig, schemaName, sqlStatement, databaseType);
RuleMetaData databaseRuleMetaData = new RuleMetaData(databaseRules);
ShardingSphereDatabase database = new ShardingSphereDatabase(schemaName, databaseType, resourceMetaData, databaseRuleMetaData, mockSchemas(schemaName));
Map<String, ShardingSphereDatabase> databases = new HashMap<>(2, 1F);
@@ -155,8 +155,8 @@ public abstract class SQLRewriterIT {
: (((RouteSQLRewriteResult) sqlRewriteResult).getSqlRewriteUnits()).values();
}
- private Collection<ShardingSphereRule> createDatabaseRules(final DatabaseConfiguration databaseConfig, final String schemaName, final SQLStatement sqlStatement) {
- Collection<ShardingSphereRule> result = DatabaseRulesBuilder.build(DefaultDatabase.LOGIC_NAME, databaseConfig, mock(InstanceContext.class));
+ private Collection<ShardingSphereRule> createDatabaseRules(final DatabaseConfiguration databaseConfig, final String schemaName, final SQLStatement sqlStatement, final DatabaseType databaseType) {
+ Collection<ShardingSphereRule> result = DatabaseRulesBuilder.build(DefaultDatabase.LOGIC_NAME, databaseType, databaseConfig, mock(InstanceContext.class));
mockRules(result, schemaName, sqlStatement);
result.add(sqlParserRule);
result.add(timestampServiceRule);