You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2026/02/18 14:53:37 UTC
(shardingsphere) branch master updated: Add more test cases on SingleRuleTest (#38088)
This is an automated email from the ASF dual-hosted git repository.
zhangliang 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 2782545d8e3 Add more test cases on SingleRuleTest (#38088)
2782545d8e3 is described below
commit 2782545d8e3eddabfe7a4e02821b301556f7f103
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Wed Feb 18 22:53:31 2026 +0800
Add more test cases on SingleRuleTest (#38088)
* Add more test cases on SingleRuleTest
* Add more test cases on SingleRuleTest
---
.../shardingsphere/single/rule/SingleRuleTest.java | 327 ++++++++++++++-------
1 file changed, 221 insertions(+), 106 deletions(-)
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 cedd328a823..564a1906827 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,10 +18,13 @@
package org.apache.shardingsphere.single.rule;
import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.database.connector.core.type.DatabaseTypeRegistry;
+import org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
import org.apache.shardingsphere.infra.datanode.DataNode;
+import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.schema.QualifiedTable;
-import org.apache.shardingsphere.infra.route.context.RouteContext;
-import org.apache.shardingsphere.infra.route.context.RouteMapper;
+import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
import org.apache.shardingsphere.infra.rule.attribute.datanode.DataNodeRuleAttribute;
@@ -29,9 +32,17 @@ import org.apache.shardingsphere.infra.rule.attribute.datanode.MutableDataNodeRu
import org.apache.shardingsphere.infra.rule.attribute.table.TableMapperRuleAttribute;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.single.config.SingleRuleConfiguration;
+import org.apache.shardingsphere.single.constant.SingleOrder;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.index.IndexSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.OwnerSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.IndexSQLStatementAttribute;
import org.apache.shardingsphere.test.infra.fixture.jdbc.MockedDataSource;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import javax.sql.DataSource;
import java.sql.Connection;
@@ -46,9 +57,10 @@ import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
+import java.util.stream.Stream;
-import static org.hamcrest.Matchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
@@ -57,43 +69,27 @@ import static org.mockito.Mockito.when;
class SingleRuleTest {
- private static final String TABLE_TYPE = "TABLE";
-
- private static final String PARTITIONED_TABLE_TYPE = "PARTITIONED TABLE";
-
- private static final String VIEW_TYPE = "VIEW";
-
- private static final String SYSTEM_TABLE_TYPE = "SYSTEM TABLE";
-
- private static final String SYSTEM_VIEW_TYPE = "SYSTEM VIEW";
-
- private static final String TABLE_NAME = "TABLE_NAME";
+ private final DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "FIXTURE");
private Map<String, DataSource> dataSourceMap;
private SingleRuleConfiguration ruleConfig;
- private final DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "FIXTURE");
-
@BeforeEach
void setUp() throws SQLException {
dataSourceMap = new LinkedHashMap<>(2, 1F);
dataSourceMap.put("foo_ds", mockDataSource("foo_ds", Arrays.asList("employee", "t_order_0")));
dataSourceMap.put("bar_ds", mockDataSource("bar_ds", Arrays.asList("student", "t_order_1")));
- Collection<String> configuredTables = new LinkedList<>(Arrays.asList("foo_ds.employee", "foo_ds.t_order_0", "bar_ds.student", "bar_ds.t_order_1"));
- ruleConfig = new SingleRuleConfiguration(configuredTables, null);
+ ruleConfig = new SingleRuleConfiguration(new LinkedList<>(Arrays.asList("foo_ds.employee", "foo_ds.t_order_0", "bar_ds.student", "bar_ds.t_order_1")), null);
}
- @SuppressWarnings("JDBCResourceOpenedButNotSafelyClosed")
private DataSource mockDataSource(final String dataSourceName, final List<String> tableNames) throws SQLException {
Connection connection = mock(Connection.class, RETURNS_DEEP_STUBS);
when(connection.getCatalog()).thenReturn(dataSourceName);
when(connection.getMetaData().getURL()).thenReturn(String.format("jdbc:mock://127.0.0.1/%s", dataSourceName));
- DataSource result = new MockedDataSource(connection);
ResultSet resultSet = mockResultSet(tableNames);
- when(result.getConnection().getMetaData().getTables(dataSourceName, null, null, new String[]{TABLE_TYPE, PARTITIONED_TABLE_TYPE, VIEW_TYPE, SYSTEM_TABLE_TYPE, SYSTEM_VIEW_TYPE}))
- .thenReturn(resultSet);
- return result;
+ when(connection.getMetaData().getTables(dataSourceName, null, null, new String[]{"TABLE", "PARTITIONED TABLE", "VIEW", "SYSTEM TABLE", "SYSTEM VIEW"})).thenReturn(resultSet);
+ return new MockedDataSource(connection);
}
private ResultSet mockResultSet(final List<String> tableNames) throws SQLException {
@@ -103,30 +99,24 @@ class SingleRuleTest {
when(result.next()).thenReturn(true, nextResults.toArray(new Boolean[tableNames.size()]));
String firstTableName = tableNames.get(0);
String[] nextTableNames = tableNames.subList(1, tableNames.size()).toArray(new String[tableNames.size() - 1]);
- when(result.getString(TABLE_NAME)).thenReturn(firstTableName, nextTableNames);
+ when(result.getString("TABLE_NAME")).thenReturn(firstTableName, nextTableNames);
return result;
}
@Test
- void assertGetSingleTableDataNodes() {
- TableMapperRuleAttribute ruleAttribute = mock(TableMapperRuleAttribute.class, RETURNS_DEEP_STUBS);
- when(ruleAttribute.getDistributedTableNames()).thenReturn(Collections.singletonList("t_order"));
- when(ruleAttribute.getActualTableNames()).thenReturn(Arrays.asList("t_order_0", "t_order_1"));
- ShardingSphereRule builtRule = mock(ShardingSphereRule.class);
- when(builtRule.getAttributes()).thenReturn(new RuleAttributes(ruleAttribute));
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
- Map<String, Collection<DataNode>> actual = singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getAllDataNodes();
- assertThat(actual.size(), is(2));
- assertTrue(actual.containsKey("employee"));
- assertTrue(actual.containsKey("student"));
+ void assertOrder() {
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ assertThat(new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule)).getOrder(), is(SingleOrder.ORDER));
}
- @Test
- void assertGetSingleTableDataNodesWithUpperCase() {
- ShardingSphereRule builtRule = mock(ShardingSphereRule.class);
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("getSingleTableDataNodesArguments")
+ void assertGetSingleTableDataNodes(final String name, final String distributedTableName, final String actualTableName1, final String actualTableName2) {
TableMapperRuleAttribute ruleAttribute = mock(TableMapperRuleAttribute.class, RETURNS_DEEP_STUBS);
- when(ruleAttribute.getDistributedTableNames()).thenReturn(Collections.singleton("T_ORDER"));
- when(ruleAttribute.getActualTableNames()).thenReturn(Arrays.asList("T_ORDER_0", "T_ORDER_1"));
+ Collection<String> distributedTableNames = Collections.singleton(distributedTableName);
+ when(ruleAttribute.getDistributedTableNames()).thenReturn(distributedTableNames);
+ when(ruleAttribute.getActualTableNames()).thenReturn(Arrays.asList(actualTableName1, actualTableName2));
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class);
when(builtRule.getAttributes()).thenReturn(new RuleAttributes(ruleAttribute));
SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
Map<String, Collection<DataNode>> actual = singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getAllDataNodes();
@@ -135,97 +125,108 @@ class SingleRuleTest {
assertTrue(actual.containsKey("student"));
}
- @Test
- void assertFindSingleTableDataNode() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- Optional<DataNode> actual = singleRule.getAttributes().getAttribute(MutableDataNodeRuleAttribute.class).findTableDataNode("foo_db", "employee");
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("findSingleTableDataNodeArguments")
+ void assertFindSingleTableDataNode(final String name, final String actualTableName, final String expectedDataSourceName, final String expectedTableName) {
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ Optional<DataNode> actual = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule)).getAttributes().getAttribute(MutableDataNodeRuleAttribute.class)
+ .findTableDataNode("foo_db", actualTableName);
assertTrue(actual.isPresent());
- assertThat(actual.get().getDataSourceName(), is("foo_ds"));
- assertThat(actual.get().getTableName(), is("employee"));
+ assertThat(actual.get().getDataSourceName(), is(expectedDataSourceName));
+ assertThat(actual.get().getTableName(), is(expectedTableName));
}
- @Test
- void assertFindSingleTableDataNodeWithUpperCase() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- Optional<DataNode> actual = singleRule.getAttributes().getAttribute(MutableDataNodeRuleAttribute.class).findTableDataNode("foo_db", "EMPLOYEE");
- assertTrue(actual.isPresent());
- assertThat(actual.get().getDataSourceName(), is("foo_ds"));
- assertThat(actual.get().getTableName(), is("employee"));
- }
-
- @Test
- void assertIsAllTablesInSameDataSource() {
- Collection<QualifiedTable> singleTables = new LinkedList<>();
- singleTables.add(new QualifiedTable("foo_db", "employee"));
- RouteMapper dataSourceMapper = new RouteMapper("foo_ds", null);
- Collection<RouteMapper> tableMappers = new LinkedList<>();
- tableMappers.add(dataSourceMapper);
- RouteContext routeContext = new RouteContext();
- routeContext.putRouteUnit(dataSourceMapper, tableMappers);
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- assertTrue(singleRule.isAllTablesInSameComputeNode(routeContext.getOriginalDataNodes().stream().flatMap(Collection::stream).collect(Collectors.toList()), singleTables));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("isAllTablesInSameComputeNodeArguments")
+ void assertIsAllTablesInSameComputeNode(final String name, final Collection<DataNode> dataNodes, final Collection<QualifiedTable> singleTables, final boolean expectedMatched) {
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertThat(singleRule.isAllTablesInSameComputeNode(dataNodes, singleTables), is(expectedMatched));
}
@Test
void assertAssignNewDataSourceName() {
SingleRuleConfiguration singleRuleConfig = new SingleRuleConfiguration();
singleRuleConfig.setDefaultDataSource("foo_ds");
- SingleRule singleRule = new SingleRule(
- singleRuleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(singleRuleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
assertThat(singleRule.assignNewDataSourceName(), is("foo_ds"));
}
@Test
- void assertGetSingleTables() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- Collection<QualifiedTable> tableNames = new LinkedList<>();
- tableNames.add(new QualifiedTable("foo_db", "employee"));
- assertThat(singleRule.getSingleTables(tableNames).iterator().next().getSchemaName(), is("foo_db"));
- assertThat(singleRule.getSingleTables(tableNames).iterator().next().getTableName(), is("employee"));
+ void assertAssignNewDataSourceNameWithoutDefaultDataSource() {
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertTrue(singleRule.getDataSourceNames().contains(singleRule.assignNewDataSourceName()));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("getSingleTablesArguments")
+ void assertGetSingleTables(final String name, final QualifiedTable inputTable, final boolean expectedPresent, final String expectedSchemaName, final String expectedTableName) {
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ Collection<QualifiedTable> actualTables = singleRule.getSingleTables(Collections.singleton(inputTable));
+ if (expectedPresent) {
+ QualifiedTable actualTable = actualTables.iterator().next();
+ assertThat(actualTable.getSchemaName(), is(expectedSchemaName));
+ assertThat(actualTable.getTableName(), is(expectedTableName));
+ } else {
+ assertTrue(actualTables.isEmpty());
+ }
}
@Test
void assertPut() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
String tableName = "teacher";
String dataSourceName = "foo_ds";
- singleRule.getAttributes().getAttribute(MutableDataNodeRuleAttribute.class).put(dataSourceName, "foo_db", tableName);
Collection<QualifiedTable> tableNames = new LinkedList<>();
tableNames.add(new QualifiedTable("foo_db", "teacher"));
- assertThat(singleRule.getSingleTables(tableNames).iterator().next().getSchemaName(), is("foo_db"));
- assertThat(singleRule.getSingleTables(tableNames).iterator().next().getTableName(), is("teacher"));
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("employee"));
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("student"));
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("t_order_0"));
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("t_order_1"));
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("teacher"));
+ singleRule.getAttributes().getAttribute(MutableDataNodeRuleAttribute.class).put(dataSourceName, "foo_db", tableName);
+ Collection<QualifiedTable> actualTables = singleRule.getSingleTables(tableNames);
+ QualifiedTable actualTable = actualTables.iterator().next();
+ assertThat(actualTable.getSchemaName(), is("foo_db"));
+ assertThat(actualTable.getTableName(), is("teacher"));
+ Collection<String> actualLogicTableNames = singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames();
+ assertTrue(actualLogicTableNames.contains("employee"));
+ assertTrue(actualLogicTableNames.contains("student"));
+ assertTrue(actualLogicTableNames.contains("t_order_0"));
+ assertTrue(actualLogicTableNames.contains("t_order_1"));
+ assertTrue(actualLogicTableNames.contains("teacher"));
}
@Test
void assertRemove() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
String tableName = "employee";
+ Collection<QualifiedTable> tableNames = Collections.singleton(new QualifiedTable("foo_db", "employee"));
singleRule.getAttributes().getAttribute(MutableDataNodeRuleAttribute.class).remove("foo_db", tableName);
- Collection<QualifiedTable> tableNames = new LinkedList<>();
- tableNames.add(new QualifiedTable("foo_db", "employee"));
assertTrue(singleRule.getSingleTables(tableNames).isEmpty());
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("student"));
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("t_order_0"));
- assertTrue(singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames().contains("t_order_1"));
+ Collection<String> actualLogicTableNames = singleRule.getAttributes().getAttribute(TableMapperRuleAttribute.class).getLogicTableNames();
+ assertTrue(actualLogicTableNames.contains("student"));
+ assertTrue(actualLogicTableNames.contains("t_order_0"));
+ assertTrue(actualLogicTableNames.contains("t_order_1"));
}
@Test
void assertGetAllDataNodes() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- assertTrue(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getAllDataNodes().containsKey("employee"));
- assertTrue(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getAllDataNodes().containsKey("student"));
- assertTrue(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getAllDataNodes().containsKey("t_order_0"));
- assertTrue(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getAllDataNodes().containsKey("t_order_1"));
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertFalse(singleRule.getConfiguration().getDefaultDataSource().isPresent());
+ Map<String, Collection<DataNode>> actualDataNodes = singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getAllDataNodes();
+ assertTrue(actualDataNodes.containsKey("employee"));
+ assertTrue(actualDataNodes.containsKey("student"));
+ assertTrue(actualDataNodes.containsKey("t_order_0"));
+ assertTrue(actualDataNodes.containsKey("t_order_1"));
}
@Test
void assertGetDataNodesByTableName() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertTrue(singleRule.getDataSourceNames().contains("foo_ds"));
Collection<DataNode> actual = singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).getDataNodesByTableName("EMPLOYEE");
assertThat(actual.size(), is(1));
DataNode dataNode = actual.iterator().next();
@@ -235,29 +236,143 @@ class SingleRuleTest {
@Test
void assertFindFirstActualTable() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- String logicTable = "employee";
- assertFalse(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).findFirstActualTable(logicTable).isPresent());
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertTrue(singleRule.getSingleTableDataNodes().containsKey("employee"));
+ assertFalse(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).findFirstActualTable("employee").isPresent());
}
@Test
void assertIsNeedAccumulate() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertFalse(singleRule.getConfiguration().getDefaultDataSource().isPresent());
assertFalse(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).isNeedAccumulate(Collections.emptyList()));
}
@Test
void assertFindLogicTableByActualTable() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- String actualTable = "student";
- assertFalse(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).findLogicTableByActualTable(actualTable).isPresent());
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertTrue(singleRule.getDataSourceNames().contains("bar_ds"));
+ assertFalse(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).findLogicTableByActualTable("student").isPresent());
}
@Test
void assertFindActualTableByCatalog() {
- SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS)));
- String catalog = "employee";
- String logicTable = "t_order_0";
- assertFalse(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).findActualTableByCatalog(catalog, logicTable).isPresent());
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ assertTrue(singleRule.getSingleTableDataNodes().containsKey("student"));
+ assertFalse(singleRule.getAttributes().getAttribute(DataNodeRuleAttribute.class).findActualTableByCatalog("employee", "t_order_0").isPresent());
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("getQualifiedTablesArguments")
+ void assertGetQualifiedTables(final String name, final boolean useSimpleTableSegments, final boolean useIndexAttribute) {
+ ShardingSphereRule builtRule = mock(ShardingSphereRule.class, RETURNS_DEEP_STUBS);
+ SingleRule singleRule = new SingleRule(ruleConfig, "foo_db", databaseType, dataSourceMap, Collections.singleton(builtRule));
+ SQLStatementContext sqlStatementContext = mock(SQLStatementContext.class, RETURNS_DEEP_STUBS);
+ ShardingSphereDatabase database = mock(ShardingSphereDatabase.class);
+ when(database.getName()).thenReturn("foo_db");
+ String defaultSchemaName = new DatabaseTypeRegistry(databaseType).getDefaultSchemaName("foo_db");
+ if (useSimpleTableSegments) {
+ Collection<SimpleTableSegment> simpleTableSegments = createSimpleTableSegments();
+ when(sqlStatementContext.getTablesContext().getSimpleTables()).thenReturn(simpleTableSegments);
+ when(sqlStatementContext.getSqlStatement().getAttributes().findAttribute(IndexSQLStatementAttribute.class)).thenReturn(Optional.empty());
+ } else {
+ when(sqlStatementContext.getTablesContext().getSimpleTables()).thenReturn(Collections.emptyList());
+ Optional<IndexSQLStatementAttribute> indexAttribute = useIndexAttribute ? Optional.of(createIndexAttribute(database, defaultSchemaName)) : Optional.empty();
+ when(sqlStatementContext.getSqlStatement().getAttributes().findAttribute(IndexSQLStatementAttribute.class)).thenReturn(indexAttribute);
+ }
+ Collection<QualifiedTable> actual = singleRule.getQualifiedTables(sqlStatementContext, database);
+ if (useSimpleTableSegments) {
+ assertThat(actual.size(), is(2));
+ assertTrue(actual.contains(new QualifiedTable(defaultSchemaName, "employee")));
+ assertTrue(actual.contains(new QualifiedTable("custom_schema", "student")));
+ return;
+ }
+ if (useIndexAttribute) {
+ assertThat(actual.size(), is(1));
+ assertTrue(actual.contains(new QualifiedTable(defaultSchemaName, "employee")));
+ return;
+ }
+ assertTrue(actual.isEmpty());
+ }
+
+ private static Collection<SimpleTableSegment> createSimpleTableSegments() {
+ Collection<SimpleTableSegment> result = new LinkedList<>();
+ result.add(createSimpleTableSegment(null, "employee"));
+ result.add(createSimpleTableSegment("custom_schema", "student"));
+ return result;
+ }
+
+ private static SimpleTableSegment createSimpleTableSegment(final String schemaName, final String tableName) {
+ SimpleTableSegment result = mock(SimpleTableSegment.class, RETURNS_DEEP_STUBS);
+ when(result.getTableName().getIdentifier().getValue()).thenReturn(tableName);
+ if (null == schemaName) {
+ when(result.getOwner()).thenReturn(Optional.empty());
+ } else {
+ OwnerSegment ownerSegment = mock(OwnerSegment.class, RETURNS_DEEP_STUBS);
+ when(ownerSegment.getIdentifier().getValue()).thenReturn(schemaName);
+ when(result.getOwner()).thenReturn(Optional.of(ownerSegment));
+ }
+ return result;
+ }
+
+ private static IndexSQLStatementAttribute createIndexAttribute(final ShardingSphereDatabase database, final String schemaName) {
+ IndexSegment indexSegment = mock(IndexSegment.class, RETURNS_DEEP_STUBS);
+ when(indexSegment.getOwner()).thenReturn(Optional.empty());
+ when(indexSegment.getIndexName().getIdentifier().getValue()).thenReturn("idx_employee");
+ IndexSQLStatementAttribute result = mock(IndexSQLStatementAttribute.class);
+ when(result.getIndexes()).thenReturn(Collections.singleton(indexSegment));
+ ShardingSphereSchema schema = mock(ShardingSphereSchema.class);
+ ShardingSphereTable table = mock(ShardingSphereTable.class);
+ when(database.getSchema(schemaName)).thenReturn(schema);
+ when(schema.getAllTables()).thenReturn(Collections.singleton(table));
+ when(table.containsIndex("idx_employee")).thenReturn(true);
+ when(table.getName()).thenReturn("employee");
+ return result;
+ }
+
+ private static Stream<Arguments> getSingleTableDataNodesArguments() {
+ return Stream.of(
+ Arguments.of("lower case distributed table", "t_order", "t_order_0", "t_order_1"),
+ Arguments.of("upper case distributed table", "T_ORDER", "T_ORDER_0", "T_ORDER_1"),
+ Arguments.of("mixed case distributed table", "t_Order", "t_order_0", "T_ORDER_1"));
+ }
+
+ private static Stream<Arguments> findSingleTableDataNodeArguments() {
+ return Stream.of(
+ Arguments.of("lower case table", "employee", "foo_ds", "employee"),
+ Arguments.of("upper case table", "EMPLOYEE", "foo_ds", "employee"),
+ Arguments.of("other table", "student", "bar_ds", "student"));
+ }
+
+ private static Stream<Arguments> isAllTablesInSameComputeNodeArguments() {
+ return Stream.of(
+ Arguments.of("all in same compute node", Collections.singleton(new DataNode("foo_ds", "foo_db", "employee")),
+ Collections.singleton(new QualifiedTable("foo_db", "employee")), true),
+ Arguments.of("single tables are in same compute node", Collections.singleton(new DataNode("foo_ds", "foo_db", "employee")),
+ Arrays.asList(new QualifiedTable("foo_db", "employee"), new QualifiedTable("foo_db", "t_order_0")), true),
+ Arguments.of("single tables are in different compute node", Collections.emptyList(),
+ Arrays.asList(new QualifiedTable("foo_db", "employee"), new QualifiedTable("foo_db", "student")), false),
+ Arguments.of("route data nodes are in different compute node", Collections.singleton(new DataNode("bar_ds", "foo_db", "employee")),
+ Collections.singleton(new QualifiedTable("foo_db", "employee")), false),
+ Arguments.of("single table metadata not found", Collections.emptyList(),
+ Collections.singleton(new QualifiedTable("foo_db", "missing_table")), true));
+ }
+
+ private static Stream<Arguments> getSingleTablesArguments() {
+ return Stream.of(
+ Arguments.of("table exists in same schema", new QualifiedTable("foo_db", "employee"), true, "foo_db", "employee"),
+ Arguments.of("table exists in different schema", new QualifiedTable("bar_db", "employee"), false, null, null),
+ Arguments.of("table does not exist", new QualifiedTable("foo_db", "missing_table"), false, null, null));
+ }
+
+ private static Stream<Arguments> getQualifiedTablesArguments() {
+ return Stream.of(
+ Arguments.of("qualified tables from simple table segments", true, false),
+ Arguments.of("qualified tables from index attribute", false, true),
+ Arguments.of("empty qualified tables when no tables and no index", false, false));
}
}