Refactor change unconfiguredSchemaMetaDataMap type to Map<String, Col…

…lection<String>> (#7559) * Refactor RuleSchemaMetaData.unconfiguredSchemaMetaDataMap to Map<String,Collection<String>>, due to unconfigured table only need table name * fix checkstyle * fix checkstyle issue * fix test
apache · Sep 23, 2020 · bf2d576 · bf2d576
1 parent 89c6a55
commit bf2d576
Show file tree

Hide file tree

Showing 20 changed files with 73 additions and 93 deletions.
diff --git a/...java/org/apache/shardingsphere/sharding/route/engine/type/ShardingRouteEngineFactory.java b/...java/org/apache/shardingsphere/sharding/route/engine/type/ShardingRouteEngineFactory.java
@@ -32,7 +32,6 @@
 import org.apache.shardingsphere.sharding.route.engine.type.unconfigured.ShardingUnconfiguredTablesRoutingEngine;
 import org.apache.shardingsphere.sharding.route.engine.type.unicast.ShardingUnicastRoutingEngine;
 import org.apache.shardingsphere.sharding.rule.ShardingRule;
-import org.apache.shardingsphere.sql.parser.binder.metadata.schema.SchemaMetaData;
 import org.apache.shardingsphere.sql.parser.binder.statement.SQLStatementContext;
 import org.apache.shardingsphere.sql.parser.binder.type.TableAvailable;
 import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
@@ -95,7 +94,7 @@ public static ShardingRouteEngine newInstance(final ShardingRule shardingRule, f
     }
 
     private static ShardingRouteEngine getDALRoutingEngine(final ShardingRule shardingRule, 
-                                                           final Map<String, SchemaMetaData> unconfiguredSchemaMetaDataMap, final SQLStatement sqlStatement, final Collection<String> tableNames) {
+                                                           final Map<String, Collection<String>> unconfiguredSchemaMetaDataMap, final SQLStatement sqlStatement, final Collection<String> tableNames) {
         if (sqlStatement instanceof MySQLUseStatement) {
             return new ShardingIgnoreRoutingEngine();
         }

diff --git a/...here/sharding/route/engine/type/unconfigured/ShardingUnconfiguredTablesRoutingEngine.java b/...here/sharding/route/engine/type/unconfigured/ShardingUnconfiguredTablesRoutingEngine.java
@@ -20,18 +20,17 @@
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.sharding.rule.ShardingRule;
 import org.apache.shardingsphere.sharding.route.engine.type.ShardingRouteEngine;
-import org.apache.shardingsphere.sql.parser.binder.metadata.schema.SchemaMetaData;
 import org.apache.shardingsphere.infra.exception.ShardingSphereException;
 import org.apache.shardingsphere.infra.route.context.RouteMapper;
 import org.apache.shardingsphere.infra.route.context.RouteResult;
 import org.apache.shardingsphere.infra.route.context.RouteUnit;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 /**
  * Sharding unconfigured tables engine.
@@ -41,7 +40,7 @@ public final class ShardingUnconfiguredTablesRoutingEngine implements ShardingRo
 
     private final Collection<String> logicTables;
 
-    private final Map<String, SchemaMetaData> unconfiguredSchemaMetaDataMap;
+    private final Map<String, Collection<String>> unconfiguredSchemaMetaDataMap;
 
     @Override
     public RouteResult route(final ShardingRule shardingRule) {
@@ -50,17 +49,14 @@ public RouteResult route(final ShardingRule shardingRule) {
             throw new ShardingSphereException("Can not route tables for `%s`, please make sure the tables are in same schema.", logicTables);
         }
         RouteResult result = new RouteResult();
-        List<RouteMapper> routingTables = new ArrayList<>(logicTables.size());
-        for (String each : logicTables) {
-            routingTables.add(new RouteMapper(each, each));
-        }
+        List<RouteMapper> routingTables = logicTables.stream().map(table -> new RouteMapper(table, table)).collect(Collectors.toList());
         result.getRouteUnits().add(new RouteUnit(new RouteMapper(dataSourceName.get(), dataSourceName.get()), routingTables));
         return result;
     }
 
     private Optional<String> findDataSourceName() {
-        for (Entry<String, SchemaMetaData> entry : unconfiguredSchemaMetaDataMap.entrySet()) {
-            if (entry.getValue().getAllTableNames().containsAll(logicTables)) {
+        for (Entry<String, Collection<String>> entry : unconfiguredSchemaMetaDataMap.entrySet()) {
+            if (entry.getValue().containsAll(logicTables)) {
                 return Optional.of(entry.getKey());
             }
         }

diff --git a/...a/org/apache/shardingsphere/sharding/route/engine/type/standard/AbstractSQLRouteTest.java b/...a/org/apache/shardingsphere/sharding/route/engine/type/standard/AbstractSQLRouteTest.java
@@ -36,6 +36,7 @@
 
 import java.sql.Types;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -81,10 +82,8 @@ private RuleSchemaMetaData buildRuleSchemaMetaData() {
                 new ColumnMetaData("status", Types.VARCHAR, "varchar", false, false, false),
                 new ColumnMetaData("c_date", Types.TIMESTAMP, "timestamp", false, false, false)), Collections.emptySet()));
         tableMetaDataMap.put("t_other", new TableMetaData(Collections.singletonList(new ColumnMetaData("order_id", Types.INTEGER, "int", true, false, false)), Collections.emptySet()));
-        Map<String, TableMetaData> unconfiguredTableMetaDataMap = new HashMap<>(1, 1);
-        unconfiguredTableMetaDataMap.put("t_category", new TableMetaData(Collections.singletonList(new ColumnMetaData("order_id", Types.INTEGER, "int", true, false, false)), Collections.emptySet()));
-        Map<String, SchemaMetaData> unconfiguredSchemaMetaDataMap = new HashMap<>(1, 1);
-        unconfiguredSchemaMetaDataMap.put("ds_0", new SchemaMetaData(unconfiguredTableMetaDataMap));
+        Map<String, Collection<String>> unconfiguredSchemaMetaDataMap = new HashMap<>(1, 1);
+        unconfiguredSchemaMetaDataMap.put("ds_0", Arrays.asList("t_category"));
         return new RuleSchemaMetaData(new SchemaMetaData(tableMetaDataMap), unconfiguredSchemaMetaDataMap);
     }
 }
diff --git a/.../sharding/route/engine/type/unconfigured/ShardingUnconfiguredTablesRoutingEngineTest.java b/.../sharding/route/engine/type/unconfigured/ShardingUnconfiguredTablesRoutingEngineTest.java
@@ -19,8 +19,6 @@
 
 import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
 import org.apache.shardingsphere.sharding.rule.ShardingRule;
-import org.apache.shardingsphere.sql.parser.binder.metadata.schema.SchemaMetaData;
-import org.apache.shardingsphere.sql.parser.binder.metadata.table.TableMetaData;
 import org.apache.shardingsphere.infra.route.context.RouteMapper;
 import org.apache.shardingsphere.infra.route.context.RouteResult;
 import org.apache.shardingsphere.infra.route.context.RouteUnit;
@@ -29,7 +27,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
@@ -45,11 +43,8 @@ public final class ShardingUnconfiguredTablesRoutingEngineTest {
 
     @Before
     public void setUp() {
-        Map<String, TableMetaData> tableMetaDataMap = new HashMap<>(2, 1);
-        tableMetaDataMap.put("t_order", new TableMetaData(Collections.emptyList(), Collections.emptyList()));
-        tableMetaDataMap.put("t_order_item", new TableMetaData(Collections.emptyList(), Collections.emptyList()));
-        Map<String, SchemaMetaData> unconfiguredSchemaMetaDataMap = new HashMap<>(1, 1);
-        unconfiguredSchemaMetaDataMap.put("ds_0", new SchemaMetaData(tableMetaDataMap));
+        Map<String, Collection<String>> unconfiguredSchemaMetaDataMap = new HashMap<>(1, 1);
+        unconfiguredSchemaMetaDataMap.put("ds_0", Arrays.asList("t_order", "t_order_item"));
         shardingDefaultDatabaseRoutingEngine = new ShardingUnconfiguredTablesRoutingEngine(Arrays.asList("t_order", "t_order_item"), unconfiguredSchemaMetaDataMap);
     }
 

diff --git a/...org/apache/shardingsphere/governance/core/yaml/swapper/RuleSchemaMetaDataYamlSwapper.java b/...org/apache/shardingsphere/governance/core/yaml/swapper/RuleSchemaMetaDataYamlSwapper.java
@@ -47,22 +47,26 @@ public YamlRuleSchemaMetaData swapToYamlConfiguration(final RuleSchemaMetaData m
         YamlRuleSchemaMetaData result = new YamlRuleSchemaMetaData();
         result.setConfiguredSchemaMetaData(convertYamlSchema(metaData.getConfiguredSchemaMetaData()));
         Map<String, YamlSchemaMetaData> unconfigured = metaData.getUnconfiguredSchemaMetaDataMap().entrySet().stream()
-                .collect(Collectors.toMap(Entry::getKey, entry -> convertYamlSchema(entry.getValue())));
+                .collect(Collectors.toMap(Entry::getKey, entry -> convertUnconfiguredYamlSchema(entry.getValue())));
         result.setUnconfiguredSchemaMetaDataMap(unconfigured);
         return result;
     }
-
+    
     @Override
     public RuleSchemaMetaData swapToObject(final YamlRuleSchemaMetaData yamlConfig) {
         SchemaMetaData configured = Optional.ofNullable(yamlConfig.getConfiguredSchemaMetaData()).map(this::convertSchema).orElse(new SchemaMetaData());
-        Map<String, SchemaMetaData> unconfigured = Optional.ofNullable(yamlConfig.getUnconfiguredSchemaMetaDataMap()).map(e -> e.entrySet().stream()
-                .collect(Collectors.toMap(Entry::getKey, entry -> convertSchema(entry.getValue())))).orElse(new HashMap<>());
+        Map<String, Collection<String>> unconfigured = Optional.ofNullable(yamlConfig.getUnconfiguredSchemaMetaDataMap()).map(e -> e.entrySet().stream()
+                .collect(Collectors.toMap(Entry::getKey, entry -> convertUnconfiguredSchema(entry.getValue())))).orElse(new HashMap<>());
         return new RuleSchemaMetaData(configured, unconfigured);
     }
 
     private SchemaMetaData convertSchema(final YamlSchemaMetaData schema) {
         return new SchemaMetaData(schema.getTables().entrySet().stream().collect(Collectors.toMap(Entry::getKey, entry -> convertTable(entry.getValue()))));
     }
+
+    private Collection<String> convertUnconfiguredSchema(final YamlSchemaMetaData schema) {
+        return schema.getTables().keySet().stream().collect(Collectors.toList());
+    }
 
     private TableMetaData convertTable(final YamlTableMetaData table) {
         return new TableMetaData(convertColumns(table.getColumns()), convertIndexes(table.getIndexes()));
@@ -90,6 +94,12 @@ private YamlSchemaMetaData convertYamlSchema(final SchemaMetaData schema) {
         result.setTables(tables);
         return result;
     }
+
+    private YamlSchemaMetaData convertUnconfiguredYamlSchema(final Collection<String> tableNames) {
+        SchemaMetaData schemaMetaData = new SchemaMetaData();
+        tableNames.forEach(table -> schemaMetaData.put(table, new TableMetaData()));
+        return convertYamlSchema(schemaMetaData);
+    }
 
     private YamlTableMetaData convertYamlTable(final TableMetaData table) {
         YamlTableMetaData result = new YamlTableMetaData();

diff --git a/...apache/shardingsphere/governance/core/yaml/swapper/RuleSchemaMetaDataYamlSwapperTest.java b/...apache/shardingsphere/governance/core/yaml/swapper/RuleSchemaMetaDataYamlSwapperTest.java
@@ -25,6 +25,7 @@
 
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.stream.Collectors;
 
@@ -48,8 +49,6 @@ public void assertSwapToYamlRuleSchemaMetaData() {
         assertThat(yamlRuleSchemaMetaData.getConfiguredSchemaMetaData().getTables().get("t_order").getColumns().keySet(), is(Collections.singleton("id")));
         assertThat(yamlRuleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().keySet(), is(Collections.singleton("ds_0")));
         assertThat(yamlRuleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").getTables().keySet(), is(Collections.singleton("t_user")));
-        assertThat(yamlRuleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").getTables().get("t_user").getIndexes().keySet(), is(Collections.singleton("primary")));
-        assertThat(yamlRuleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").getTables().get("t_user").getColumns().keySet(), is(Collections.singleton("id")));
     }
 
     @Test
@@ -64,9 +63,7 @@ public void assertSwapToRuleSchemaMetaData() {
         assertThat(ruleSchemaMetaData.getConfiguredSchemaMetaData().getAllColumnNames("t_order").size(), is(1));
         assertThat(ruleSchemaMetaData.getConfiguredSchemaMetaData().get("t_order").getColumns().keySet(), is(Collections.singleton("id")));
         assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().keySet(), is(Collections.singleton("ds_0")));
-        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").getAllTableNames(), is(Collections.singleton("t_user")));
-        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").get("t_user").getIndexes().keySet(), is(Collections.singleton("primary")));
-        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").get("t_user").getColumns().keySet(), is(Collections.singleton("id")));
+        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0"), is(Arrays.asList("t_user")));
     }
 
     @SneakyThrows

diff --git a/...nfig/src/test/java/org/apache/shardingsphere/governance/core/config/ConfigCenterTest.java b/...nfig/src/test/java/org/apache/shardingsphere/governance/core/config/ConfigCenterTest.java
@@ -522,9 +522,7 @@ public void assertLoadMetaData() {
         assertThat(ruleSchemaMetaData.getConfiguredSchemaMetaData().getAllColumnNames("t_order").size(), is(1));
         assertThat(ruleSchemaMetaData.getConfiguredSchemaMetaData().get("t_order").getColumns().keySet(), is(Collections.singleton("id")));
         assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().keySet(), is(Collections.singleton("ds_0")));
-        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").getAllTableNames(), is(Collections.singleton("t_user")));
-        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").get("t_user").getIndexes().keySet(), is(Collections.singleton("primary")));
-        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0").get("t_user").getColumns().keySet(), is(Collections.singleton("id")));
+        assertThat(ruleSchemaMetaData.getUnconfiguredSchemaMetaDataMap().get("ds_0"), is(Arrays.asList("t_user")));
     }
 
     @Test

diff --git a/...ardingsphere/infra/metadata/refresh/impl/CreateTableStatementMetaDataRefreshStrategy.java b/...ardingsphere/infra/metadata/refresh/impl/CreateTableStatementMetaDataRefreshStrategy.java
@@ -17,18 +17,18 @@
 
 package org.apache.shardingsphere.infra.metadata.refresh.impl;
 
+import com.google.common.collect.Lists;
 import org.apache.shardingsphere.infra.database.type.DatabaseType;
 import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
 import org.apache.shardingsphere.infra.metadata.refresh.MetaDataRefreshStrategy;
 import org.apache.shardingsphere.infra.metadata.refresh.TableMetaDataLoaderCallback;
-import org.apache.shardingsphere.sql.parser.binder.metadata.schema.SchemaMetaData;
 import org.apache.shardingsphere.sql.parser.binder.metadata.table.TableMetaData;
 import org.apache.shardingsphere.sql.parser.binder.metadata.table.TableMetaDataLoader;
 import org.apache.shardingsphere.sql.parser.binder.statement.ddl.CreateTableStatementContext;
 
 import javax.sql.DataSource;
 import java.sql.SQLException;
-import java.util.HashMap;
+import java.util.Collection;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
@@ -55,20 +55,18 @@ private void refreshUnconfiguredMetaData(final ShardingSphereMetaData metaData,
         for (Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
             Optional<TableMetaData> tableMetaData = TableMetaDataLoader.loadWithoutColumnMetaData(entry.getValue(), tableName, databaseType.getName());
             if (tableMetaData.isPresent()) {
-                refreshUnconfiguredMetaData(metaData, tableName, entry.getKey(), tableMetaData.get());
+                refreshUnconfiguredMetaData(metaData, tableName, entry.getKey());
                 return;
             }
         }
     }
 
-    private void refreshUnconfiguredMetaData(final ShardingSphereMetaData metaData, final String tableName, final String dataSourceName, final TableMetaData tableMetaData) {
-        SchemaMetaData schemaMetaData = metaData.getRuleSchemaMetaData().getUnconfiguredSchemaMetaDataMap().get(dataSourceName);
+    private void refreshUnconfiguredMetaData(final ShardingSphereMetaData metaData, final String tableName, final String dataSourceName) {
+        Collection<String> schemaMetaData = metaData.getRuleSchemaMetaData().getUnconfiguredSchemaMetaDataMap().get(dataSourceName);
         if (null == schemaMetaData) {
-            Map<String, TableMetaData> tables = new HashMap<>(1, 1);
-            tables.put(tableName, tableMetaData);
-            metaData.getRuleSchemaMetaData().getUnconfiguredSchemaMetaDataMap().put(dataSourceName, new SchemaMetaData(tables));
+            metaData.getRuleSchemaMetaData().getUnconfiguredSchemaMetaDataMap().put(dataSourceName, Lists.newArrayList(tableName));
         } else {
-            schemaMetaData.put(tableName, tableMetaData);
+            schemaMetaData.add(tableName);
         }
     }
 }
diff --git a/...mon/src/main/java/org/apache/shardingsphere/infra/metadata/schema/RuleSchemaMetaData.java b/...mon/src/main/java/org/apache/shardingsphere/infra/metadata/schema/RuleSchemaMetaData.java
@@ -20,6 +20,7 @@
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.sql.parser.binder.metadata.schema.SchemaMetaData;
+import org.apache.shardingsphere.sql.parser.binder.metadata.table.TableMetaData;
 
 import java.util.Collection;
 import java.util.LinkedList;
@@ -34,7 +35,7 @@ public final class RuleSchemaMetaData {
 
     private final SchemaMetaData configuredSchemaMetaData;
 
-    private final Map<String, SchemaMetaData> unconfiguredSchemaMetaDataMap;
+    private final Map<String, Collection<String>> unconfiguredSchemaMetaDataMap;
 
     /**
      * Get schema meta data.
@@ -43,7 +44,7 @@ public final class RuleSchemaMetaData {
      */
     public SchemaMetaData getSchemaMetaData() {
         SchemaMetaData result = new SchemaMetaData();
-        unconfiguredSchemaMetaDataMap.values().forEach(result::merge);
+        unconfiguredSchemaMetaDataMap.values().stream().flatMap(tableNames -> tableNames.stream()).forEach(tableName -> result.put(tableName, new TableMetaData()));
         result.merge(configuredSchemaMetaData);
         return result;
     }
@@ -55,9 +56,7 @@ public SchemaMetaData getSchemaMetaData() {
      */
     public Collection<String> getAllTableNames() {
         Collection<String> result = new LinkedList<>(configuredSchemaMetaData.getAllTableNames());
-        for (SchemaMetaData each : unconfiguredSchemaMetaDataMap.values()) {
-            result.addAll(each.getAllTableNames());
-        }
+        unconfiguredSchemaMetaDataMap.values().forEach(result::addAll);
         return result;
     }
 }
diff --git a/...c/main/java/org/apache/shardingsphere/infra/metadata/schema/RuleSchemaMetaDataLoader.java b/...c/main/java/org/apache/shardingsphere/infra/metadata/schema/RuleSchemaMetaDataLoader.java
@@ -77,7 +77,7 @@ public RuleSchemaMetaData load(final DatabaseType databaseType, final Map<String
             configuredSchemaMetaData.merge(schemaMetaData);
         }
         decorate(configuredSchemaMetaData);
-        Map<String, SchemaMetaData> unConfiguredSchemaMetaDataMap = loadUnConfiguredSchemaMetaData(databaseType, dataSourceMap, excludedTableNames);
+        Map<String, Collection<String>> unConfiguredSchemaMetaDataMap = loadUnConfiguredSchemaMetaData(databaseType, dataSourceMap, excludedTableNames);
         return new RuleSchemaMetaData(configuredSchemaMetaData, unConfiguredSchemaMetaDataMap);
     }
 
@@ -136,13 +136,13 @@ public Optional<TableMetaData> load(final DatabaseType databaseType, final DataS
         return load(databaseType, dataSourceMap, tableName, props);
     }
 
-    private Map<String, SchemaMetaData> loadUnConfiguredSchemaMetaData(final DatabaseType databaseType, final Map<String, DataSource> dataSourceMap,
+    private Map<String, Collection<String>> loadUnConfiguredSchemaMetaData(final DatabaseType databaseType, final Map<String, DataSource> dataSourceMap,
                                                                        final Collection<String> excludedTableNames) throws SQLException {
-        Map<String, SchemaMetaData> result = new HashMap<>(dataSourceMap.size(), 1);
+        Map<String, Collection<String>> result = new HashMap<>(dataSourceMap.size(), 1);
         for (Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
-            SchemaMetaData schemaMetaData = SchemaMetaDataLoader.load(entry.getValue(), databaseType.getName(), excludedTableNames);
-            if (!schemaMetaData.getAllTableNames().isEmpty()) {
-                result.put(entry.getKey(), schemaMetaData);
+            Collection<String> tableNames = SchemaMetaDataLoader.loadUnconfiguredTableNames(entry.getValue(), databaseType.getName(), excludedTableNames);
+            if (!tableNames.isEmpty()) {
+                result.put(entry.getKey(), tableNames);
             }
         }
         return result;