refactor api: actual tables -> actual data nodes 3rd version

README_ZH.md

@@ -135,8 +135,8 @@ try (
     <rdb:data-source id="shardingDataSource">
         <rdb:sharding-rule data-sources="dbtbl_0,dbtbl_1">
             <rdb:table-rules>
-                <rdb:table-rule logic-table="t_order" actual-tables="t_order_${0..3}" table-strategy="orderTableStrategy"/>
-                <rdb:table-rule logic-table="t_order_item" actual-tables="t_order_item_${0..3}" table-strategy="orderItemTableStrategy"/>
+                <rdb:table-rule logic-table="t_order" actual-data-nodes="t_order_${0..3}" table-strategy="orderTableStrategy"/>
+                <rdb:table-rule logic-table="t_order_item" actual-data-nodes="t_order_item_${0..3}" table-strategy="orderItemTableStrategy"/>
             </rdb:table-rules>
             <rdb:default-database-strategy sharding-columns="none" algorithm-class="com.dangdang.ddframe.rdb.sharding.api.strategy.database.NoneDatabaseShardingAlgorithm"/>
         </rdb:sharding-rule>

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

@@ -43,7 +43,7 @@ public class TableRuleConfiguration {
     
     private String logicTable;
     
-    private String actualTables;
+    private String actualDataNodes;
     
     private ShardingStrategyConfiguration databaseShardingStrategyConfig;
     
@@ -61,10 +61,10 @@ 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> actualDataNodes = new InlineExpressionParser(this.actualDataNodes).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, dataSourceMap, databaseShardingStrategy, tableShardingStrategy, keyGeneratorColumnName, keyGenerator);
+        return new TableRule(logicTable, actualDataNodes, dataSourceMap, databaseShardingStrategy, tableShardingStrategy, keyGeneratorColumnName, keyGenerator);
     }
 }

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

@@ -51,10 +51,10 @@ public final class TableRule {
     
     private final KeyGenerator keyGenerator;
     
-    public TableRule(final String logicTable, final List<String> actualTables, final Map<String, DataSource> dataSourceMap,
+    public TableRule(final String logicTable, final List<String> actualDataNodes, final Map<String, DataSource> dataSourceMap,
                      final ShardingStrategy databaseShardingStrategy, final ShardingStrategy tableShardingStrategy, final String generateKeyColumn, final KeyGenerator keyGenerator) {
         this.logicTable = logicTable;
-        this.actualDataNodes = null == actualTables || actualTables.isEmpty() ? generateDataNodes(logicTable, dataSourceMap) : generateDataNodes(actualTables, dataSourceMap);
+        this.actualDataNodes = null == actualDataNodes || actualDataNodes.isEmpty() ? generateDataNodes(logicTable, dataSourceMap) : generateDataNodes(actualDataNodes, dataSourceMap);
         this.databaseShardingStrategy = databaseShardingStrategy;
         this.tableShardingStrategy = tableShardingStrategy;
         this.generateKeyColumn = generateKeyColumn;
@@ -69,13 +69,13 @@ public final class TableRule {
         return result;
     }
     
-    private List<DataNode> generateDataNodes(final List<String> actualTables, final Map<String, DataSource> dataSourceMap) {
+    private List<DataNode> generateDataNodes(final List<String> actualDataNodes, 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);
+        for (String each : actualDataNodes) {
+            Preconditions.checkArgument(DataNode.isValidDataNode(each), String.format("Invalid format for actual data nodes: '%s'", each));
+            DataNode dataNode = new DataNode(each);
             Preconditions.checkArgument(dataSourceMap.containsKey(dataNode.getDataSourceName()), 
-                    String.format("Cannot find data source name in sharding rule, invalid actual data node is: '%s'", actualTable));
+                    String.format("Cannot find data source name in sharding rule, invalid actual data node is: '%s'", each));
             result.add(dataNode);
         }
         return result;

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlTableRuleConfiguration.java

@@ -16,9 +16,7 @@ public class YamlTableRuleConfiguration {
     
     private String logicTable;
     
-    private String actualTables;
-    
-    private String dataSourceNames;
+    private String actualDataNodes;
     
     private YamlShardingStrategyConfiguration databaseStrategy;
     
@@ -37,7 +35,7 @@ public class YamlTableRuleConfiguration {
         Preconditions.checkNotNull(logicTable, "Logic table cannot be null.");
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable(logicTable);
-        tableRuleConfig.setActualTables(actualTables);
+        tableRuleConfig.setActualDataNodes(actualDataNodes);
         tableRuleConfig.setLogicTable(logicTable);
         if (null != databaseStrategy) {
             tableRuleConfig.setDatabaseShardingStrategyConfig(databaseStrategy.build());

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("ds.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("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("db0." + input + ",db1." + input);
+                result.setActualDataNodes("db0." + input + ",db1." + input);
                 result.setKeyGeneratorColumnName(generateKeyColumnsMap.get(input));
                 return result;
             }
@@ -86,7 +86,7 @@ public class ShardingRuleMockBuilder {
         if (tableRuleConfigs.isEmpty()) {
             TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
             tableRuleConfig.setLogicTable("mock");
-            tableRuleConfig.setActualTables("mock");
+            tableRuleConfig.setActualDataNodes("mock");
             tableRuleConfigs.add(tableRuleConfig);
         }
         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();

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

@@ -63,7 +63,7 @@ public abstract class AbstractShardingJDBCDatabaseAndTableTest extends AbstractS
             for (String dataSourceName : entry.getValue().keySet()) {
                 orderActualDataNodes.add(dataSourceName + ".t_order_${0..1}");
             }
-            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
+            orderTableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
@@ -71,7 +71,7 @@ public abstract class AbstractShardingJDBCDatabaseAndTableTest extends AbstractS
             for (String dataSourceName : entry.getValue().keySet()) {
                 orderItemActualDataNodes.add(dataSourceName + ".t_order_item_${0..1}");
             }
-            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(orderItemActualDataNodes));
+            orderItemTableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderItemActualDataNodes));
             orderItemTableRuleConfig.setKeyGeneratorColumnName("item_id");
             orderItemTableRuleConfig.setKeyGeneratorClass(IncrementKeyGenerator.class.getName());
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);

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

@@ -86,7 +86,7 @@ public class ShardingDatabaseAndTableTest extends AbstractSQLAssertTest {
             for (String dataSourceName : entry.getValue().keySet()) {
                 orderActualDataNodes.add(dataSourceName + ".t_order_${0..9}");
             }
-            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
+            orderTableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
@@ -94,7 +94,7 @@ public class ShardingDatabaseAndTableTest extends AbstractSQLAssertTest {
             for (String dataSourceName : entry.getValue().keySet()) {
                 orderItemActualDataNodes.add(dataSourceName + ".t_order_item_${0..9}");
             }
-            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(orderItemActualDataNodes));
+            orderItemTableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderItemActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             TableRuleConfiguration configTableRuleConfig = new TableRuleConfiguration();
             configTableRuleConfig.setLogicTable("t_config");

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

@@ -99,7 +99,7 @@ public class ShardingMasterSlaveTest extends AbstractSQLAssertTest {
             for (String dataSourceName : masterSlaveDataSourceMap.keySet()) {
                 orderActualDataNodes.add(dataSourceName + ".t_order_${0..9}");
             }
-            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
+            orderTableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
@@ -107,7 +107,7 @@ public class ShardingMasterSlaveTest extends AbstractSQLAssertTest {
             for (String dataSourceName : masterSlaveDataSourceMap.keySet()) {
                 itemOrderActualDataNodes.add(dataSourceName + ".t_order_item_${0..9}");
             }
-            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(itemOrderActualDataNodes));
+            orderItemTableRuleConfig.setActualDataNodes(Joiner.on(",").join(itemOrderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             TableRuleConfiguration configTableRuleConfig = new TableRuleConfiguration();
             configTableRuleConfig.setLogicTable("t_config");

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

@@ -75,7 +75,7 @@ public class ShardingTableOnlyTest extends AbstractSQLAssertTest {
             for (String dataSourceName : entry.getValue().keySet()) {
                 orderActualDataNodes.add(dataSourceName + ".t_order_${0..9}");
             }
-            orderTableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
+            orderTableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderActualDataNodes));
             shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
             TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
             orderItemTableRuleConfig.setLogicTable("t_order_item");
@@ -83,7 +83,7 @@ public class ShardingTableOnlyTest extends AbstractSQLAssertTest {
             for (String dataSourceName : entry.getValue().keySet()) {
                 orderItemActualDataNodes.add(dataSourceName + ".t_order_item_${0..9}");
             }
-            orderItemTableRuleConfig.setActualTables(Joiner.on(",").join(orderItemActualDataNodes));
+            orderItemTableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderItemActualDataNodes));
             orderItemTableRuleConfig.setKeyGeneratorClass("item_id");
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");

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

@@ -194,7 +194,7 @@ public final class ShardingDataSourceTest {
         for (String each : dataSourceMap.keySet()) {
             orderActualDataNodes.add(each + ".table_${0..2}");
         }
-        tableRuleConfig.setActualTables(Joiner.on(",").join(orderActualDataNodes));
+        tableRuleConfig.setActualDataNodes(Joiner.on(",").join(orderActualDataNodes));
         result.getTableRuleConfigs().add(tableRuleConfig);
         return result;
     }

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

@@ -68,11 +68,11 @@ public final class SQLParsingEngineTest extends AbstractBaseParseSQLTest {
     private ShardingRule buildShardingRule() throws SQLException {
         TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
         orderTableRuleConfig.setLogicTable("t_order");
-        orderTableRuleConfig.setActualTables("db0.t_order,db1.t_order");
+        orderTableRuleConfig.setActualDataNodes("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("db0.t_order_item,db1.t_order_item");
+        orderItemTableRuleConfig.setActualDataNodes("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("ds.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("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("ds.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("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/BindingTableRuleTest.java

@@ -74,14 +74,14 @@ public final class BindingTableRuleTest {
     private TableRule createTableRule() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds1.table_0, ds1.table_1, ds2.table_0, ds2.table_1");
+        tableRuleConfig.setActualDataNodes("ds1.table_0, ds1.table_1, ds2.table_0, ds2.table_1");
         return tableRuleConfig.build(createDataSourceMap());
     }
     
     private TableRule createSubTableRule() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("subLogicTable");
-        tableRuleConfig.setActualTables("ds1.sub_table_0, ds1.sub_table_1, ds2.sub_table_0, ds2.sub_table_1");
+        tableRuleConfig.setActualDataNodes("ds1.sub_table_0, ds1.sub_table_1, ds2.sub_table_0, ds2.sub_table_1");
         return tableRuleConfig.build(createDataSourceMap());
     }
     

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("ds${0..1}.table_${0..2}");
+        result.setActualDataNodes("ds${0..1}.table_${0..2}");
         return result;
     }
     
     private TableRuleConfiguration createTableRuleConfigWithDatabaseShardingStrategy(final ShardingStrategyConfiguration strategyConfig) {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
-        result.setActualTables("ds${0..1}.table_${0..2}");
+        result.setActualDataNodes("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("ds${0..1}.table_${0..2}");
+        result.setActualDataNodes("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("ds${0..1}.sub_table_${0..2}");
+        result.setActualDataNodes("ds${0..1}.sub_table_${0..2}");
         return result;
     }
     
     private TableRuleConfiguration createTableRuleConfigWithAllStrategies() {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
-        result.setActualTables("ds${0..1}.table_${0..2}");
+        result.setActualDataNodes("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("ds${0..1}.table_${0..2}");
+        result.setActualDataNodes("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("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("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("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("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("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("ds${0..1}.table_${0..2}");
         tableRuleConfig.setTableShardingStrategyConfig(new NoneShardingStrategyConfiguration());
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
@@ -77,7 +77,7 @@ public final class TableRuleTest {
     public void assertTableRuleWithDataNodeString() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("ds${0..1}.table_${0..2}");
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
         assertNull(actual.getDatabaseShardingStrategy());
@@ -88,7 +88,7 @@ public final class TableRuleTest {
     public void assertTableRuleWithDataSourceNames() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("ds${0..1}.table_${0..2}");
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertActualTable(actual);
         assertNull(actual.getDatabaseShardingStrategy());
@@ -109,7 +109,7 @@ public final class TableRuleTest {
     public void assertGetActualDatasourceNames() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("ds${0..1}.table_${0..2}");
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertThat(actual.getActualDatasourceNames(), is((Collection<String>) Sets.newLinkedHashSet(Arrays.asList("ds0", "ds1"))));
     }
@@ -118,7 +118,7 @@ public final class TableRuleTest {
     public void assertGetActualTableNames() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("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"))));
     }
@@ -127,7 +127,7 @@ public final class TableRuleTest {
     public void assertFindActualTableIndex() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("ds${0..1}.table_${0..2}");
         TableRule actual = tableRuleConfig.build(createDataSourceMap());
         assertThat(actual.findActualTableIndex("ds1", "table_1"), is(4));
     }
@@ -136,7 +136,7 @@ public final class TableRuleTest {
     public void assertFindActualTableIndexForNotFound() {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("logicTable");
-        tableRuleConfig.setActualTables("ds${0..1}.table_${0..2}");
+        tableRuleConfig.setActualDataNodes("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,10 +18,10 @@ defaultKeyGeneratorClass: io.shardingjdbc.core.yaml.fixture.IncrementKeyGenerato
     
 tables:
   config:
-    actualTables: db${0..1}.config_${0..1}
+    actualDataNodes: db${0..1}.config_${0..1}
 
   t_order: 
-    actualTables: db${0..1}.t_order_${0..1}
+    actualDataNodes: db${0..1}.t_order_${0..1}
     databaseStrategy: 
       standard:
         shardingColumn: order_id
@@ -31,7 +31,7 @@ tables:
         shardingColumn: id
         algorithmInlineExpression: t_order_${id % 2}
   t_order_item:
-    actualTables: db${0..1}.t_order_item_${0..1}
+    actualDataNodes: 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: ds.t_order_${0..1}
+    actualDataNodes: 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: ds.t_order_item_${0..1}
+    actualDataNodes: ds.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

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

@@ -13,7 +13,7 @@ dataSources:
     maxActive: 100
 tables:
   t_order: 
-    actualTables: t_order_${0..1}
+    actualDataNodes: t_order_${0..1}
     tableStrategy: 
       standard:
         shardingColumn: order_id

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

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

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

@@ -14,10 +14,10 @@ dataSources:
     
 tables:
   config:
-    actualTables: db${0..1}.t_config
+    actualDataNodes: db${0..1}.t_config
   
   t_order: 
-    actualTables: db${0..1}.t_order_${0..1}
+    actualDataNodes: 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: db${0..1}.t_order_item_${0..1}
+    actualDataNodes: 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: db${0..1}.t_config
+    actualDataNodes: db${0..1}.t_config
 
   t_order: 
-    actualTables: db${0..1}.t_order_${0..1}
+    actualDataNodes: 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: db${0..1}.t_order_item_${0..1}
+    actualDataNodes: db${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

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

 tables:
   config:
-    actualTables: db${0..1}.t_config
+    actualDataNodes: db${0..1}.t_config
 
   t_order: 
-    actualTables: db${0..1}.t_order_${0..1}
+    actualDataNodes: 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: db${0..1}.t_order_item_${0..1}
+    actualDataNodes: db${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

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

 tables:
   config:
-    actualTables: db${0..1}.t_config
+    actualDataNodes: db${0..1}.t_config
   t_order: 
-    actualTables: db${0..1}.t_order_${0..1}
+    actualDataNodes: 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: db${0..1}.t_order_item_${0..1}
+    actualDataNodes: 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: db_ms_${0..1}.t_config
+    actualDataNodes: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: db_ms_${0..1}.t_order_${0..1}
+    actualDataNodes: 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: db_ms_${0..1}.t_order_item_${0..1}
+    actualDataNodes: 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: db_ms_${0..1}.t_config
+    actualDataNodes: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: db_ms_${0..1}.t_order_${0..2}
+    actualDataNodes: 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: db_ms_${0..1}.t_order_item_${0..1}
+    actualDataNodes: 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: db_ms_${0..1}.t_config
+    actualDataNodes: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: db_ms_${0..1}.t_order_${0..1}
+    actualDataNodes: 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: db_ms_${0..1}.t_order_item_${0..1}
+    actualDataNodes: 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: db_ms_${0..1}.t_config
+    actualDataNodes: db_ms_${0..1}.t_config
     
   t_order: 
-    actualTables: db_ms_${0..1}.t_order_${0..1}
+    actualDataNodes: 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: db_ms_${0..1}.t_order_item_${0..1}
+    actualDataNodes: db_ms_${0..1}.t_order_item_${0..1}
     #绑定表中其余的表的策略与第一张表的策略相同
     databaseStrategy: 
       standard:

sharding-jdbc-orchestration/src/test/java/io/shardingjdbc/orchestration/json/ShardingRuleConfigurationConverterTest.java

@@ -19,9 +19,9 @@ import static org.junit.Assert.assertThat;
 
 public final class ShardingRuleConfigurationConverterTest {
     
-    private final String commonShardingRuleConfigJson = "{\"tableRuleConfigs\":[{\"logicTable\":\"t_order\",\"actualTables\":\"t_order_${[0, 1]}\","
+    private final String commonShardingRuleConfigJson = "{\"tableRuleConfigs\":[{\"logicTable\":\"t_order\",\"actualDataNodes\":\"t_order_${[0, 1]}\","
             + "\"databaseShardingStrategyConfig\":{},\"tableShardingStrategyConfig\":{}},"
-            + "{\"logicTable\":\"t_order_item\",\"actualTables\":\"t_order_item_${[0, 1]}\","
+            + "{\"logicTable\":\"t_order_item\",\"actualDataNodes\":\"t_order_item_${[0, 1]}\","
             + "\"databaseShardingStrategyConfig\":{},\"tableShardingStrategyConfig\":{}}"
             + "],\"bindingTableGroups\":[\"t_order, t_order_item\"],\"defaultDatabaseShardingStrategyConfig\":{},";
     
@@ -61,11 +61,11 @@ public final class ShardingRuleConfigurationConverterTest {
         ShardingRuleConfiguration actual = new ShardingRuleConfiguration();
         TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
         orderTableRuleConfig.setLogicTable("t_order");
-        orderTableRuleConfig.setActualTables("t_order_${[0, 1]}");
+        orderTableRuleConfig.setActualDataNodes("t_order_${[0, 1]}");
         actual.getTableRuleConfigs().add(orderTableRuleConfig);
         TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
         orderItemTableRuleConfig.setLogicTable("t_order_item");
-        orderItemTableRuleConfig.setActualTables("t_order_item_${[0, 1]}");
+        orderItemTableRuleConfig.setActualDataNodes("t_order_item_${[0, 1]}");
         actual.getTableRuleConfigs().add(orderItemTableRuleConfig);
         actual.getBindingTableGroups().add("t_order, t_order_item");
         actual.setDefaultTableShardingStrategyConfig(strategyConfig);
@@ -153,10 +153,10 @@ public final class ShardingRuleConfigurationConverterTest {
         Iterator<TableRuleConfiguration> actualTableRuleConfigs = actual.getTableRuleConfigs().iterator();
         TableRuleConfiguration orderTableRuleConfig = actualTableRuleConfigs.next();
         assertThat(orderTableRuleConfig.getLogicTable(), is("t_order"));
-        assertThat(orderTableRuleConfig.getActualTables(), is("t_order_${[0, 1]}"));
+        assertThat(orderTableRuleConfig.getActualDataNodes(), is("t_order_${[0, 1]}"));
         TableRuleConfiguration orderItemTableRuleConfig = actualTableRuleConfigs.next();
         assertThat(orderItemTableRuleConfig.getLogicTable(), is("t_order_item"));
-        assertThat(orderItemTableRuleConfig.getActualTables(), is("t_order_item_${[0, 1]}"));
+        assertThat(orderItemTableRuleConfig.getActualDataNodes(), is("t_order_item_${[0, 1]}"));
         assertThat(actual.getBindingTableGroups().size(), is(1));
         assertThat(actual.getBindingTableGroups().iterator().next(), is("t_order, t_order_item"));
     }

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/main/java/io/shardingjdbc/spring/namespace/constants/ShardingJdbcDataSourceBeanDefinitionParserTag.java

@@ -50,7 +50,7 @@ public final class ShardingJdbcDataSourceBeanDefinitionParserTag {
     
     public static final String LOGIC_TABLES_ATTRIBUTE = "logic-tables";
     
-    public static final String ACTUAL_TABLES_ATTRIBUTE = "actual-tables";
+    public static final String ACTUAL_DATA_NODES_ATTRIBUTE = "actual-data-nodes";
     
     public static final String DATABASE_STRATEGY_REF_ATTRIBUTE = "database-strategy-ref";
     

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/main/java/io/shardingjdbc/spring/namespace/parser/ShardingJdbcDataSourceBeanDefinitionParser.java

@@ -121,9 +121,9 @@ public class ShardingJdbcDataSourceBeanDefinitionParser extends AbstractBeanDefi
     private BeanDefinition parseTableRuleConfig(final Element tableElement) {
         BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(TableRuleConfiguration.class);
         factory.addPropertyValue("logicTable", tableElement.getAttribute(ShardingJdbcDataSourceBeanDefinitionParserTag.LOGIC_TABLE_ATTRIBUTE));
-        String actualTables = tableElement.getAttribute(ShardingJdbcDataSourceBeanDefinitionParserTag.ACTUAL_TABLES_ATTRIBUTE);
-        if (!Strings.isNullOrEmpty(actualTables)) {
-            factory.addPropertyValue("actualTables", actualTables);
+        String actualDataNodes = tableElement.getAttribute(ShardingJdbcDataSourceBeanDefinitionParserTag.ACTUAL_DATA_NODES_ATTRIBUTE);
+        if (!Strings.isNullOrEmpty(actualDataNodes)) {
+            factory.addPropertyValue("actualDataNodes", actualDataNodes);
         }
         String databaseStrategy = tableElement.getAttribute(ShardingJdbcDataSourceBeanDefinitionParserTag.DATABASE_STRATEGY_REF_ATTRIBUTE);
         if (!Strings.isNullOrEmpty(databaseStrategy)) {

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/main/resources/META-INF/namespace/sharding.xsd

@@ -38,7 +38,7 @@
     <xsd:element name="table-rule">
         <xsd:complexType>
             <xsd:attribute name="logic-table" type="xsd:string" use="required" />
-            <xsd:attribute name="actual-tables" type="xsd:string" use="optional" />
+            <xsd:attribute name="actual-data-nodes" type="xsd:string" use="optional" />
             <xsd:attribute name="database-strategy-ref" type="xsd:string" use="optional" />
             <xsd:attribute name="table-strategy-ref" type="xsd:string" use="optional" />
             <xsd:attribute name="generate-key-column" type="xsd:string" use="optional" />

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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="tableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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

@@ -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="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="dbtbl_0.t_order_item_${0..3}, dbtbl_1.t_order_item_${0..3}" database-strategy-ref="databaseStrategy"  table-strategy-ref="orderItemTableStrategy" />
+                <sharding:table-rule logic-table="t_order" actual-data-nodes="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-data-nodes="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/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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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="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-rule logic-table="t_order" actual-data-nodes="dbtbl_${0..1}.t_order_${0..3}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
+                <sharding:table-rule logic-table="t_order_item" actual-data-nodes="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="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-rule logic-table="t_order" actual-data-nodes="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-data-nodes="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>