You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by yx...@apache.org on 2022/06/11 17:34:53 UTC
[shardingsphere] branch master updated: Refactor CountInstanceRulesHandler (#18305)
This is an automated email from the ASF dual-hosted git repository.
yx9o 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 b781cde538a Refactor CountInstanceRulesHandler (#18305)
b781cde538a is described below
commit b781cde538a65b447b46d0f62b336d940a32dec1
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sun Jun 12 01:34:42 2022 +0800
Refactor CountInstanceRulesHandler (#18305)
* Refactor CountInstanceRulesHandler
* Refactor CountInstanceRulesHandler
* Refactor CountInstanceRulesHandler
* Fix test case
---
.../queryable/CountInstanceRulesHandler.java | 144 ++++++++-------------
.../common/queryable/CountInstanceRulesTest.java | 55 ++++----
2 files changed, 73 insertions(+), 126 deletions(-)
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesHandler.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesHandler.java
index c7ca0df6e73..5bdf460d65e 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesHandler.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesHandler.java
@@ -17,28 +17,26 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.ral.common.queryable;
-import org.apache.shardingsphere.dbdiscovery.api.config.DatabaseDiscoveryRuleConfiguration;
+import com.google.common.base.Preconditions;
+import org.apache.shardingsphere.dbdiscovery.rule.DatabaseDiscoveryRule;
import org.apache.shardingsphere.distsql.parser.statement.ral.common.queryable.CountInstanceRulesStatement;
-import org.apache.shardingsphere.encrypt.api.config.EncryptRuleConfiguration;
-import org.apache.shardingsphere.infra.config.RuleConfiguration;
-import org.apache.shardingsphere.infra.distsql.constant.ExportableConstants;
+import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.infra.merge.result.impl.local.LocalDataQueryResultRow;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.text.distsql.ral.QueryableRALBackendHandler;
-import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
+import org.apache.shardingsphere.shadow.rule.ShadowRule;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
+import org.apache.shardingsphere.sharding.rule.ShardingRule;
import org.apache.shardingsphere.singletable.rule.SingleTableRule;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collection;
-import java.util.Collections;
import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
@@ -48,8 +46,6 @@ import java.util.function.Supplier;
*/
public final class CountInstanceRulesHandler extends QueryableRALBackendHandler<CountInstanceRulesStatement> {
- private static final int DEFAULT_COUNT = 0;
-
private static final String SINGLE_TABLE = "single_table";
private static final String SHARDING_TABLE = "sharding_table";
@@ -75,109 +71,71 @@ public final class CountInstanceRulesHandler extends QueryableRALBackendHandler<
@Override
protected Collection<LocalDataQueryResultRow> getRows(final ContextManager contextManager) throws SQLException {
- Map<String, List<Object>> dataMap = new LinkedHashMap<>();
- ProxyContext.getInstance().getAllDatabaseNames().forEach(each -> addSchemaData(dataMap, ProxyContext.getInstance().getDatabase(each)));
- Collection<LocalDataQueryResultRow> result = new LinkedList<>();
- for (List<Object> each : dataMap.values()) {
- result.add(new LocalDataQueryResultRow(each));
- }
- return result;
+ Map<String, LocalDataQueryResultRow> result = initRows();
+ ProxyContext.getInstance().getAllDatabaseNames().forEach(each -> addDatabaseData(result, ProxyContext.getInstance().getDatabase(each)));
+ return result.values();
}
- private void addSchemaData(final Map<String, List<Object>> dataMap, final ShardingSphereDatabase database) {
- initData(dataMap);
- Collection<SingleTableRule> singleTableRules = database.getRuleMetaData().findRules(SingleTableRule.class);
- if (!singleTableRules.isEmpty()) {
- addSingleTableData(dataMap, singleTableRules);
+ private Map<String, LocalDataQueryResultRow> initRows() {
+ Map<String, LocalDataQueryResultRow> result = new LinkedHashMap<>();
+ for (String each : Arrays.asList(SINGLE_TABLE, SHARDING_TABLE, SHARDING_BINDING_TABLE, SHARDING_BROADCAST_TABLE, SHARDING_SCALING, READWRITE_SPLITTING, DB_DISCOVERY, ENCRYPT, SHADOW)) {
+ result.put(each, new LocalDataQueryResultRow(each, 0));
}
- if (hasRuleConfiguration(database)) {
- addConfigurationData(dataMap, database.getRuleMetaData().getConfigurations());
- }
- }
-
- private void addSingleTableData(final Map<String, List<Object>> dataMap, final Collection<SingleTableRule> rules) {
- Optional<Integer> count = rules.stream().map(each -> (Collection) each.export(ExportableConstants.EXPORT_SINGLE_TABLES).orElse(Collections.emptyMap()))
- .map(Collection::size).reduce(Integer::sum);
- dataMap.compute(SINGLE_TABLE, (key, value) -> buildRow(value, SINGLE_TABLE, count.orElse(DEFAULT_COUNT)));
- }
-
- private boolean hasRuleConfiguration(final ShardingSphereDatabase database) {
- Collection<RuleConfiguration> configs = database.getRuleMetaData().getConfigurations();
- return null != configs && !configs.isEmpty();
- }
-
- private void initData(final Map<String, List<Object>> dataMap) {
- addDefaultData(dataMap, SINGLE_TABLE, SHARDING_TABLE, SHARDING_BINDING_TABLE, SHARDING_BROADCAST_TABLE, SHARDING_SCALING, READWRITE_SPLITTING, DB_DISCOVERY, ENCRYPT, SHADOW);
- }
-
- private void addConfigurationData(final Map<String, List<Object>> dataMap, final Collection<RuleConfiguration> ruleConfigs) {
- ruleConfigs.forEach(each -> {
- addShardingData(dataMap, each);
- addReadwriteSplittingData(dataMap, each);
- addDBDiscoveryData(dataMap, each);
- addEncryptData(dataMap, each);
- addShadowData(dataMap, each);
- });
+ return result;
}
- private void addShardingData(final Map<String, List<Object>> dataMap, final RuleConfiguration ruleConfig) {
- if (!(ruleConfig instanceof ShardingRuleConfiguration)) {
- return;
+ private void addDatabaseData(final Map<String, LocalDataQueryResultRow> rowMap, final ShardingSphereDatabase database) {
+ for (ShardingSphereRule each : database.getRuleMetaData().getRules()) {
+ if (each instanceof SingleTableRule) {
+ addSingleTableData(rowMap, (SingleTableRule) each);
+ } else if (each instanceof ShardingRule) {
+ Optional<ShardingRuleConfiguration> shardingRuleConfig = database.getRuleMetaData().findSingleRuleConfiguration(ShardingRuleConfiguration.class);
+ Preconditions.checkState(shardingRuleConfig.isPresent());
+ addShardingData(rowMap, (ShardingRule) each, shardingRuleConfig.get());
+ } else if (each instanceof ReadwriteSplittingRule) {
+ addReadwriteSplittingData(rowMap, (ReadwriteSplittingRule) each);
+ } else if (each instanceof DatabaseDiscoveryRule) {
+ addDBDiscoveryData(rowMap, (DatabaseDiscoveryRule) each);
+ } else if (each instanceof EncryptRule) {
+ addEncryptData(rowMap, (EncryptRule) each);
+ } else if (each instanceof ShadowRule) {
+ addShadowData(rowMap, (ShadowRule) each);
+ }
}
- addData(dataMap, SHARDING_TABLE, () -> ((ShardingRuleConfiguration) ruleConfig).getTables().size() + ((ShardingRuleConfiguration) ruleConfig).getAutoTables().size());
- addData(dataMap, SHARDING_BINDING_TABLE, () -> ((ShardingRuleConfiguration) ruleConfig).getBindingTableGroups().size());
- addData(dataMap, SHARDING_BROADCAST_TABLE, () -> ((ShardingRuleConfiguration) ruleConfig).getBroadcastTables().size());
- addData(dataMap, SHARDING_SCALING, () -> ((ShardingRuleConfiguration) ruleConfig).getScaling().size());
}
- private void addReadwriteSplittingData(final Map<String, List<Object>> dataMap, final RuleConfiguration ruleConfig) {
- if (!(ruleConfig instanceof ReadwriteSplittingRuleConfiguration)) {
- return;
- }
- addData(dataMap, READWRITE_SPLITTING, () -> ((ReadwriteSplittingRuleConfiguration) ruleConfig).getDataSources().size());
+ private void addSingleTableData(final Map<String, LocalDataQueryResultRow> rowMap, final SingleTableRule rule) {
+ rowMap.compute(SINGLE_TABLE, (key, value) -> buildRow(value, SINGLE_TABLE, rule.getAllTables().size()));
}
- private void addDBDiscoveryData(final Map<String, List<Object>> dataMap, final RuleConfiguration ruleConfig) {
- if (!(ruleConfig instanceof DatabaseDiscoveryRuleConfiguration)) {
- return;
- }
- addData(dataMap, DB_DISCOVERY, () -> ((DatabaseDiscoveryRuleConfiguration) ruleConfig).getDataSources().size());
+ private void addShardingData(final Map<String, LocalDataQueryResultRow> rowMap, final ShardingRule rule, final ShardingRuleConfiguration ruleConfig) {
+ addData(rowMap, SHARDING_TABLE, () -> rule.getTables().size());
+ addData(rowMap, SHARDING_BINDING_TABLE, () -> rule.getBindingTableRules().size());
+ addData(rowMap, SHARDING_BROADCAST_TABLE, () -> rule.getBroadcastTables().size());
+ addData(rowMap, SHARDING_SCALING, () -> ruleConfig.getScaling().size());
}
- private void addEncryptData(final Map<String, List<Object>> dataMap, final RuleConfiguration ruleConfig) {
- if (!(ruleConfig instanceof EncryptRuleConfiguration)) {
- return;
- }
- addData(dataMap, ENCRYPT, () -> ((EncryptRuleConfiguration) ruleConfig).getTables().size());
+ private void addReadwriteSplittingData(final Map<String, LocalDataQueryResultRow> rowMap, final ReadwriteSplittingRule rule) {
+ addData(rowMap, READWRITE_SPLITTING, () -> rule.getDataSourceMapper().size());
}
- private void addShadowData(final Map<String, List<Object>> dataMap, final RuleConfiguration ruleConfig) {
- if (!(ruleConfig instanceof ShadowRuleConfiguration)) {
- return;
- }
- addData(dataMap, SHADOW, () -> ((ShadowRuleConfiguration) ruleConfig).getDataSources().size());
+ private void addDBDiscoveryData(final Map<String, LocalDataQueryResultRow> rowMap, final DatabaseDiscoveryRule rule) {
+ addData(rowMap, DB_DISCOVERY, () -> rule.getDataSourceMapper().size());
}
- private void addData(final Map<String, List<Object>> dataMap, final String dataKey, final Supplier<Integer> apply) {
- dataMap.compute(dataKey, (key, value) -> buildRow(value, dataKey, apply.get()));
+ private void addEncryptData(final Map<String, LocalDataQueryResultRow> rowMap, final EncryptRule rule) {
+ addData(rowMap, ENCRYPT, () -> rule.getTables().size());
}
- private void addDefaultData(final Map<String, List<Object>> dataMap, final String... dataKey) {
- for (String each : dataKey) {
- dataMap.putIfAbsent(each, buildRow(each, DEFAULT_COUNT));
- }
+ private void addShadowData(final Map<String, LocalDataQueryResultRow> rowMap, final ShadowRule rule) {
+ addData(rowMap, SHADOW, () -> rule.getDataSourceMapper().size());
}
- private List<Object> buildRow(final Collection<Object> value, final String ruleName, final Integer count) {
- if (value == null) {
- return Arrays.asList(ruleName, count);
- } else {
- Integer oldCount = (Integer) new LinkedList<>(value).getLast();
- return Arrays.asList(ruleName, Integer.sum(oldCount, count));
- }
+ private void addData(final Map<String, LocalDataQueryResultRow> rowMap, final String dataKey, final Supplier<Integer> apply) {
+ rowMap.compute(dataKey, (key, value) -> buildRow(value, dataKey, apply.get()));
}
- private List<Object> buildRow(final String ruleName, final Integer count) {
- return Arrays.asList(ruleName, count);
+ private LocalDataQueryResultRow buildRow(final LocalDataQueryResultRow value, final String ruleName, final int count) {
+ return null == value ? new LocalDataQueryResultRow(ruleName, count) : new LocalDataQueryResultRow(ruleName, Integer.sum((Integer) value.getCell(2), count));
}
}
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesTest.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesTest.java
index 5a98c33d8b7..f2c617941d2 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesTest.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/test/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/queryable/CountInstanceRulesTest.java
@@ -18,21 +18,17 @@
package org.apache.shardingsphere.proxy.backend.text.distsql.ral.common.queryable;
import org.apache.shardingsphere.distsql.parser.statement.ral.common.queryable.CountInstanceRulesStatement;
-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.infra.distsql.constant.ExportableConstants;
+import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.metadata.database.rule.ShardingSphereRuleMetaData;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
import org.apache.shardingsphere.proxy.backend.util.ProxyContextRestorer;
-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.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.BindingTableRule;
+import org.apache.shardingsphere.sharding.rule.ShardingRule;
import org.apache.shardingsphere.singletable.rule.SingleTableRule;
import org.junit.Before;
import org.junit.Test;
@@ -47,13 +43,11 @@ import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
-import java.util.LinkedList;
import java.util.Map;
-import java.util.Properties;
+import java.util.Optional;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -71,15 +65,10 @@ public final class CountInstanceRulesTest extends ProxyContextRestorer {
@Before
public void before() {
- Collection<ShardingSphereRule> rules = new LinkedList<>();
- rules.add(mockSingleTableRule());
ShardingSphereRuleMetaData ruleMetaData = mock(ShardingSphereRuleMetaData.class);
- when(ruleMetaData.findRules(any())).thenReturn(rules);
- Collection<RuleConfiguration> ruleConfigs = new LinkedList<>();
- ruleConfigs.add(mockShardingTableRule());
- ruleConfigs.add(mockReadwriteSplittingRule());
- ruleConfigs.add(mockEncryptRule());
- when(ruleMetaData.getConfigurations()).thenReturn(ruleConfigs);
+ when(ruleMetaData.findSingleRuleConfiguration(ShardingRuleConfiguration.class)).thenReturn(Optional.of(mock(ShardingRuleConfiguration.class)));
+ Collection<ShardingSphereRule> rules = Arrays.asList(mockSingleTableRule(), mockShardingRule(), mockReadwriteSplittingRule(), mockEncryptRule());
+ when(ruleMetaData.getRules()).thenReturn(rules);
when(database1.getRuleMetaData()).thenReturn(ruleMetaData);
when(database2.getRuleMetaData()).thenReturn(ruleMetaData);
Map<String, ShardingSphereDatabase> databases = new HashMap<>(2, 1);
@@ -91,28 +80,27 @@ public final class CountInstanceRulesTest extends ProxyContextRestorer {
private SingleTableRule mockSingleTableRule() {
SingleTableRule result = mock(SingleTableRule.class);
- when(result.export(ExportableConstants.EXPORT_SINGLE_TABLES)).thenReturn(java.util.Optional.of(Arrays.asList("single_table_1", "single_table_2")));
+ when(result.getAllTables()).thenReturn(Arrays.asList("single_table_1", "single_table_2"));
return result;
}
- private RuleConfiguration mockShardingTableRule() {
- ShardingRuleConfiguration result = mock(ShardingRuleConfiguration.class);
- when(result.getTables()).thenReturn(Collections.singletonList(new ShardingTableRuleConfiguration("sharding_table")));
- when(result.getAutoTables()).thenReturn(Collections.singletonList(new ShardingAutoTableRuleConfiguration("sharding_auto_table")));
- when(result.getBindingTableGroups()).thenReturn(Collections.singletonList("binding_table_1,binding_table_2"));
+ private ShardingRule mockShardingRule() {
+ ShardingRule result = mock(ShardingRule.class);
+ when(result.getTables()).thenReturn(Arrays.asList("sharding_table", "sharding_auto_table"));
+ when(result.getBindingTableRules()).thenReturn(Collections.singletonMap("binding_table", mock(BindingTableRule.class)));
when(result.getBroadcastTables()).thenReturn(Arrays.asList("broadcast_table_1", "broadcast_table_2"));
return result;
}
- private RuleConfiguration mockReadwriteSplittingRule() {
- ReadwriteSplittingRuleConfiguration result = mock(ReadwriteSplittingRuleConfiguration.class);
- when(result.getDataSources()).thenReturn(Collections.singletonList(new ReadwriteSplittingDataSourceRuleConfiguration("readwrite_splitting", "", new Properties(), "")));
+ private ReadwriteSplittingRule mockReadwriteSplittingRule() {
+ ReadwriteSplittingRule result = mock(ReadwriteSplittingRule.class);
+ when(result.getDataSourceMapper()).thenReturn(Collections.singletonMap("readwrite_splitting", Arrays.asList("write_ds", "read_ds")));
return result;
}
- private RuleConfiguration mockEncryptRule() {
- EncryptRuleConfiguration result = mock(EncryptRuleConfiguration.class);
- when(result.getTables()).thenReturn(Collections.singletonList(new EncryptTableRuleConfiguration("encrypt_table", Collections.emptyList(), false)));
+ private EncryptRule mockEncryptRule() {
+ EncryptRule result = mock(EncryptRule.class);
+ when(result.getTables()).thenReturn(Collections.singleton("encrypt_table"));
return result;
}
@@ -168,8 +156,9 @@ public final class CountInstanceRulesTest extends ProxyContextRestorer {
public void assertGetRowDataWithoutConfiguration() throws SQLException {
CountInstanceRulesHandler handler = new CountInstanceRulesHandler();
handler.init(new CountInstanceRulesStatement(), null);
- when(database1.getRuleMetaData().getConfigurations()).thenReturn(Collections.emptyList());
- when(database2.getRuleMetaData().getConfigurations()).thenReturn(Collections.emptyList());
+ Collection<ShardingSphereRule> rules = Collections.singleton(mockSingleTableRule());
+ when(database1.getRuleMetaData().getRules()).thenReturn(rules);
+ when(database2.getRuleMetaData().getRules()).thenReturn(rules);
handler.execute();
handler.next();
Collection<Object> actual = handler.getRowData();