This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 3454e0a improve load single table performance (#14031)
3454e0a is described below
commit 3454e0af088f742092b0a7b0ffe2452f1fe55aca
Author: tuichenchuxin <[email protected]>
AuthorDate: Mon Dec 13 10:13:17 2021 +0800
improve load single table performance (#14031)
* improve load single table performance
* Revert "improve load single table performance"
This reverts commit 62dc927b
* improve load single table performance
* Revert "improve load single table performance"
This reverts commit 8d225001
* Revert "Revert "improve load single table performance""
This reverts commit a5bf33cb
* improve load single table performance
* improve load single table performance
---
.../singletable/route/SingleTableRouteEngine.java | 9 +++---
.../singletable/rule/SingleTableDataNode.java | 35 ----------------------
.../rule/SingleTableDataNodeLoader.java | 18 ++++++-----
.../singletable/rule/SingleTableRule.java | 28 ++++++++++-------
.../route/SingleTableRouteEngineTest.java | 10 +++----
.../rule/SingleTableDataNodeLoaderTest.java | 31 +++++++++----------
.../singletable/rule/SingleTableRuleTest.java | 5 ++--
.../rql/rule/SingleTableQueryResultSet.java | 12 ++++----
.../distsql/rql/SingleTableQueryResultSetTest.java | 17 ++++++-----
9 files changed, 71 insertions(+), 94 deletions(-)
diff --git
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngine.java
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngine.java
index a377e40..098a5ce 100644
---
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngine.java
+++
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngine.java
@@ -18,11 +18,11 @@
package org.apache.shardingsphere.singletable.route;
import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.exception.ShardingSphereException;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
-import org.apache.shardingsphere.singletable.rule.SingleTableDataNode;
import org.apache.shardingsphere.singletable.rule.SingleTableRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
import
org.apache.shardingsphere.sql.parser.sql.common.statement.ddl.AlterTableStatement;
@@ -121,12 +121,13 @@ public final class SingleTableRouteEngine {
}
private void fillRouteContext(final SingleTableRule singleTableRule, final
RouteContext routeContext, final Collection<String> logicTables) {
- Map<String, SingleTableDataNode> singleTableDataNodes =
singleTableRule.getSingleTableDataNodes();
+ Map<String, Collection<DataNode>> singleTableDataNodes =
singleTableRule.getSingleTableDataNodes();
for (String each : logicTables) {
- if (!singleTableDataNodes.containsKey(each)) {
+ Collection<DataNode> dataNodes = singleTableDataNodes.get(each);
+ if (null == dataNodes || dataNodes.isEmpty()) {
throw new ShardingSphereException("`%s` single table does not
exist.", each);
}
- String dataSource =
singleTableDataNodes.get(each).getDataSourceName();
+ String dataSource =
dataNodes.iterator().next().getDataSourceName();
routeContext.putRouteUnit(new RouteMapper(dataSource, dataSource),
Collections.singletonList(new RouteMapper(each, each)));
}
}
diff --git
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNode.java
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNode.java
deleted file mode 100644
index 35b75db..0000000
---
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNode.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.singletable.rule;
-
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-
-/**
- * Single table data node.
- */
-@RequiredArgsConstructor
-@Getter
-@EqualsAndHashCode
-public final class SingleTableDataNode {
-
- private final String tableName;
-
- private final String dataSourceName;
-}
diff --git
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoader.java
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoader.java
index 28ae298..42ce68d 100644
---
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoader.java
+++
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoader.java
@@ -24,11 +24,13 @@ import
org.apache.shardingsphere.infra.config.exception.ShardingSphereConfigurat
import
org.apache.shardingsphere.infra.config.properties.ConfigurationProperties;
import
org.apache.shardingsphere.infra.config.properties.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import
org.apache.shardingsphere.infra.metadata.schema.builder.loader.SchemaMetaDataLoader;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Collection;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
@@ -49,14 +51,14 @@ public final class SingleTableDataNodeLoader {
* @param props configuration properties
* @return single table data node map
*/
- public static Map<String, SingleTableDataNode> load(final DatabaseType
databaseType, final Map<String, DataSource> dataSourceMap,
- final
Collection<String> excludedTables, final ConfigurationProperties props) {
- Map<String, SingleTableDataNode> result = new ConcurrentHashMap<>();
+ public static Map<String, Collection<DataNode>> load(final DatabaseType
databaseType, final Map<String, DataSource> dataSourceMap,
+ final
Collection<String> excludedTables, final ConfigurationProperties props) {
+ Map<String, Collection<DataNode>> result = new ConcurrentHashMap<>();
boolean checkDuplicateTable =
props.getValue(ConfigurationPropertyKey.CHECK_DUPLICATE_TABLE_ENABLED);
for (Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
- Map<String, SingleTableDataNode> dataNodeMap = load(databaseType,
entry.getKey(), entry.getValue(), excludedTables);
+ Map<String, DataNode> dataNodeMap = load(databaseType,
entry.getKey(), entry.getValue(), excludedTables);
for (String each : dataNodeMap.keySet()) {
- SingleTableDataNode existDataNode =
result.putIfAbsent(each.toLowerCase(), dataNodeMap.get(each));
+ Collection<DataNode> existDataNode =
result.putIfAbsent(each.toLowerCase(),
Collections.singletonList(dataNodeMap.get(each)));
if (checkDuplicateTable) {
Preconditions.checkState(null == existDataNode, "Single
table conflict, there are multiple tables `%s` existed.", each);
}
@@ -65,12 +67,12 @@ public final class SingleTableDataNodeLoader {
return result;
}
- private static Map<String, SingleTableDataNode> load(final DatabaseType
databaseType, final String dataSourceName, final DataSource dataSource, final
Collection<String> excludedTables) {
+ private static Map<String, DataNode> load(final DatabaseType databaseType,
final String dataSourceName, final DataSource dataSource, final
Collection<String> excludedTables) {
Collection<String> tables = loadAllTableNames(databaseType,
dataSource);
- Map<String, SingleTableDataNode> result = new HashMap<>(tables.size(),
1);
+ Map<String, DataNode> result = new HashMap<>(tables.size(), 1);
for (String each : tables) {
if (!excludedTables.contains(each)) {
- result.put(each, new SingleTableDataNode(each,
dataSourceName));
+ result.put(each, new DataNode(dataSourceName, each));
}
}
return result;
diff --git
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableRule.java
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableRule.java
index 81e3032..6922c84 100644
---
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableRule.java
+++
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/main/java/org/apache/shardingsphere/singletable/rule/SingleTableRule.java
@@ -54,13 +54,16 @@ public final class SingleTableRule implements SchemaRule,
DataNodeContainedRule,
private final Collection<String> dataSourceNames;
- private final Map<String, SingleTableDataNode> singleTableDataNodes;
+ private final Map<String, Collection<DataNode>> singleTableDataNodes;
+
+ private final Map<String, String> tableNames;
public SingleTableRule(final SingleTableRuleConfiguration config, final
DatabaseType databaseType,
final Map<String, DataSource> dataSourceMap, final
Collection<ShardingSphereRule> builtRules, final ConfigurationProperties props)
{
Map<String, DataSource> aggregateDataSourceMap =
getAggregateDataSourceMap(dataSourceMap, builtRules);
dataSourceNames = aggregateDataSourceMap.keySet();
singleTableDataNodes = SingleTableDataNodeLoader.load(databaseType,
aggregateDataSourceMap, getExcludedTables(builtRules), props);
+ tableNames =
singleTableDataNodes.entrySet().stream().collect(Collectors.toConcurrentMap(Entry::getKey,
entry -> entry.getValue().iterator().next().getTableName()));
config.getDefaultDataSource().ifPresent(op -> defaultDataSource = op);
}
@@ -95,7 +98,7 @@ public final class SingleTableRule implements SchemaRule,
DataNodeContainedRule,
*/
public boolean isSingleTablesInSameDataSource(final Collection<String>
singleTableNames) {
Set<String> dataSourceNames = singleTableNames.stream().map(each ->
singleTableDataNodes.get(each.toLowerCase()))
-
.filter(Objects::nonNull).map(SingleTableDataNode::getDataSourceName).collect(Collectors.toSet());
+ .filter(Objects::nonNull).flatMap(each ->
each.stream().map(DataNode::getDataSourceName)).collect(Collectors.toSet());
return dataSourceNames.size() <= 1;
}
@@ -110,10 +113,12 @@ public final class SingleTableRule implements SchemaRule,
DataNodeContainedRule,
if (!isSingleTablesInSameDataSource(singleTableNames)) {
return false;
}
- SingleTableDataNode dataNode =
singleTableDataNodes.get(singleTableNames.iterator().next().toLowerCase());
- for (RouteUnit each : routeContext.getRouteUnits()) {
- if
(!each.getDataSourceMapper().getLogicName().equals(dataNode.getDataSourceName()))
{
- return false;
+ Collection<DataNode> dataNodes =
singleTableDataNodes.get(singleTableNames.iterator().next().toLowerCase());
+ if (null != dataNodes && !dataNodes.isEmpty()) {
+ for (RouteUnit each : routeContext.getRouteUnits()) {
+ if
(!each.getDataSourceMapper().getLogicName().equals(dataNodes.iterator().next().getDataSourceName()))
{
+ return false;
+ }
}
}
return true;
@@ -147,13 +152,15 @@ public final class SingleTableRule implements SchemaRule,
DataNodeContainedRule,
@Override
public void put(final String tableName, final String dataSourceName) {
if (dataSourceNames.contains(dataSourceName)) {
- singleTableDataNodes.put(tableName.toLowerCase(), new
SingleTableDataNode(tableName, dataSourceName));
+ singleTableDataNodes.put(tableName.toLowerCase(),
Collections.singletonList(new DataNode(dataSourceName, tableName)));
+ tableNames.put(tableName.toLowerCase(), tableName);
}
}
@Override
public void remove(final String tableName) {
singleTableDataNodes.remove(tableName.toLowerCase());
+ tableNames.remove(tableName.toLowerCase());
}
private Collection<String> getExcludedTables(final
Collection<ShardingSphereRule> rules) {
@@ -163,8 +170,7 @@ public final class SingleTableRule implements SchemaRule,
DataNodeContainedRule,
@Override
public Map<String, Collection<DataNode>> getAllDataNodes() {
- return singleTableDataNodes.values().stream().map(each -> new
DataNode(each.getDataSourceName(), each.getTableName()))
- .collect(Collectors.groupingBy(DataNode::getTableName,
LinkedHashMap::new, Collectors.toCollection(LinkedList::new)));
+ return singleTableDataNodes;
}
@Override
@@ -194,12 +200,12 @@ public final class SingleTableRule implements SchemaRule,
DataNodeContainedRule,
@Override
public Collection<String> getAllTables() {
- return
singleTableDataNodes.values().stream().map(SingleTableDataNode::getTableName).collect(Collectors.toList());
+ return tableNames.values();
}
@Override
public Collection<String> getTables() {
- return
singleTableDataNodes.values().stream().map(SingleTableDataNode::getTableName).collect(Collectors.toList());
+ return tableNames.values();
}
@Override
diff --git
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngineTest.java
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngineTest.java
index 74103c6..2da47e8 100644
---
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngineTest.java
+++
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/route/SingleTableRouteEngineTest.java
@@ -19,11 +19,11 @@ package org.apache.shardingsphere.singletable.route;
import
org.apache.shardingsphere.infra.config.properties.ConfigurationProperties;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.route.context.RouteContext;
import org.apache.shardingsphere.infra.route.context.RouteMapper;
import org.apache.shardingsphere.infra.route.context.RouteUnit;
import
org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
-import org.apache.shardingsphere.singletable.rule.SingleTableDataNode;
import org.apache.shardingsphere.singletable.rule.SingleTableRule;
import
org.apache.shardingsphere.sql.parser.sql.dialect.statement.mysql.ddl.MySQLCreateTableStatement;
import org.junit.Test;
@@ -52,8 +52,8 @@ public final class SingleTableRouteEngineTest {
SingleTableRouteEngine singleTableRouteEngine = new
SingleTableRouteEngine(Arrays.asList("t_order", "t_order_item"), null);
SingleTableRule singleTableRule = new SingleTableRule(new
SingleTableRuleConfiguration(), mock(DatabaseType.class),
createDataSourceMap(), Collections.emptyList(), new
ConfigurationProperties(new Properties()));
- singleTableRule.getSingleTableDataNodes().put("t_order", new
SingleTableDataNode("t_order", "ds_0"));
- singleTableRule.getSingleTableDataNodes().put("t_order_item", new
SingleTableDataNode("t_order_item", "ds_0"));
+ singleTableRule.getSingleTableDataNodes().put("t_order",
Collections.singletonList(new DataNode("ds_0", "t_order")));
+ singleTableRule.getSingleTableDataNodes().put("t_order_item",
Collections.singletonList(new DataNode("ds_0", "t_order_item")));
RouteContext routeContext = new RouteContext();
singleTableRouteEngine.route(routeContext, singleTableRule);
List<RouteUnit> routeUnits = new
ArrayList<>(routeContext.getRouteUnits());
@@ -75,8 +75,8 @@ public final class SingleTableRouteEngineTest {
SingleTableRouteEngine singleTableRouteEngine = new
SingleTableRouteEngine(Arrays.asList("t_order", "t_order_item"), null);
SingleTableRule singleTableRule = new SingleTableRule(new
SingleTableRuleConfiguration(), mock(DatabaseType.class),
createDataSourceMap(), Collections.emptyList(), new
ConfigurationProperties(new Properties()));
- singleTableRule.getSingleTableDataNodes().put("t_order", new
SingleTableDataNode("t_order", "ds_0"));
- singleTableRule.getSingleTableDataNodes().put("t_order_item", new
SingleTableDataNode("t_order_item", "ds_1"));
+ singleTableRule.getSingleTableDataNodes().put("t_order",
Collections.singletonList(new DataNode("ds_0", "t_order")));
+ singleTableRule.getSingleTableDataNodes().put("t_order_item",
Collections.singletonList(new DataNode("ds_1", "t_order_item")));
RouteContext routeContext = new RouteContext();
singleTableRouteEngine.route(routeContext, singleTableRule);
List<RouteUnit> routeUnits = new
ArrayList<>(routeContext.getRouteUnits());
diff --git
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoaderTest.java
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoaderTest.java
index 3d383f1..700a7e6 100644
---
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoaderTest.java
+++
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableDataNodeLoaderTest.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.singletable.rule;
import
org.apache.shardingsphere.infra.config.properties.ConfigurationProperties;
import
org.apache.shardingsphere.infra.config.properties.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -85,35 +86,35 @@ public final class SingleTableDataNodeLoaderTest {
@Test
public void assertLoad() {
ConfigurationProperties props = new ConfigurationProperties(new
Properties());
- Map<String, SingleTableDataNode> dataNodeMap =
SingleTableDataNodeLoader.load(mock(DatabaseType.class), dataSourceMap,
Collections.emptyList(), props);
+ Map<String, Collection<DataNode>> dataNodeMap =
SingleTableDataNodeLoader.load(mock(DatabaseType.class), dataSourceMap,
Collections.emptyList(), props);
assertTrue(dataNodeMap.containsKey("employee"));
assertTrue(dataNodeMap.containsKey("dept"));
assertTrue(dataNodeMap.containsKey("salary"));
assertTrue(dataNodeMap.containsKey("student"));
assertTrue(dataNodeMap.containsKey("teacher"));
assertTrue(dataNodeMap.containsKey("class"));
- assertThat(dataNodeMap.get("employee").getDataSourceName(), is("ds0"));
- assertThat(dataNodeMap.get("dept").getDataSourceName(), is("ds0"));
- assertThat(dataNodeMap.get("salary").getDataSourceName(), is("ds0"));
- assertThat(dataNodeMap.get("student").getDataSourceName(), is("ds1"));
- assertThat(dataNodeMap.get("teacher").getDataSourceName(), is("ds1"));
- assertThat(dataNodeMap.get("class").getDataSourceName(), is("ds1"));
+
assertThat(dataNodeMap.get("employee").iterator().next().getDataSourceName(),
is("ds0"));
+
assertThat(dataNodeMap.get("dept").iterator().next().getDataSourceName(),
is("ds0"));
+
assertThat(dataNodeMap.get("salary").iterator().next().getDataSourceName(),
is("ds0"));
+
assertThat(dataNodeMap.get("student").iterator().next().getDataSourceName(),
is("ds1"));
+
assertThat(dataNodeMap.get("teacher").iterator().next().getDataSourceName(),
is("ds1"));
+
assertThat(dataNodeMap.get("class").iterator().next().getDataSourceName(),
is("ds1"));
}
@Test
public void assertLoadWithExcludeTables() {
ConfigurationProperties props = new ConfigurationProperties(new
Properties());
Collection<String> excludedTables = Arrays.asList("salary",
"employee", "student");
- Map<String, SingleTableDataNode> dataNodeMap =
SingleTableDataNodeLoader.load(mock(DatabaseType.class), dataSourceMap,
excludedTables, props);
+ Map<String, Collection<DataNode>> dataNodeMap =
SingleTableDataNodeLoader.load(mock(DatabaseType.class), dataSourceMap,
excludedTables, props);
assertFalse(dataNodeMap.containsKey("employee"));
assertFalse(dataNodeMap.containsKey("salary"));
assertFalse(dataNodeMap.containsKey("student"));
assertTrue(dataNodeMap.containsKey("dept"));
assertTrue(dataNodeMap.containsKey("teacher"));
assertTrue(dataNodeMap.containsKey("class"));
- assertThat(dataNodeMap.get("dept").getDataSourceName(), is("ds0"));
- assertThat(dataNodeMap.get("teacher").getDataSourceName(), is("ds1"));
- assertThat(dataNodeMap.get("class").getDataSourceName(), is("ds1"));
+
assertThat(dataNodeMap.get("dept").iterator().next().getDataSourceName(),
is("ds0"));
+
assertThat(dataNodeMap.get("teacher").iterator().next().getDataSourceName(),
is("ds1"));
+
assertThat(dataNodeMap.get("class").iterator().next().getDataSourceName(),
is("ds1"));
}
@Test(expected = IllegalStateException.class)
@@ -130,15 +131,15 @@ public final class SingleTableDataNodeLoaderTest {
properties.setProperty(ConfigurationPropertyKey.CHECK_DUPLICATE_TABLE_ENABLED.getKey(),
"true");
Collection<String> excludedTables = Arrays.asList("salary",
"employee", "student");
ConfigurationProperties props = new
ConfigurationProperties(properties);
- Map<String, SingleTableDataNode> dataNodeMap =
SingleTableDataNodeLoader.load(mock(DatabaseType.class), dataSourceMap,
excludedTables, props);
+ Map<String, Collection<DataNode>> dataNodeMap =
SingleTableDataNodeLoader.load(mock(DatabaseType.class), dataSourceMap,
excludedTables, props);
assertFalse(dataNodeMap.containsKey("employee"));
assertFalse(dataNodeMap.containsKey("salary"));
assertFalse(dataNodeMap.containsKey("student"));
assertTrue(dataNodeMap.containsKey("dept"));
assertTrue(dataNodeMap.containsKey("teacher"));
assertTrue(dataNodeMap.containsKey("class"));
- assertThat(dataNodeMap.get("dept").getDataSourceName(), is("ds0"));
- assertThat(dataNodeMap.get("teacher").getDataSourceName(), is("ds1"));
- assertThat(dataNodeMap.get("class").getDataSourceName(), is("ds1"));
+
assertThat(dataNodeMap.get("dept").iterator().next().getDataSourceName(),
is("ds0"));
+
assertThat(dataNodeMap.get("teacher").iterator().next().getDataSourceName(),
is("ds1"));
+
assertThat(dataNodeMap.get("class").iterator().next().getDataSourceName(),
is("ds1"));
}
}
diff --git
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableRuleTest.java
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableRuleTest.java
index 9cd1881..a8a55b1 100644
---
a/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableRuleTest.java
+++
b/shardingsphere-kernel/shardingsphere-single-table/shardingsphere-single-table-core/src/test/java/org/apache/shardingsphere/singletable/rule/SingleTableRuleTest.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.singletable.rule;
import
org.apache.shardingsphere.infra.config.properties.ConfigurationProperties;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import
org.apache.shardingsphere.infra.rule.identifier.type.DataNodeContainedRule;
import
org.apache.shardingsphere.singletable.config.SingleTableRuleConfiguration;
import org.junit.Before;
@@ -92,7 +93,7 @@ public final class SingleTableRuleTest {
when(dataNodeContainedRule.getAllTables()).thenReturn(Arrays.asList("t_order",
"t_order_0", "t_order_1"));
SingleTableRule singleTableRule = new SingleTableRule(new
SingleTableRuleConfiguration(), mock(DatabaseType.class), dataSourceMap,
Collections.singletonList(dataNodeContainedRule), new
ConfigurationProperties(new Properties()));
- Map<String, SingleTableDataNode> actual =
singleTableRule.getSingleTableDataNodes();
+ Map<String, Collection<DataNode>> actual =
singleTableRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
assertTrue(actual.containsKey("student"));
@@ -104,7 +105,7 @@ public final class SingleTableRuleTest {
when(dataNodeContainedRule.getAllTables()).thenReturn(Arrays.asList("T_ORDER",
"T_ORDER_0", "T_ORDER_1"));
SingleTableRule singleTableRule = new SingleTableRule(new
SingleTableRuleConfiguration(), mock(DatabaseType.class), dataSourceMap,
Collections.singletonList(dataNodeContainedRule), new
ConfigurationProperties(new Properties()));
- Map<String, SingleTableDataNode> actual =
singleTableRule.getSingleTableDataNodes();
+ Map<String, Collection<DataNode>> actual =
singleTableRule.getSingleTableDataNodes();
assertThat(actual.size(), is(2));
assertTrue(actual.containsKey("employee"));
assertTrue(actual.containsKey("student"));
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/SingleTableQueryResultSet.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/SingleTableQueryResultSet.java
index b7f5cc7..f57bbba 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/SingleTableQueryResultSet.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/SingleTableQueryResultSet.java
@@ -18,9 +18,9 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rql.rule;
import
org.apache.shardingsphere.distsql.parser.statement.rql.show.ShowSingleTableStatement;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.distsql.query.DistSQLResultSet;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
-import org.apache.shardingsphere.singletable.rule.SingleTableDataNode;
import org.apache.shardingsphere.singletable.rule.SingleTableRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
@@ -29,7 +29,7 @@ import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
-import java.util.Map.Entry;
+import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -38,13 +38,13 @@ import java.util.stream.Stream;
*/
public final class SingleTableQueryResultSet implements DistSQLResultSet {
- private Iterator<SingleTableDataNode> data = Collections.emptyIterator();
+ private Iterator<DataNode> data = Collections.emptyIterator();
@Override
public void init(final ShardingSphereMetaData metaData, final SQLStatement
sqlStatement) {
ShowSingleTableStatement showSingleTableStatement =
(ShowSingleTableStatement) sqlStatement;
- Stream<SingleTableDataNode> singleTableRules =
metaData.getRuleMetaData().getRules().stream().filter(each -> each instanceof
SingleTableRule)
- .map(each -> (SingleTableRule) each).map(each ->
each.getSingleTableDataNodes().entrySet()).flatMap(Collection::stream).map(Entry::getValue);
+ Stream<DataNode> singleTableRules =
metaData.getRuleMetaData().getRules().stream().filter(each -> each instanceof
SingleTableRule)
+ .map(each -> (SingleTableRule) each).map(each ->
each.getSingleTableDataNodes().values()).flatMap(Collection::stream).filter(Objects::nonNull).map(each
-> each.iterator().next());
if (null != showSingleTableStatement.getTableName()) {
singleTableRules = singleTableRules.filter(each ->
showSingleTableStatement.getTableName().equals(each.getTableName()));
}
@@ -63,7 +63,7 @@ public final class SingleTableQueryResultSet implements
DistSQLResultSet {
@Override
public Collection<Object> getRowData() {
- SingleTableDataNode next = data.next();
+ DataNode next = data.next();
return Arrays.asList(next.getTableName(), next.getDataSourceName());
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/SingleTableQueryResultSetTest.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/SingleTableQueryResultSetTest.java
index 7c00df0..a0cfb79 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/SingleTableQueryResultSetTest.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/SingleTableQueryResultSetTest.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rql;
import
org.apache.shardingsphere.distsql.parser.statement.rql.show.ShowSingleTableStatement;
+import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.distsql.query.DistSQLResultSet;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import
org.apache.shardingsphere.infra.metadata.rule.ShardingSphereRuleMetaData;
@@ -25,7 +26,6 @@ import
org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import
org.apache.shardingsphere.proxy.backend.text.distsql.rql.rule.SingleTableQueryResultSet;
import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
import org.apache.shardingsphere.shadow.rule.ShadowRule;
-import org.apache.shardingsphere.singletable.rule.SingleTableDataNode;
import org.apache.shardingsphere.singletable.rule.SingleTableRule;
import org.junit.Before;
import org.junit.Test;
@@ -35,6 +35,7 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.Collection;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
@@ -53,9 +54,9 @@ public final class SingleTableQueryResultSetTest {
@Before
public void before() {
- Map<String, SingleTableDataNode> singleTableDataNodeMap = new
HashMap<>();
- singleTableDataNodeMap.put("t_order", new
SingleTableDataNode("t_order", "ds_1"));
- singleTableDataNodeMap.put("t_order_item", new
SingleTableDataNode("t_order_item", "ds_2"));
+ Map<String, Collection<DataNode>> singleTableDataNodeMap = new
HashMap<>();
+ singleTableDataNodeMap.put("t_order", Collections.singletonList(new
DataNode("ds_1", "t_order")));
+ singleTableDataNodeMap.put("t_order_item",
Collections.singletonList(new DataNode("ds_2", "t_order_item")));
Collection<ShardingSphereRule> rules = new LinkedList<>();
rules.add(mockSingleTableRule(singleTableDataNodeMap));
ShardingSphereRuleMetaData ruleMetaData =
mock(ShardingSphereRuleMetaData.class);
@@ -81,9 +82,9 @@ public final class SingleTableQueryResultSetTest {
@Test
public void assertGetRowDataMultipleRules() {
- Map<String, SingleTableDataNode> singleTableDataNodeMap = new
HashMap<>();
- singleTableDataNodeMap.put("t_order_multiple", new
SingleTableDataNode("t_order_multiple", "ds_1_multiple"));
- singleTableDataNodeMap.put("t_order_item_multiple", new
SingleTableDataNode("t_order_item_multiple", "ds_2_multiple"));
+ Map<String, Collection<DataNode>> singleTableDataNodeMap = new
HashMap<>();
+ singleTableDataNodeMap.put("t_order_multiple",
Collections.singletonList(new DataNode("ds_1_multiple", "t_order_multiple")));
+ singleTableDataNodeMap.put("t_order_item_multiple",
Collections.singletonList(new DataNode("ds_2_multiple",
"t_order_item_multiple")));
addShardingSphereRule(mockSingleTableRule(singleTableDataNodeMap));
DistSQLResultSet resultSet = new SingleTableQueryResultSet();
resultSet.init(shardingSphereMetaData,
mock(ShowSingleTableStatement.class));
@@ -126,7 +127,7 @@ public final class SingleTableQueryResultSetTest {
assertThat(rowData.next(), is("ds_1"));
}
- private SingleTableRule mockSingleTableRule(final Map<String,
SingleTableDataNode> singleTableDataNodeMap) {
+ private SingleTableRule mockSingleTableRule(final Map<String,
Collection<DataNode>> singleTableDataNodeMap) {
SingleTableRule singleTableRule = mock(SingleTableRule.class);
when(singleTableRule.getSingleTableDataNodes()).thenReturn(singleTableDataNodeMap);
return singleTableRule;
