refactor api: actual tables -> actual data nodes 1st version

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/api/config/TableRuleConfiguration.java

@@ -45,8 +45,6 @@ public class TableRuleConfiguration {
     
     private String actualTables;
     
-    private String dataSourceNames;
-    
     private ShardingStrategyConfiguration databaseShardingStrategyConfig;
     
     private ShardingStrategyConfiguration tableShardingStrategyConfig;
@@ -64,10 +62,9 @@ public class TableRuleConfiguration {
     public TableRule build(final Map<String, DataSource> dataSourceMap) {
         Preconditions.checkNotNull(logicTable, "Logic table cannot be null.");
         List<String> actualTables = new InlineExpressionParser(this.actualTables).evaluate();
-        List<String> dataSourceNames = new InlineExpressionParser(this.dataSourceNames).evaluate();
         ShardingStrategy databaseShardingStrategy = null == databaseShardingStrategyConfig ? null : databaseShardingStrategyConfig.build();
         ShardingStrategy tableShardingStrategy = null == tableShardingStrategyConfig ? null : tableShardingStrategyConfig.build();
         KeyGenerator keyGenerator = !Strings.isNullOrEmpty(keyGeneratorColumnName) && !Strings.isNullOrEmpty(keyGeneratorClass) ? KeyGeneratorFactory.newInstance(keyGeneratorClass) : null;
-        return new TableRule(logicTable, actualTables, dataSourceNames, dataSourceMap, databaseShardingStrategy, tableShardingStrategy, keyGeneratorColumnName, keyGenerator);
+        return new TableRule(logicTable, actualTables, dataSourceMap, databaseShardingStrategy, tableShardingStrategy, keyGeneratorColumnName, keyGenerator);
     }
 }

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/rule/ShardingRule.java

@@ -128,7 +128,7 @@ public final class ShardingRule {
         config.setLogicTable(logicTableName);
         config.setDatabaseShardingStrategyConfig(new NoneShardingStrategyConfiguration());
         config.setTableShardingStrategyConfig(new NoneShardingStrategyConfiguration());
-        return new TableRule(logicTableName, null, null, defaultDataSourceMap, null, null, null, null);
+        return new TableRule(logicTableName, null, defaultDataSourceMap, null, null, null, null);
     }
     
     /**

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/rule/TableRule.java

@@ -17,16 +17,16 @@
 
 package io.shardingjdbc.core.rule;
 
+import com.google.common.base.Preconditions;
 import io.shardingjdbc.core.keygen.KeyGenerator;
 import io.shardingjdbc.core.routing.strategy.ShardingStrategy;
 import lombok.Getter;
 import lombok.ToString;
 
 import javax.sql.DataSource;
-import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.LinkedHashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -51,43 +51,34 @@ public final class TableRule {
     
     private final KeyGenerator keyGenerator;
     
-    public TableRule(final String logicTable, final List<String> actualTables, final List<String> actualDataSources, final Map<String, DataSource> dataSourceMap,
+    public TableRule(final String logicTable, final List<String> actualTables, final Map<String, DataSource> dataSourceMap,
                      final ShardingStrategy databaseShardingStrategy, final ShardingStrategy tableShardingStrategy, final String generateKeyColumn, final KeyGenerator keyGenerator) {
         this.logicTable = logicTable;
-        if (null == actualTables || actualTables.isEmpty()) {
-            actualDataNodes = generateDataNodes(Collections.singletonList(logicTable), dataSourceMap, actualDataSources);
-        } else {
-            actualDataNodes = generateDataNodes(actualTables, dataSourceMap, actualDataSources);
-        }
+        this.actualDataNodes = null == actualTables || actualTables.isEmpty() ? generateDataNodes(logicTable, dataSourceMap) : generateDataNodes(actualTables, dataSourceMap);
         this.databaseShardingStrategy = databaseShardingStrategy;
         this.tableShardingStrategy = tableShardingStrategy;
         this.generateKeyColumn = generateKeyColumn;
         this.keyGenerator = keyGenerator;
     }
     
-    private List<DataNode> generateDataNodes(final List<String> actualTables, final Map<String, DataSource> dataSourceMap, final Collection<String> actualDataSourceNames) {
-        Collection<String> dataSourceNames = getDataSourceNames(dataSourceMap, actualDataSourceNames);
-        List<DataNode> result = new ArrayList<>(actualTables.size() * (dataSourceNames.isEmpty() ? 1 : dataSourceNames.size()));
-        for (String actualTable : actualTables) {
-            if (DataNode.isValidDataNode(actualTable)) {
-                result.add(new DataNode(actualTable));
-            } else {
-                for (String dataSourceName : dataSourceNames) {
-                    result.add(new DataNode(dataSourceName, actualTable));
-                }
-            }
+    private List<DataNode> generateDataNodes(final String logicTable, final Map<String, DataSource> dataSourceMap) {
+        List<DataNode> result = new LinkedList<>();
+        for (String each : dataSourceMap.keySet()) {
+            result.add(new DataNode(each, logicTable));
         }
         return result;
     }
     
-    private Collection<String> getDataSourceNames(final Map<String, DataSource> dataSourceMap, final Collection<String> actualDataSourceNames) {
-        if (null == dataSourceMap) {
-            return Collections.emptyList();
-        }
-        if (null == actualDataSourceNames || actualDataSourceNames.isEmpty()) {
-            return dataSourceMap.keySet();
+    private List<DataNode> generateDataNodes(final List<String> actualTables, final Map<String, DataSource> dataSourceMap) {
+        List<DataNode> result = new LinkedList<>();
+        for (String actualTable : actualTables) {
+            Preconditions.checkArgument(DataNode.isValidDataNode(actualTable), String.format("Invalid format for actual data nodes: '%s'", actualTable));
+            DataNode dataNode = new DataNode(actualTable);
+            Preconditions.checkArgument(dataSourceMap.containsKey(dataNode.getDataSourceName()), 
+                    String.format("Cannot find data source name in sharding rule, invalid actual data node is: '%s'", actualTable));
+            result.add(dataNode);
         }
-        return actualDataSourceNames;
+        return result;
     }
     
     /**

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/api/ShardingDataSourceFactoryTest.java

@@ -71,7 +71,7 @@ public final class ShardingDataSourceFactoryTest {
         ShardingRuleConfiguration result = new ShardingRuleConfiguration();
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("table_0, table_1, table_2");
+        tableRuleConfig.setActualTables("ds.table_${0..2}");
         result.getTableRuleConfigs().add(tableRuleConfig);
         return result;
     }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/api/fixture/ShardingRuleMockBuilder.java

@@ -77,7 +77,7 @@ public class ShardingRuleMockBuilder {
             public TableRuleConfiguration apply(final String input) {
                 TableRuleConfiguration result = new TableRuleConfiguration();
                 result.setLogicTable(input);
-                result.setActualTables(input);
+                result.setActualTables("db0." + input + ",db1." + input);
                 result.setKeyGeneratorColumnName(generateKeyColumnsMap.get(input));
                 return result;
             }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/common/base/AbstractSQLAssertTest.java

@@ -78,8 +78,7 @@ public abstract class AbstractSQLAssertTest extends AbstractSQLTest {
     
     protected File getExpectedFile(final String expected) {
         String strategyName = getShardingStrategy().name();
-        String expectedFile = null == expected ? "integrate/dataset/EmptyTable.xml"
-                : String.format("integrate/dataset/sharding/%s/expect/" + expected, strategyName, strategyName);
+        String expectedFile = null == expected ? "integrate/dataset/EmptyTable.xml" : String.format("integrate/dataset/sharding/%s/expect/" + expected, strategyName, strategyName);
         URL url = AbstractSQLAssertTest.class.getClassLoader().getResource(expectedFile);
         if (null == url) {
             throw new RuntimeException("Wrong expected file:" + expectedFile);

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/common/base/AbstractShardingJDBCDatabaseAndTableTest.java

@@ -17,15 +17,16 @@
 
 package io.shardingjdbc.core.common.base;
 
+import com.google.common.base.Joiner;
 import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
 import io.shardingjdbc.core.api.config.TableRuleConfiguration;
 import io.shardingjdbc.core.api.config.strategy.StandardShardingStrategyConfiguration;
-import io.shardingjdbc.core.rule.ShardingRule;
 import io.shardingjdbc.core.constant.DatabaseType;
 import io.shardingjdbc.core.jdbc.core.datasource.ShardingDataSource;
 import io.shardingjdbc.core.keygen.fixture.IncrementKeyGenerator;
 import io.shardingjdbc.core.routing.fixture.PreciseOrderShardingAlgorithm;
 import io.shardingjdbc.core.routing.fixture.RangeOrderShardingAlgorithm;
+import io.shardingjdbc.core.rule.ShardingRule;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.runner.RunWith;
@@ -36,6 +37,7 @@ import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -53,15 +55,23 @@ public abstract class AbstractShardingJDBCDatabaseAndTableTest extends AbstractS
     @Before
     public void initShardingDataSources() throws SQLException {
         Map<DatabaseType, Map<String, DataSource>> dataSourceMap = createDataSourceMap();
-        for (Map.Entry<DatabaseType, Map<String, DataSource>> each : dataSourceMap.entrySet()) {
-            ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
+        for (Map.Entry<DatabaseType, Map<String, DataSource>> entry : dataSourceMap.entrySet()) {
+            final ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
             TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
             orderTableRuleConfig.setLogicTable("t_order");
-            orderTableRuleConfig.setActualTables("t_order_0, t_order_1");
+            List<String> orderActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : entry.getValue().keySet()) {
+                orderActualDataNodes.add(dataSourceName + ".t_order_${0..1}");
+            }
+            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
-            orderItemTableRuleConfig.setActualTables("t_order_item_0, t_order_item_1");
+            List<String> orderItemActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : entry.getValue().keySet()) {
+                orderItemActualDataNodes.add(dataSourceName + ".t_order_item_${0..1}");
+            }
+            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(orderItemActualDataNodes));
             orderItemTableRuleConfig.setKeyGeneratorColumnName("item_id");
             orderItemTableRuleConfig.setKeyGeneratorClass(IncrementKeyGenerator.class.getName());
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
@@ -73,8 +83,8 @@ public abstract class AbstractShardingJDBCDatabaseAndTableTest extends AbstractS
                     new StandardShardingStrategyConfiguration("user_id", PreciseOrderShardingAlgorithm.class.getName(), RangeOrderShardingAlgorithm.class.getName()));
             shardingRuleConfig.setDefaultTableShardingStrategyConfig(
                     new StandardShardingStrategyConfiguration("order_id", PreciseOrderShardingAlgorithm.class.getName(), RangeOrderShardingAlgorithm.class.getName()));
-            ShardingRule shardingRule = shardingRuleConfig.build(each.getValue());
-            shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRule));
+            ShardingRule shardingRule = shardingRuleConfig.build(entry.getValue());
+            shardingDataSources.put(entry.getKey(), new ShardingDataSource(shardingRule));
         }
     }
     

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/ShardingDatabaseAndTableTest.java

@@ -17,6 +17,7 @@
 
 package io.shardingjdbc.core.integrate.type.sharding;
 
+import com.google.common.base.Joiner;
 import io.shardingjdbc.core.common.base.AbstractSQLAssertTest;
 import io.shardingjdbc.core.common.env.ShardingTestStrategy;
 import io.shardingjdbc.core.integrate.fixture.PreciseModuloDatabaseShardingAlgorithm;
@@ -35,6 +36,7 @@ import javax.sql.DataSource;
 import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -75,16 +77,24 @@ public class ShardingDatabaseAndTableTest extends AbstractSQLAssertTest {
         }
         isShutdown = false;
         Map<DatabaseType, Map<String, DataSource>> dataSourceMap = createDataSourceMap();
-        for (Map.Entry<DatabaseType, Map<String, DataSource>> each : dataSourceMap.entrySet()) {
+        for (Map.Entry<DatabaseType, Map<String, DataSource>> entry : dataSourceMap.entrySet()) {
             ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
             shardingRuleConfig.setDefaultDataSourceName("dataSource_dbtbl_0");
             TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
             orderTableRuleConfig.setLogicTable("t_order");
-            orderTableRuleConfig.setActualTables("t_order_${0..9}");
+            List<String> orderActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : entry.getValue().keySet()) {
+                orderActualDataNodes.add(dataSourceName + ".t_order_${0..9}");
+            }
+            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
-            orderItemTableRuleConfig.setActualTables("t_order_item_${0..9}");
+            List<String> orderItemActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : entry.getValue().keySet()) {
+                orderItemActualDataNodes.add(dataSourceName + ".t_order_item_${0..9}");
+            }
+            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(orderItemActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             TableRuleConfiguration configTableRuleConfig = new TableRuleConfiguration();
             configTableRuleConfig.setLogicTable("t_config");
@@ -94,7 +104,7 @@ public class ShardingDatabaseAndTableTest extends AbstractSQLAssertTest {
                     new StandardShardingStrategyConfiguration("user_id", PreciseModuloDatabaseShardingAlgorithm.class.getName(), RangeModuloDatabaseShardingAlgorithm.class.getName()));
             shardingRuleConfig.setDefaultTableShardingStrategyConfig(
                     new StandardShardingStrategyConfiguration("order_id", PreciseModuloTableShardingAlgorithm.class.getName(), RangeModuloTableShardingAlgorithm.class.getName()));
-            shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRuleConfig.build(each.getValue())));
+            shardingDataSources.put(entry.getKey(), new ShardingDataSource(shardingRuleConfig.build(entry.getValue())));
         }
         return shardingDataSources;
     }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/ShardingMasterSlaveTest.java

@@ -17,19 +17,20 @@
 
 package io.shardingjdbc.core.integrate.type.sharding;
 
-import io.shardingjdbc.core.common.base.AbstractSQLAssertTest;
-import io.shardingjdbc.core.common.env.ShardingTestStrategy;
-import io.shardingjdbc.core.integrate.fixture.PreciseModuloDatabaseShardingAlgorithm;
-import io.shardingjdbc.core.integrate.fixture.RangeModuloDatabaseShardingAlgorithm;
-import io.shardingjdbc.core.integrate.jaxb.SQLShardingRule;
+import com.google.common.base.Joiner;
 import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
 import io.shardingjdbc.core.api.config.TableRuleConfiguration;
 import io.shardingjdbc.core.api.config.strategy.StandardShardingStrategyConfiguration;
-import io.shardingjdbc.core.rule.MasterSlaveRule;
+import io.shardingjdbc.core.common.base.AbstractSQLAssertTest;
+import io.shardingjdbc.core.common.env.ShardingTestStrategy;
 import io.shardingjdbc.core.constant.DatabaseType;
 import io.shardingjdbc.core.hint.HintManagerHolder;
+import io.shardingjdbc.core.integrate.fixture.PreciseModuloDatabaseShardingAlgorithm;
+import io.shardingjdbc.core.integrate.fixture.RangeModuloDatabaseShardingAlgorithm;
+import io.shardingjdbc.core.integrate.jaxb.SQLShardingRule;
 import io.shardingjdbc.core.jdbc.core.datasource.MasterSlaveDataSource;
 import io.shardingjdbc.core.jdbc.core.datasource.ShardingDataSource;
+import io.shardingjdbc.core.rule.MasterSlaveRule;
 import org.junit.After;
 import org.junit.AfterClass;
 
@@ -37,6 +38,7 @@ import javax.sql.DataSource;
 import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -88,29 +90,38 @@ public class ShardingMasterSlaveTest extends AbstractSQLAssertTest {
         }
         isShutdown = false;
         Map<DatabaseType, Map<String, DataSource>> dataSourceMap = createDataSourceMap();
-        for (Entry<DatabaseType, Map<String, DataSource>> each : dataSourceMap.entrySet()) {
-            ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
+        for (Entry<DatabaseType, Map<String, DataSource>> entry : dataSourceMap.entrySet()) {
+            Map<String, DataSource> masterSlaveDataSourceMap = getMasterSlaveDataSourceMap(entry);
+            final ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
             TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
             orderTableRuleConfig.setLogicTable("t_order");
-            orderTableRuleConfig.setActualTables("t_order_${0..9}");
+            List<String> orderActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : masterSlaveDataSourceMap.keySet()) {
+                orderActualDataNodes.add(dataSourceName + ".t_order_${0..9}");
+            }
+            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
-            orderItemTableRuleConfig.setActualTables("t_order_item_${0..9}");
+            List<String> itemOrderActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : masterSlaveDataSourceMap.keySet()) {
+                itemOrderActualDataNodes.add(dataSourceName + ".t_order_item_${0..9}");
+            }
+            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(itemOrderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             TableRuleConfiguration configTableRuleConfig = new TableRuleConfiguration();
             configTableRuleConfig.setLogicTable("t_config");
-            configTableRuleConfig.setActualTables("t_config");
             shardingRuleConfig.getTableRuleConfigs().add(configTableRuleConfig);
             shardingRuleConfig.setDefaultTableShardingStrategyConfig(
                     new StandardShardingStrategyConfiguration("t_order_item", PreciseModuloDatabaseShardingAlgorithm.class.getName(), RangeModuloDatabaseShardingAlgorithm.class.getName()));
             shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(
                     new StandardShardingStrategyConfiguration("user_id", PreciseModuloDatabaseShardingAlgorithm.class.getName(), RangeModuloDatabaseShardingAlgorithm.class.getName()));
-            shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRuleConfig.build(getMasterSlaveDataSourceMap(each))));
+            shardingDataSources.put(entry.getKey(), new ShardingDataSource(shardingRuleConfig.build(masterSlaveDataSourceMap)));
         }
         return shardingDataSources;
     }
     
+    // TODO use MasterSlaveRuleConfiguration to generate data source map
     private Map<String, DataSource> getMasterSlaveDataSourceMap(final Entry<DatabaseType, Map<String, DataSource>> each) throws SQLException {
         Map<String, DataSource> masterSlaveDataSourceMap = each.getValue();
         MasterSlaveDataSource masterSlaveDs0 = getMasterSlaveDataSource(masterSlaveDataSourceMap, "ms_0", "dataSource_master_0", "dataSource_slave_0");

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/ShardingTableOnlyTest.java

@@ -17,6 +17,7 @@
 
 package io.shardingjdbc.core.integrate.type.sharding;
 
+import com.google.common.base.Joiner;
 import io.shardingjdbc.core.common.base.AbstractSQLAssertTest;
 import io.shardingjdbc.core.common.env.ShardingTestStrategy;
 import io.shardingjdbc.core.integrate.fixture.PreciseModuloTableShardingAlgorithm;
@@ -38,6 +39,7 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -65,22 +67,30 @@ public class ShardingTableOnlyTest extends AbstractSQLAssertTest {
             return shardingDataSources;
         }
         Map<DatabaseType, Map<String, DataSource>> dataSourceMap = createDataSourceMap();
-        for (Map.Entry<DatabaseType, Map<String, DataSource>> each : dataSourceMap.entrySet()) {
+        for (Map.Entry<DatabaseType, Map<String, DataSource>> entry : dataSourceMap.entrySet()) {
             ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
             TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
             orderTableRuleConfig.setLogicTable("t_order");
-            orderTableRuleConfig.setActualTables("t_order_${0..9}");
+            List<String> orderActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : entry.getValue().keySet()) {
+                orderActualDataNodes.add(dataSourceName + ".t_order_${0..9}");
+            }
+            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
-            orderItemTableRuleConfig.setActualTables("t_order_item_${0..9}");
+            List<String> orderItemActualDataNodes = new LinkedList<>();
+            for (String dataSourceName : entry.getValue().keySet()) {
+                orderItemActualDataNodes.add(dataSourceName + ".t_order_item_${0..9}");
+            }
+            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(orderItemActualDataNodes));
             orderItemTableRuleConfig.setKeyGeneratorClass("item_id");
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");
             shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new NoneShardingStrategyConfiguration());
             shardingRuleConfig.setDefaultTableShardingStrategyConfig(
                     new StandardShardingStrategyConfiguration("order_id", PreciseModuloTableShardingAlgorithm.class.getName(), RangeModuloTableShardingAlgorithm.class.getName()));
-            shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRuleConfig.build(each.getValue())));
+            shardingDataSources.put(entry.getKey(), new ShardingDataSource(shardingRuleConfig.build(entry.getValue())));
         }
         return shardingDataSources;
     }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/jdbc/core/datasource/ShardingDataSourceTest.java

@@ -17,6 +17,7 @@
 
 package io.shardingjdbc.core.jdbc.core.datasource;
 
+import com.google.common.base.Joiner;
 import io.shardingjdbc.core.api.MasterSlaveDataSourceFactory;
 import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
@@ -33,6 +34,8 @@ import java.sql.DatabaseMetaData;
 import java.sql.SQLException;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 
@@ -147,7 +150,7 @@ public final class ShardingDataSourceTest {
         DataSource newDataSource = mockDataSource("H2");
         Map<String, DataSource> newDataSourceMap = new HashMap<>(1, 1);
         newDataSourceMap.put("ds", newDataSource);
-        shardingDataSource.renew(createShardingRuleConfig().build(newDataSourceMap), new Properties());
+        shardingDataSource.renew(createShardingRuleConfig(newDataSourceMap).build(newDataSourceMap), new Properties());
         assertThat(originExecutorEngine, is(getExecutorEngine(shardingDataSource)));
     }
     
@@ -163,7 +166,7 @@ public final class ShardingDataSourceTest {
         newDataSourceMap.put("ds", newDataSource);
         Properties props = new Properties();
         props.setProperty(ShardingPropertiesConstant.EXECUTOR_SIZE.getKey(), "100");
-        shardingDataSource.renew(createShardingRuleConfig().build(newDataSourceMap), props);
+        shardingDataSource.renew(createShardingRuleConfig(newDataSourceMap).build(newDataSourceMap), props);
         assertThat(originExecutorEngine, not(getExecutorEngine(shardingDataSource)));
     }
     
@@ -176,18 +179,22 @@ public final class ShardingDataSourceTest {
         DataSource newDataSource = mockDataSource("MySQL");
         Map<String, DataSource> newDataSourceMap = new HashMap<>(1, 1);
         newDataSourceMap.put("ds", newDataSource);
-        shardingDataSource.renew(createShardingRuleConfig().build(newDataSourceMap), new Properties());
+        shardingDataSource.renew(createShardingRuleConfig(newDataSourceMap).build(newDataSourceMap), new Properties());
     }
     
     private ShardingDataSource createShardingDataSource(final Map<String, DataSource> dataSourceMap) throws SQLException {
-        return new ShardingDataSource(createShardingRuleConfig().build(dataSourceMap));
+        return new ShardingDataSource(createShardingRuleConfig(dataSourceMap).build(dataSourceMap));
     }
     
-    private ShardingRuleConfiguration createShardingRuleConfig() {
-        ShardingRuleConfiguration result = new ShardingRuleConfiguration();
+    private ShardingRuleConfiguration createShardingRuleConfig(final Map<String, DataSource> dataSourceMap) {
+        final ShardingRuleConfiguration result = new ShardingRuleConfiguration();
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("table_0, table_1, table_2");
+        List<String> orderActualDataNodes = new LinkedList<>();
+        for (String each : dataSourceMap.keySet()) {
+            orderActualDataNodes.add(each + ".table_${0..2}");
+        }
+        tableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
         result.getTableRuleConfigs().add(tableRuleConfig);
         return result;
     }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/parsing/SQLParsingEngineTest.java

@@ -68,13 +68,11 @@ public final class SQLParsingEngineTest extends AbstractBaseParseSQLTest {
     private ShardingRule buildShardingRule() throws SQLException {
         TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
         orderTableRuleConfig.setLogicTable("t_order");
-        orderTableRuleConfig.setActualTables("t_order");
-        orderTableRuleConfig.setDataSourceNames("db0, db1");
+        orderTableRuleConfig.setActualTables("db0.t_order,db1.t_order");
         orderTableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id, order_id", TestComplexKeysShardingAlgorithm.class.getName()));
         TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
         orderItemTableRuleConfig.setLogicTable("t_order_item");
-        orderItemTableRuleConfig.setActualTables("t_order_item");
-        orderItemTableRuleConfig.setDataSourceNames("db0, db1");
+        orderItemTableRuleConfig.setActualTables("db0.t_order_item,db1.t_order_item");
         orderItemTableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id, order_id, item_id", TestComplexKeysShardingAlgorithm.class.getName()));
         return new ShardingRuleMockBuilder().addTableRuleConfig(orderTableRuleConfig).addTableRuleConfig(orderItemTableRuleConfig)
                 .addShardingColumns("user_id").addShardingColumns("order_id").addShardingColumns("item_id").addGenerateKeyColumn("t_order_item", "item_id").build();

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/parsing/parser/sql/AbstractStatementParserTest.java

@@ -48,7 +48,7 @@ public abstract class AbstractStatementParserTest {
         }
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("TABLE_XXX");
-        tableRuleConfig.setActualTables("table_0, table_1, table_2");
+        tableRuleConfig.setActualTables("ds.table_${0..2}");
         tableRuleConfig.setTableShardingStrategyConfig(
                 new ComplexShardingStrategyConfiguration("field1, field2, field3, field4, field5, field6, field7", TestComplexKeysShardingAlgorithm.class.getName()));
         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/parsing/parser/sql/InsertStatementParserTest.java

@@ -110,7 +110,7 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
         final ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("TABLE_XXX");
-        tableRuleConfig.setActualTables("table_${0..2}");
+        tableRuleConfig.setActualTables("ds.table_${0..2}");
         tableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("field1", TestComplexKeysShardingAlgorithm.class.getName()));
         tableRuleConfig.setKeyGeneratorColumnName("field2");
         shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfig);

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/rule/ShardingRuleTest.java

@@ -284,14 +284,14 @@ public final class ShardingRuleTest {
     private TableRuleConfiguration createTableRuleConfig() {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
-        result.setActualTables("table_0, table_1, table_2");
+        result.setActualTables("ds${0..1}.table_${0..2}");
         return result;
     }
     
     private TableRuleConfiguration createTableRuleConfigWithDatabaseShardingStrategy(final ShardingStrategyConfiguration strategyConfig) {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
-        result.setActualTables("table_0, table_1, table_2");
+        result.setActualTables("ds${0..1}.table_${0..2}");
         result.setDatabaseShardingStrategyConfig(strategyConfig);
         return result;
     }
@@ -299,7 +299,7 @@ public final class ShardingRuleTest {
     private TableRuleConfiguration createTableRuleConfigWithTableShardingStrategy(final ShardingStrategyConfiguration strategyConfig) {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
-        result.setActualTables("table_0, table_1, table_2");
+        result.setActualTables("ds${0..1}.table_${0..2}");
         result.setTableShardingStrategyConfig(strategyConfig);
         return result;
     }
@@ -307,14 +307,14 @@ public final class ShardingRuleTest {
     private TableRuleConfiguration createSubTableRuleConfig() {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("subLogicTable");
-        result.setActualTables("sub_table_0, sub_table_1, sub_table_2");
+        result.setActualTables("ds${0..1}.sub_table_${0..2}");
         return result;
     }
     
     private TableRuleConfiguration createTableRuleConfigWithAllStrategies() {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
-        result.setActualTables("table_0, table_1, table_2");
+        result.setActualTables("ds${0..1}.table_${0..2}");
         result.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("column", TestPreciseShardingAlgorithm.class.getName()));
         result.setTableShardingStrategyConfig(new NoneShardingStrategyConfiguration());
         return result;
@@ -323,7 +323,7 @@ public final class ShardingRuleTest {
     private TableRuleConfiguration createTableRuleConfigWithTableStrategies() {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
-        result.setActualTables("table_0, table_1, table_2");
+        result.setActualTables("ds${0..1}.table_${0..2}");
         result.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("column", TestPreciseShardingAlgorithm.class.getName()));
         return result;
     }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/rule/TableRuleTest.java

@@ -42,7 +42,7 @@ public final class TableRuleTest {
     public void assertTableRuleWithoutDataNode() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("table_0, table_1, table_2");
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
         assertNull(actual.getDatabaseShardingStrategy());
@@ -53,7 +53,7 @@ public final class TableRuleTest {
     public void assertTableRuleWithDatabaseShardingStrategyWithoutDataNode() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("table_0, table_1, table_2");
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
         tableRuleConfig.setDatabaseShardingStrategyConfig(new NoneShardingStrategyConfiguration());
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
@@ -65,7 +65,7 @@ public final class TableRuleTest {
     public void assertTableRuleWithTableShardingStrategyWithoutDataNode() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("table_0, table_1, table_2");
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
         tableRuleConfig.setTableShardingStrategyConfig(new NoneShardingStrategyConfiguration());
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
@@ -77,8 +77,8 @@ public final class TableRuleTest {
     public void assertTableRuleWithDataNodeString() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds0.table_0, ds0.table_1, ds0.table_2, ds1.table_0, ds1.table_1, ds1.table_2");
-        TableRule actual = tableRuleConfig.build(null);
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
         assertNull(actual.getDatabaseShardingStrategy());
         assertNull(actual.getTableShardingStrategy());
@@ -88,8 +88,7 @@ public final class TableRuleTest {
     public void assertTableRuleWithDataSourceNames() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("table_0, table_1, table_2");
-        tableRuleConfig.setDataSourceNames("ds0, ds1");
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
         assertNull(actual.getDatabaseShardingStrategy());
@@ -110,8 +109,8 @@ public final class TableRuleTest {
     public void assertGetActualDatasourceNames() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds0.table_0, ds0.table_1, ds0.table_2, ds1.table_0, ds1.table_1, ds1.table_2");
-        TableRule actual = tableRuleConfig.build(null);
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertThat(actual.getActualDatasourceNames(), is((Collection<String>) Sets.newLinkedHashSet(Arrays.asList("ds0", "ds1"))));
     }
     
@@ -119,8 +118,8 @@ public final class TableRuleTest {
     public void assertGetActualTableNames() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds0.table_0, ds0.table_1, ds0.table_2, ds1.table_0, ds1.table_1, ds1.table_2");
-        TableRule actual = tableRuleConfig.build(null);
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertThat(actual.getActualTableNames("ds1"), is((Collection<String>) Sets.newLinkedHashSet(Arrays.asList("table_0", "table_1", "table_2"))));
     }
     
@@ -128,8 +127,8 @@ public final class TableRuleTest {
     public void assertFindActualTableIndex() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds0.table_0, ds0.table_1, ds0.table_2, ds1.table_0, ds1.table_1, ds1.table_2");
-        TableRule actual = tableRuleConfig.build(null);
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertThat(actual.findActualTableIndex("ds1", "table_1"), is(4));
     }
     
@@ -137,8 +136,8 @@ public final class TableRuleTest {
     public void assertFindActualTableIndexForNotFound() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds0.table_0, ds0.table_1, ds0.table_2, ds1.table_0, ds1.table_1, ds1.table_2");
-        TableRule actual = tableRuleConfig.build(null);
+        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertThat(actual.findActualTableIndex("ds2", "table_2"), is(-1));
     }
     

sharding-jdbc-core/src/test/resources/yaml/config/config-all.yaml

@@ -18,11 +18,10 @@ defaultKeyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerato
     
 tables:
   config:
-    actualTables: config_${0..1}
-    dataSourceNames: config
-    
+    actualTables: db${0..1}.config_${0..1}
+
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: order_id
@@ -32,7 +31,7 @@ tables:
         shardingColumn: id
         algorithmInlineExpression: t_order_${id % 2}
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db${0..1}.t_order_item_${0..1}
     keyGeneratorColumnName: order_item_id
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.DecrementKeyGenerator
     #绑定表中其余的表的策略与第一张表的策略相同

sharding-jdbc-core/src/test/resources/yaml/config/config-bindingError.yaml

 tables:
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: ds.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: order_id
@@ -10,7 +10,7 @@ tables:
         shardingColumn: id
         algorithmInlineExpression: t_order_${id % 2}
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: ds.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/config/config-min.yaml

 tables:
   config:
-    actualTables: config_${0..1}
+    actualTables: ds.config_${0..1}

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding/configWithDataSourceWithProps.yaml

@@ -14,10 +14,10 @@ dataSources:
     
 tables:
   config:
-    actualTables: t_config
+    actualTables: db${0..1}.t_config
   
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -30,7 +30,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
   
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding/configWithDataSourceWithoutProps.yaml

@@ -14,10 +14,10 @@ dataSources:
     
 tables:
   config:
-    actualTables: t_config
+    actualTables: db${0..1}.t_config
 
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -30,7 +30,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
   
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding/configWithoutDataSourceWithProps.yaml

 tables:
   config:
-    actualTables: t_config
+    actualTables: db${0..1}.t_config
 
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -16,7 +16,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
 
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding/configWithoutDataSourceWithoutProps.yaml

 tables:
   config:
-    actualTables: t_config
+    actualTables: db${0..1}.t_config
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -15,7 +15,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
   
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding_ms/configWithDataSourceWithProps.yaml

@@ -26,10 +26,10 @@ dataSources:
     
 tables:
   config:
-    actualTables: t_config
+    actualTables: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db_ms_${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -42,7 +42,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
   
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db_ms_${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding_ms/configWithDataSourceWithoutProps.yaml

@@ -26,10 +26,10 @@ dataSources:
     
 tables:
   config:
-    actualTables: t_config
+    actualTables: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: t_order_${0..2}
+    actualTables: db_ms_${0..1}.t_order_${0..2}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -42,7 +42,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
   
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db_ms_${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding_ms/configWithoutDataSourceWithProps.yaml

 tables:
   config:
-    actualTables: t_config
+    actualTables: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db_ms_${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -16,7 +16,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
   
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db_ms_${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-core/src/test/resources/yaml/integrate/sharding_ms/configWithoutDataSourceWithoutProps.yaml

 tables:
   config:
-    actualTables: t_config
+    actualTables: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: t_order_${0..1}
+    actualTables: db_ms_${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: user_id
@@ -16,7 +16,7 @@ tables:
     keyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerator
 
   t_order_item:
-    actualTables: t_order_item_${0..1}
+    actualTables: db_ms_${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/io/shardingjdbc/spring/AllSpringTests.java

@@ -22,7 +22,6 @@ import io.shardingjdbc.spring.cases.WithNamespaceAlgorithmExpressionTest;
 import io.shardingjdbc.spring.cases.WithNamespaceBindingTablesTest;
 import io.shardingjdbc.spring.cases.WithNamespaceDefaultStrategyTest;
 import io.shardingjdbc.spring.cases.WithNamespaceDifferentTablesTest;
-import io.shardingjdbc.spring.cases.WithNamespaceForIndicatedDataSourceNamesTest;
 import io.shardingjdbc.spring.cases.WithNamespaceForMasterSlaveWithDefaultStrategyTest;
 import io.shardingjdbc.spring.cases.WithNamespaceForMasterSlaveWithStrategyRefTest;
 import io.shardingjdbc.spring.cases.WithNamespaceForMasterSlaveWithStrategyTypeTest;
@@ -38,7 +37,6 @@ import org.junit.runners.Suite.SuiteClasses;
         WithNamespaceDefaultStrategyTest.class, 
         WithNamespaceBindingTablesTest.class, 
         WithNamespaceDifferentTablesTest.class,
-        WithNamespaceForIndicatedDataSourceNamesTest.class,
         WithNamespaceForMasterSlaveWithDefaultStrategyTest.class,
         WithNamespaceForMasterSlaveWithStrategyRefTest.class,
         WithNamespaceForMasterSlaveWithStrategyTypeTest.class,

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/java/io/shardingjdbc/spring/cases/WithNamespaceForIndicatedDataSourceNamesTest.java

-/*
- * Copyright 1999-2015 dangdang.com.
- * <p>
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * </p>
- */
-
-package io.shardingjdbc.spring.cases;
-
-import io.shardingjdbc.spring.AbstractShardingBothDataBasesAndTablesSpringDBUnitTest;
-import org.springframework.test.context.ContextConfiguration;
-
-@ContextConfiguration(locations = "classpath:META-INF/rdb/withNamespaceForIndicatedDataSourceNames.xml")
-public final class WithNamespaceForIndicatedDataSourceNamesTest extends AbstractShardingBothDataBasesAndTablesSpringDBUnitTest {
-}

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceAlgorithmClass.xml

@@ -15,8 +15,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceAlgorithmClassAndProps.xml

@@ -15,8 +15,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
             </sharding:table-rules>
         </sharding:sharding-rule>
         <sharding:props>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceAlgorithmExpression.xml

@@ -16,8 +16,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceBindingTables.xml

@@ -15,8 +15,8 @@
     <sharding:data-source id="shardingDatasource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_0,t_order_1,t_order_2,t_order_3" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_0,t_order_item_1,t_order_item_2,t_order_item_3" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
             </sharding:table-rules>
             <sharding:binding-table-rules>
                 <sharding:binding-table-rule logic-tables="t_order, t_order_item" />

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceDefaultStrategy.xml

@@ -15,8 +15,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0" default-database-strategy-ref="databaseStrategy" default-table-strategy-ref="tableStrategy">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_0,t_order_1,t_order_2,t_order_3"/>
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_0,t_order_item_1,t_order_item_2,t_order_item_3"/>
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceDifferentTables.xml

@@ -17,7 +17,7 @@
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
                 <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_0.t_order_${0..3}, dbtbl_1.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" database-strategy-ref="databaseStrategy"  table-strategy-ref="orderItemTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_0.t_order_item_${0..3}, dbtbl_1.t_order_item_${0..3}" database-strategy-ref="databaseStrategy"  table-strategy-ref="orderItemTableStrategy" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceForIndicatedDataSourceNames.xml

-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xmlns:sharding="http://shardingjdbc.io/schema/shardingjdbc/sharding"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans 
-                        http://www.springframework.org/schema/beans/spring-beans.xsd 
-                        http://shardingjdbc.io/schema/shardingjdbc/sharding 
-                        http://shardingjdbc.io/schema/shardingjdbc/sharding/sharding.xsd 
-                        ">
-    <import resource="datasource/dataSource.xml" />
-    
-    <sharding:inline-strategy id="databaseStrategy" sharding-column="user_id" algorithm-expression="dbtbl_${user_id % 2}" />
-    <sharding:inline-strategy id="orderTableStrategy" sharding-column="order_id" algorithm-expression="t_order_${order_id % 4}" />
-    <sharding:inline-strategy id="orderItemTableStrategy" sharding-column="order_id" algorithm-expression="t_order_item_${order_id % 4}" />
-    
-    <sharding:data-source id="shardingDataSource">
-        <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
-            <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}, t_order_${0..3}" data-source-names="dbtbl_0, dbtbl_1" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" data-source-names="dbtbl_${0..1}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
-            </sharding:table-rules>
-        </sharding:sharding-rule>
-    </sharding:data-source>
-</beans>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceForMasterSlaveWithDefaultStrategy.xml

@@ -22,8 +22,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}, t_order_${0..3}" data-source-names="dbtbl_0, dbtbl_1" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" data-source-names="dbtbl_${0..1}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceForMasterSlaveWithStrategyRef.xml

@@ -24,8 +24,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}, t_order_${0..3}" data-source-names="dbtbl_0, dbtbl_1" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" data-source-names="dbtbl_${0..1}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceForMasterSlaveWithStrategyType.xml

@@ -22,8 +22,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}, t_order_${0..3}" data-source-names="dbtbl_0, dbtbl_1" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" data-source-names="dbtbl_${0..1}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/test/resources/META-INF/rdb/withNamespaceGenerateKeyColumns.xml

@@ -15,8 +15,8 @@
     <sharding:data-source id="shardingDataSource">
         <sharding:sharding-rule data-source-names="dbtbl_0,dbtbl_1" default-data-source-name="dbtbl_0" key-generator-class="io.shardingjdbc.spring.fixture.IncrementKeyGenerator">
             <sharding:table-rules>
-                <sharding:table-rule logic-table="t_order" actual-tables="t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" generate-key-column="order_id" />
-                <sharding:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" generate-key-column="order_item_id" column-key-generator-class="io.shardingjdbc.spring.fixture.DecrementKeyGenerator" />
+                <sharding:table-rule logic-table="t_order" actual-tables="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" generate-key-column="order_id" />
+                <sharding:table-rule logic-table="t_order_item" actual-tables="dbtbl_${0..1}.t_order_item_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" generate-key-column="order_item_id" column-key-generator-class="io.shardingjdbc.spring.fixture.DecrementKeyGenerator" />
             </sharding:table-rules>
         </sharding:sharding-rule>
     </sharding:data-source>