This is an automated email from the ASF dual-hosted git repository.
menghaoran 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 9cdbba7caeb Refactor RulesUsedResourceQueryResultSet (#18520)
9cdbba7caeb is described below
commit 9cdbba7caebafc59be9842f7dd73aaad7721d12b
Author: Liang Zhang <[email protected]>
AuthorDate: Thu Jun 23 00:12:43 2022 +0800
Refactor RulesUsedResourceQueryResultSet (#18520)
---
...eDiscoveryDynamicDataSourceStrategyFixture.java | 3 +-
.../pipeline/mysql/ingest/client/MySQLClient.java | 1 -
.../rql/rule/RulesUsedResourceQueryResultSet.java | 138 ++++++--------
.../rql/RulesUsedResourceQueryResultSetTest.java | 210 +++++++++++----------
4 files changed, 174 insertions(+), 178 deletions(-)
diff --git
a/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/test/java/org/apache/shardingsphere/readwritesplitting/fixture/DatabaseDiscoveryDynamicDataSourceStrategyFixture.java
b/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/test/java/org/apache/shardingsphere/readwritesplitting/fixture/DatabaseDiscoveryDynamicDataSourceStrategyFixture.java
index 275df756dc7..ba45dddc8bc 100644
---
a/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/test/java/org/apache/shardingsphere/readwritesplitting/fixture/DatabaseDiscoveryDynamicDataSourceStrategyFixture.java
+++
b/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/test/java/org/apache/shardingsphere/readwritesplitting/fixture/DatabaseDiscoveryDynamicDataSourceStrategyFixture.java
@@ -26,7 +26,8 @@ import java.util.Collections;
public class DatabaseDiscoveryDynamicDataSourceStrategyFixture implements
DynamicDataSourceStrategy {
@Override
- public void init(final ShardingSphereRule rule) { }
+ public void init(final ShardingSphereRule rule) {
+ }
@Override
public String getPrimaryDataSourceName(final String dataSourceName) {
diff --git
a/shardingsphere-kernel/shardingsphere-data-pipeline/shardingsphere-data-pipeline-dialect/shardingsphere-data-pipeline-mysql/src/main/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/client/MySQLClient.java
b/shardingsphere-kernel/shardingsphere-data-pipeline/shardingsphere-data-pipeline-dialect/shardingsphere-data-pipeline-mysql/src/main/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/client/MySQLClient.java
index d10e5022555..48a4ab7aec4 100644
---
a/shardingsphere-kernel/shardingsphere-data-pipeline/shardingsphere-data-pipeline-dialect/shardingsphere-data-pipeline-mysql/src/main/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/client/MySQLClient.java
+++
b/shardingsphere-kernel/shardingsphere-data-pipeline/shardingsphere-data-pipeline-dialect/shardingsphere-data-pipeline-mysql/src/main/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/client/MySQLClient.java
@@ -228,7 +228,6 @@ public final class MySQLClient {
}
}
-
/**
* Close netty channel.
*/
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/RulesUsedResourceQueryResultSet.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/RulesUsedResourceQueryResultSet.java
index e68123c5cf4..2729402af34 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/RulesUsedResourceQueryResultSet.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/rule/RulesUsedResourceQueryResultSet.java
@@ -18,33 +18,37 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.rql.rule;
import
org.apache.shardingsphere.dbdiscovery.api.config.DatabaseDiscoveryRuleConfiguration;
+import org.apache.shardingsphere.dbdiscovery.rule.DatabaseDiscoveryRule;
import
org.apache.shardingsphere.distsql.parser.statement.rql.show.ShowRulesUsedResourceStatement;
import org.apache.shardingsphere.encrypt.api.config.EncryptRuleConfiguration;
-import org.apache.shardingsphere.infra.config.RuleConfiguration;
+import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.infra.distsql.query.DistSQLResultSet;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
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.shadow.api.config.ShadowRuleConfiguration;
-import
org.apache.shardingsphere.shadow.api.config.datasource.ShadowDataSourceConfiguration;
+import org.apache.shardingsphere.shadow.rule.ShadowRule;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
+import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
+import org.apache.shardingsphere.sharding.rule.ShardingRule;
import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
-import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
-import java.util.HashMap;
+import java.util.Collections;
import java.util.Iterator;
+import java.util.LinkedList;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.stream.Collectors;
/**
* Result set for show rules used resource.
*/
public final class RulesUsedResourceQueryResultSet implements DistSQLResultSet
{
- private static final String TYPE =
ShowRulesUsedResourceStatement.class.getName();
-
private static final String SHARDING = "sharding";
private static final String READWRITE_SPLITTING = "readwrite_splitting";
@@ -55,108 +59,90 @@ public final class RulesUsedResourceQueryResultSet
implements DistSQLResultSet {
private static final String SHADOW = "shadow";
- private static final Map<String, Class<? extends RuleConfiguration>>
FEATURE_MAP = new HashMap<>(5, 1);
-
private Iterator<Collection<Object>> data;
- static {
- FEATURE_MAP.put(SHARDING, ShardingRuleConfiguration.class);
- FEATURE_MAP.put(READWRITE_SPLITTING,
ReadwriteSplittingRuleConfiguration.class);
- FEATURE_MAP.put(DB_DISCOVERY,
DatabaseDiscoveryRuleConfiguration.class);
- FEATURE_MAP.put(ENCRYPT, EncryptRuleConfiguration.class);
- FEATURE_MAP.put(SHADOW, ShadowRuleConfiguration.class);
- }
-
@Override
public void init(final ShardingSphereDatabase database, final SQLStatement
sqlStatement) {
- List<Collection<Object>> data = new ArrayList<>();
+ List<Collection<Object>> data = new LinkedList<>();
ShowRulesUsedResourceStatement statement =
(ShowRulesUsedResourceStatement) sqlStatement;
String resourceName = statement.getResourceName().orElse(null);
- if (hasRulesConfiguration(database) &&
database.getResource().getDataSources().containsKey(resourceName)) {
- getRulesConfig(database.getRuleMetaData().getConfigurations(),
resourceName, data);
+ if (database.getResource().getDataSources().containsKey(resourceName))
{
+ data.addAll(getShardingData(database));
+ data.addAll(getReadwriteSplittingData(database, resourceName));
+ data.addAll(getDatabaseDiscoveryData(database, resourceName));
+ data.addAll(getEncryptData(database));
+ data.addAll(getShadowData(database, resourceName));
}
this.data = data.iterator();
}
- private void getRulesConfig(final Collection<RuleConfiguration>
ruleConfigs, final String resourceName, final List<Collection<Object>> data) {
- ruleConfigs.forEach(each -> {
- getRulesConfigForSharding(each, data);
- getRulesConfigForReadwriteSplitting(each, resourceName, data);
- getRulesConfigForDBDiscovery(each, resourceName, data);
- getRulesConfigForEncrypt(each, data);
- getRulesConfigForShadow(each, resourceName, data);
- });
- }
-
- private void getRulesConfigForSharding(final RuleConfiguration ruleConfig,
final List<Collection<Object>> result) {
- if (!matchFeature(ruleConfig, SHARDING)) {
- return;
+ private Collection<Collection<Object>> getShardingData(final
ShardingSphereDatabase database) {
+ Optional<ShardingRule> rule =
database.getRuleMetaData().findSingleRule(ShardingRule.class);
+ if (!rule.isPresent()) {
+ return Collections.emptyList();
+ }
+ Collection<Collection<Object>> result = new LinkedList<>();
+ ShardingRuleConfiguration config = (ShardingRuleConfiguration)
rule.get().getConfiguration();
+ for (ShardingAutoTableRuleConfiguration each : config.getAutoTables())
{
+ result.add(buildRow(SHARDING, each.getLogicTable()));
+ }
+ for (ShardingTableRuleConfiguration each : config.getTables()) {
+ result.add(buildRow(SHARDING, each.getLogicTable()));
}
- ShardingRuleConfiguration config = (ShardingRuleConfiguration)
ruleConfig;
- config.getAutoTables().forEach(each -> result.add(buildRow(SHARDING,
each.getLogicTable())));
- config.getTables().forEach(each -> result.add(buildRow(SHARDING,
each.getLogicTable())));
+ return result;
}
- private void getRulesConfigForReadwriteSplitting(final RuleConfiguration
ruleConfig, final String resourceName, final List<Collection<Object>> result) {
- if (!matchFeature(ruleConfig, READWRITE_SPLITTING)) {
- return;
+ private Collection<Collection<Object>> getReadwriteSplittingData(final
ShardingSphereDatabase database, final String resourceName) {
+ Optional<ReadwriteSplittingRule> rule =
database.getRuleMetaData().findSingleRule(ReadwriteSplittingRule.class);
+ if (!rule.isPresent()) {
+ return Collections.emptyList();
}
- ReadwriteSplittingRuleConfiguration config =
(ReadwriteSplittingRuleConfiguration) ruleConfig;
- config.getDataSources().forEach(each -> {
+ Collection<Collection<Object>> result = new LinkedList<>();
+ ReadwriteSplittingRuleConfiguration config =
(ReadwriteSplittingRuleConfiguration) rule.get().getConfiguration();
+ for (ReadwriteSplittingDataSourceRuleConfiguration each :
config.getDataSources()) {
if (each.getWriteDataSourceName().isPresent() &&
each.getWriteDataSourceName().get().equalsIgnoreCase(resourceName)) {
result.add(buildRow(READWRITE_SPLITTING, each.getName()));
}
if (each.getReadDataSourceNames().isPresent() &&
Arrays.asList(each.getReadDataSourceNames().get().split(",")).contains(resourceName))
{
result.add(buildRow(READWRITE_SPLITTING, each.getName()));
}
- });
- }
-
- private void getRulesConfigForDBDiscovery(final RuleConfiguration
ruleConfig, final String resourceName, final List<Collection<Object>> result) {
- if (!matchFeature(ruleConfig, DB_DISCOVERY)) {
- return;
}
- DatabaseDiscoveryRuleConfiguration config =
(DatabaseDiscoveryRuleConfiguration) ruleConfig;
- config.getDataSources().forEach(each -> {
- if (each.getDataSourceNames().contains(resourceName)) {
- result.add(buildRow(DB_DISCOVERY, each.getGroupName()));
- }
- });
+ return result;
}
- private void getRulesConfigForEncrypt(final RuleConfiguration ruleConfig,
final List<Collection<Object>> result) {
- if (!matchFeature(ruleConfig, ENCRYPT)) {
- return;
+ private Collection<Collection<Object>> getDatabaseDiscoveryData(final
ShardingSphereDatabase database, final String resourceName) {
+ Optional<DatabaseDiscoveryRule> rule =
database.getRuleMetaData().findSingleRule(DatabaseDiscoveryRule.class);
+ if (!rule.isPresent()) {
+ return Collections.emptyList();
}
- EncryptRuleConfiguration config = (EncryptRuleConfiguration)
ruleConfig;
- config.getTables().forEach(each -> result.add(buildRow(ENCRYPT,
each.getName())));
+ DatabaseDiscoveryRuleConfiguration config =
(DatabaseDiscoveryRuleConfiguration) rule.get().getConfiguration();
+ return config.getDataSources().stream().filter(each ->
each.getDataSourceNames().contains(resourceName)).map(each ->
buildRow(DB_DISCOVERY, each.getGroupName())).collect(Collectors.toList());
}
- private void getRulesConfigForShadow(final RuleConfiguration ruleConfig,
final String resourceName, final List<Collection<Object>> result) {
- if (!matchFeature(ruleConfig, SHADOW)) {
- return;
- }
- ShadowRuleConfiguration config = (ShadowRuleConfiguration) ruleConfig;
- for (Entry<String, ShadowDataSourceConfiguration> each :
config.getDataSources().entrySet()) {
- if
(each.getValue().getShadowDataSourceName().equalsIgnoreCase(resourceName) ||
each.getValue().getSourceDataSourceName().equalsIgnoreCase(resourceName)) {
- result.add(buildRow(SHADOW, each.getKey()));
- }
+ private Collection<Collection<Object>> getEncryptData(final
ShardingSphereDatabase database) {
+ Optional<EncryptRule> rule =
database.getRuleMetaData().findSingleRule(EncryptRule.class);
+ if (!rule.isPresent()) {
+ return Collections.emptyList();
}
+ EncryptRuleConfiguration config = (EncryptRuleConfiguration)
rule.get().getConfiguration();
+ return config.getTables().stream().map(each -> buildRow(ENCRYPT,
each.getName())).collect(Collectors.toList());
}
- private boolean matchFeature(final RuleConfiguration ruleConfig, final
String feature) {
- return null != ruleConfig &&
ruleConfig.getClass().getName().equals(FEATURE_MAP.get(feature).getName());
+ private Collection<Collection<Object>> getShadowData(final
ShardingSphereDatabase database, final String resourceName) {
+ Optional<ShadowRule> rule =
database.getRuleMetaData().findSingleRule(ShadowRule.class);
+ if (!rule.isPresent()) {
+ return Collections.emptyList();
+ }
+ ShadowRuleConfiguration config = (ShadowRuleConfiguration)
rule.get().getConfiguration();
+ return config.getDataSources().entrySet().stream()
+ .filter(entry ->
entry.getValue().getShadowDataSourceName().equalsIgnoreCase(resourceName) ||
entry.getValue().getSourceDataSourceName().equalsIgnoreCase(resourceName))
+ .map(entry -> buildRow(SHADOW,
entry.getKey())).collect(Collectors.toList());
}
private Collection<Object> buildRow(final String type, final String name) {
return Arrays.asList(type, name);
}
- private boolean hasRulesConfiguration(final ShardingSphereDatabase
database) {
- Collection<RuleConfiguration> configs =
database.getRuleMetaData().getConfigurations();
- return null != configs && !configs.isEmpty();
- }
-
@Override
public Collection<String> getColumnNames() {
return Arrays.asList("type", "name");
@@ -174,6 +160,6 @@ public final class RulesUsedResourceQueryResultSet
implements DistSQLResultSet {
@Override
public String getType() {
- return TYPE;
+ return ShowRulesUsedResourceStatement.class.getName();
}
}
diff --git
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/RulesUsedResourceQueryResultSetTest.java
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/RulesUsedResourceQueryResultSetTest.java
index fa4a844ba47..e4dad9b7b0e 100644
---
a/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/RulesUsedResourceQueryResultSetTest.java
+++
b/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/rql/RulesUsedResourceQueryResultSetTest.java
@@ -19,10 +19,11 @@ package
org.apache.shardingsphere.proxy.backend.text.distsql.rql;
import
org.apache.shardingsphere.dbdiscovery.api.config.DatabaseDiscoveryRuleConfiguration;
import
org.apache.shardingsphere.dbdiscovery.api.config.rule.DatabaseDiscoveryDataSourceRuleConfiguration;
+import org.apache.shardingsphere.dbdiscovery.rule.DatabaseDiscoveryRule;
import
org.apache.shardingsphere.distsql.parser.statement.rql.show.ShowRulesUsedResourceStatement;
import org.apache.shardingsphere.encrypt.api.config.EncryptRuleConfiguration;
import
org.apache.shardingsphere.encrypt.api.config.rule.EncryptTableRuleConfiguration;
-import org.apache.shardingsphere.infra.config.RuleConfiguration;
+import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.infra.distsql.query.DistSQLResultSet;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.ShardingSphereResource;
@@ -30,16 +31,16 @@ import
org.apache.shardingsphere.infra.metadata.database.rule.ShardingSphereRule
import
org.apache.shardingsphere.proxy.backend.text.distsql.rql.rule.RulesUsedResourceQueryResultSet;
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.shadow.api.config.ShadowRuleConfiguration;
import
org.apache.shardingsphere.shadow.api.config.datasource.ShadowDataSourceConfiguration;
+import org.apache.shardingsphere.shadow.rule.ShadowRule;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import
org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
import
org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
+import org.apache.shardingsphere.sharding.rule.ShardingRule;
import org.apache.shardingsphere.test.mock.MockedDataSource;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.Collection;
@@ -49,135 +50,144 @@ import java.util.Optional;
import java.util.Properties;
import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.Silent.class)
public final class RulesUsedResourceQueryResultSetTest {
- @Mock
- private ShardingSphereDatabase database;
-
@Test
- public void assertGetRowDataForSharding() {
- init(mockShardingTableRule());
+ public void assertGetRowData() {
DistSQLResultSet resultSet = new RulesUsedResourceQueryResultSet();
ShowRulesUsedResourceStatement sqlStatement =
mock(ShowRulesUsedResourceStatement.class);
- when(sqlStatement.getResourceName()).thenReturn(Optional.of("ds_0"));
- resultSet.init(database, sqlStatement);
- Collection<Object> actual = resultSet.getRowData();
- assertThat(actual.size(), is(2));
- Iterator<Object> rowData = actual.iterator();
- assertThat(rowData.next(), is("sharding"));
- assertThat(rowData.next(), is("sharding_auto_table"));
- resultSet.next();
- actual = resultSet.getRowData();
- assertThat(actual.size(), is(2));
- rowData = actual.iterator();
- assertThat(rowData.next(), is("sharding"));
- assertThat(rowData.next(), is("sharding_table"));
+ when(sqlStatement.getResourceName()).thenReturn(Optional.of("foo_ds"));
+ resultSet.init(mockDatabase(), sqlStatement);
+ assertShardingTableData(resultSet);
+ assertReadwriteSplittingData(resultSet);
+ assertDatabaseDiscoveryData(resultSet);
+ assertEncryptData(resultSet);
+ assertShadowData(resultSet);
+ assertFalse(resultSet.next());
}
- @Test
- public void assertGetRowDataForReadwriteSplitting() {
- init(mockReadwriteSplittingRule());
- DistSQLResultSet resultSet = new RulesUsedResourceQueryResultSet();
- ShowRulesUsedResourceStatement sqlStatement =
mock(ShowRulesUsedResourceStatement.class);
- when(sqlStatement.getResourceName()).thenReturn(Optional.of("ds_0"));
- resultSet.init(database, sqlStatement);
- Collection<Object> actual = resultSet.getRowData();
- assertThat(actual.size(), is(2));
- Iterator<Object> rowData = actual.iterator();
- assertThat(rowData.next(), is("readwrite_splitting"));
- assertThat(rowData.next(), is("readwrite_splitting_source"));
+ private ShardingSphereDatabase mockDatabase() {
+ ShardingSphereDatabase result = mock(ShardingSphereDatabase.class);
+ ShardingSphereRuleMetaData ruleMetaData = new
ShardingSphereRuleMetaData(
+ Arrays.asList(mockShardingRule(),
mockReadwriteSplittingRule(), mockDatabaseDiscoveryRule(), mockEncryptRule(),
mockShadowRule()));
+ when(result.getRuleMetaData()).thenReturn(ruleMetaData);
+ ShardingSphereResource resource = new
ShardingSphereResource(Collections.singletonMap("foo_ds", new
MockedDataSource()));
+ when(result.getResource()).thenReturn(resource);
+ return result;
}
- @Test
- public void assertGetRowDataForDBDiscovery() {
- init(mockDBDiscoveryRule());
- DistSQLResultSet resultSet = new RulesUsedResourceQueryResultSet();
- ShowRulesUsedResourceStatement sqlStatement =
mock(ShowRulesUsedResourceStatement.class);
- when(sqlStatement.getResourceName()).thenReturn(Optional.of("ds_0"));
- resultSet.init(database, sqlStatement);
- Collection<Object> actual = resultSet.getRowData();
- assertThat(actual.size(), is(2));
- Iterator<Object> rowData = actual.iterator();
- assertThat(rowData.next(), is("db_discovery"));
- assertThat(rowData.next(), is("db_discovery_group_name"));
+ private ShardingRule mockShardingRule() {
+ ShardingRule result = mock(ShardingRule.class);
+ ShardingRuleConfiguration config =
mock(ShardingRuleConfiguration.class);
+ when(config.getTables()).thenReturn(Collections.singleton(new
ShardingTableRuleConfiguration("sharding_table")));
+ when(config.getAutoTables()).thenReturn(Collections.singleton(new
ShardingAutoTableRuleConfiguration("sharding_auto_table")));
+ when(result.getConfiguration()).thenReturn(config);
+ return result;
}
- @Test
- public void assertGetRowDataForEncryptRule() {
- init(mockEncryptRule());
- DistSQLResultSet resultSet = new RulesUsedResourceQueryResultSet();
- ShowRulesUsedResourceStatement sqlStatement =
mock(ShowRulesUsedResourceStatement.class);
- when(sqlStatement.getResourceName()).thenReturn(Optional.of("ds_0"));
- resultSet.init(database, sqlStatement);
- Collection<Object> actual = resultSet.getRowData();
- assertThat(actual.size(), is(2));
- Iterator<Object> rowData = actual.iterator();
- assertThat(rowData.next(), is("encrypt"));
- assertThat(rowData.next(), is("encrypt_table"));
+ private ReadwriteSplittingRule mockReadwriteSplittingRule() {
+ ReadwriteSplittingRule result = mock(ReadwriteSplittingRule.class);
+ ReadwriteSplittingRuleConfiguration config =
mock(ReadwriteSplittingRuleConfiguration.class);
+ when(config.getDataSources()).thenReturn(Collections.singleton(new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_splitting_source", "",
createReadwriteSplittingProperties(), "")));
+ when(result.getConfiguration()).thenReturn(config);
+ return result;
}
- @Test
- public void assertGetRowDataForShadowRule() {
- init(mockShadowRule());
- DistSQLResultSet resultSet = new RulesUsedResourceQueryResultSet();
- ShowRulesUsedResourceStatement sqlStatement =
mock(ShowRulesUsedResourceStatement.class);
- when(sqlStatement.getResourceName()).thenReturn(Optional.of("ds_0"));
- resultSet.init(database, sqlStatement);
- Collection<Object> actual = resultSet.getRowData();
- assertThat(actual.size(), is(2));
- Iterator<Object> rowData = actual.iterator();
- assertThat(rowData.next(), is("shadow"));
- assertThat(rowData.next(), is("shadow_source"));
+ private Properties createReadwriteSplittingProperties() {
+ Properties result = new Properties();
+ result.setProperty("write-data-source-name", "foo_ds");
+ result.setProperty("read-data-source-names", "foo_ds,bar_ds");
+ return result;
}
- private void init(final RuleConfiguration ruleConfig) {
- ShardingSphereRuleMetaData ruleMetaData =
mock(ShardingSphereRuleMetaData.class);
-
when(ruleMetaData.getConfigurations()).thenReturn(Collections.singleton(ruleConfig));
- when(database.getRuleMetaData()).thenReturn(ruleMetaData);
- ShardingSphereResource resource = new
ShardingSphereResource(Collections.singletonMap("ds_0", new
MockedDataSource()));
- when(database.getResource()).thenReturn(resource);
+ private DatabaseDiscoveryRule mockDatabaseDiscoveryRule() {
+ DatabaseDiscoveryRule result = mock(DatabaseDiscoveryRule.class);
+ DatabaseDiscoveryRuleConfiguration config =
mock(DatabaseDiscoveryRuleConfiguration.class);
+ when(config.getDataSources()).thenReturn(Collections.singleton(new
DatabaseDiscoveryDataSourceRuleConfiguration("db_discovery_group_name",
Arrays.asList("foo_ds", "bar_ds"), "", "")));
+ when(result.getConfiguration()).thenReturn(config);
+ return result;
}
- private RuleConfiguration mockShardingTableRule() {
- ShardingRuleConfiguration result =
mock(ShardingRuleConfiguration.class);
- when(result.getTables()).thenReturn(Collections.singleton(new
ShardingTableRuleConfiguration("sharding_table")));
- when(result.getAutoTables()).thenReturn(Collections.singleton(new
ShardingAutoTableRuleConfiguration("sharding_auto_table")));
+ private EncryptRule mockEncryptRule() {
+ EncryptRule result = mock(EncryptRule.class);
+ EncryptRuleConfiguration config = mock(EncryptRuleConfiguration.class);
+ when(config.getTables()).thenReturn(Collections.singleton(new
EncryptTableRuleConfiguration("encrypt_table", Collections.emptyList(),
false)));
+ when(result.getConfiguration()).thenReturn(config);
return result;
}
- private RuleConfiguration mockReadwriteSplittingRule() {
- ReadwriteSplittingRuleConfiguration result =
mock(ReadwriteSplittingRuleConfiguration.class);
- when(result.getDataSources()).thenReturn(Collections.singleton(new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_splitting_source", "",
createProperties(), "")));
+ private ShadowRule mockShadowRule() {
+ ShadowRule result = mock(ShadowRule.class);
+ ShadowRuleConfiguration config = mock(ShadowRuleConfiguration.class);
+
when(config.getDataSources()).thenReturn(Collections.singletonMap("shadow_source",
new ShadowDataSourceConfiguration("foo_ds", "shadow_ds")));
+ when(result.getConfiguration()).thenReturn(config);
return result;
}
- private Properties createProperties() {
- Properties result = new Properties();
- result.setProperty("write-data-source-name", "ds_0");
- result.setProperty("read-data-source-names", "read_0,read_1");
- return result;
+ private void assertShardingTableData(final DistSQLResultSet resultSet) {
+ Iterator<Object> actual = getActualRowData(resultSet);
+ assertThat(actual.next(), is("sharding"));
+ assertThat(actual.next(), is("sharding_auto_table"));
+ actual = getActualRowData(resultSet);
+ assertThat(actual.next(), is("sharding"));
+ assertThat(actual.next(), is("sharding_table"));
}
- private RuleConfiguration mockDBDiscoveryRule() {
- DatabaseDiscoveryRuleConfiguration result =
mock(DatabaseDiscoveryRuleConfiguration.class);
- when(result.getDataSources()).thenReturn(Collections.singleton(new
DatabaseDiscoveryDataSourceRuleConfiguration("db_discovery_group_name",
Arrays.asList("ds_0", "ds_1"), "", "")));
- return result;
+ private void assertReadwriteSplittingData(final DistSQLResultSet
resultSet) {
+ Iterator<Object> actual = getActualRowData(resultSet);
+ assertThat(actual.next(), is("readwrite_splitting"));
+ assertThat(actual.next(), is("readwrite_splitting_source"));
+ actual = getActualRowData(resultSet);
+ assertThat(actual.next(), is("readwrite_splitting"));
+ assertThat(actual.next(), is("readwrite_splitting_source"));
}
- private RuleConfiguration mockEncryptRule() {
- EncryptRuleConfiguration result = mock(EncryptRuleConfiguration.class);
- when(result.getTables()).thenReturn(Collections.singleton(new
EncryptTableRuleConfiguration("encrypt_table", Collections.emptyList(),
false)));
- return result;
+ private void assertDatabaseDiscoveryData(final DistSQLResultSet resultSet)
{
+ Iterator<Object> actual = getActualRowData(resultSet);
+ assertThat(actual.next(), is("db_discovery"));
+ assertThat(actual.next(), is("db_discovery_group_name"));
+ }
+
+ private void assertEncryptData(final DistSQLResultSet resultSet) {
+ Iterator<Object> actual = getActualRowData(resultSet);
+ assertThat(actual.next(), is("encrypt"));
+ assertThat(actual.next(), is("encrypt_table"));
+ }
+
+ private void assertShadowData(final DistSQLResultSet resultSet) {
+ Iterator<Object> actual = getActualRowData(resultSet);
+ assertThat(actual.next(), is("shadow"));
+ assertThat(actual.next(), is("shadow_source"));
+ }
+
+ private Iterator<Object> getActualRowData(final DistSQLResultSet
resultSet) {
+ assertTrue(resultSet.next());
+ Collection<Object> actual = resultSet.getRowData();
+ assertThat(actual.size(), is(2));
+ return actual.iterator();
+ }
+
+ @Test
+ public void assertGetEmptyRowData() {
+ ShardingSphereDatabase database = mockEmptyDatabase();
+ DistSQLResultSet resultSet = new RulesUsedResourceQueryResultSet();
+ ShowRulesUsedResourceStatement sqlStatement =
mock(ShowRulesUsedResourceStatement.class);
+
when(sqlStatement.getResourceName()).thenReturn(Optional.of("empty_ds"));
+ resultSet.init(database, sqlStatement);
+ assertFalse(resultSet.next());
}
- private RuleConfiguration mockShadowRule() {
- ShadowRuleConfiguration result = mock(ShadowRuleConfiguration.class);
-
when(result.getDataSources()).thenReturn(Collections.singletonMap("shadow_source",
new ShadowDataSourceConfiguration("ds_0", "shadow_ds")));
+ private ShardingSphereDatabase mockEmptyDatabase() {
+ ShardingSphereDatabase result = mock(ShardingSphereDatabase.class);
+ when(result.getRuleMetaData()).thenReturn(new
ShardingSphereRuleMetaData(Collections.emptyList()));
+ ShardingSphereResource resource = new
ShardingSphereResource(Collections.singletonMap("empty_ds", new
MockedDataSource()));
+ when(result.getResource()).thenReturn(resource);
return result;
}
}
