add Tables

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/SQLParser.java

@@ -22,9 +22,10 @@ import com.dangdang.ddframe.rdb.sharding.parsing.lexer.Lexer;
 import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.DefaultKeyword;
 import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.Literals;
 import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.Symbol;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Column;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLIdentifierExpression;
@@ -40,7 +41,6 @@ import com.google.common.base.Optional;
 import lombok.Getter;
 import lombok.Setter;
 
-import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -148,7 +148,7 @@ public class SQLParser extends AbstractParser {
     
     private void setTableToken(final SQLStatement sqlStatement, final int beginPosition, final SQLPropertyExpression propertyExpr) {
         String owner = propertyExpr.getOwner().getName();
-        if (sqlStatement.getTables().get(0).getName().equalsIgnoreCase(SQLUtil.getExactlyValue(owner))) {
+        if (sqlStatement.getTables().getSingleTableName().equalsIgnoreCase(SQLUtil.getExactlyValue(owner))) {
             sqlStatement.getSqlTokens().add(new TableToken(beginPosition - owner.length(), owner));
         }
     }
@@ -285,7 +285,7 @@ public class SQLParser extends AbstractParser {
         getLexer().nextToken();
         SQLExpression right = parseExpression(sqlStatement);
         // TODO 如果有多表,且找不到column是哪个表的,则不加入condition,以后需要解析binding table
-        if ((1 == sqlStatement.getTables().size() || left instanceof SQLPropertyExpression)
+        if ((sqlStatement.getTables().isSingleTable() || left instanceof SQLPropertyExpression)
                 && (right instanceof SQLNumberExpression || right instanceof SQLTextExpression || right instanceof SQLPlaceholderExpression)) {
             Optional<Column> column = find(sqlStatement.getTables(), left);
             if (column.isPresent() && shardingRule.isShardingColumn(column.get())) {
@@ -328,46 +328,23 @@ public class SQLParser extends AbstractParser {
         parseExpression(sqlStatement);
     }
     
-    private Optional<Column> find(final Collection<Table> tables, final SQLExpression sqlExpression) {
+    private Optional<Column> find(final Tables tables, final SQLExpression sqlExpression) {
         if (sqlExpression instanceof SQLPropertyExpression) {
-            return getColumnWithQualifiedName(tables, (SQLPropertyExpression) sqlExpression);
+            return getColumnWithOwner(tables, (SQLPropertyExpression) sqlExpression);
         }
         if (sqlExpression instanceof SQLIdentifierExpression) {
-            return getColumnWithoutOwner(tables, SQLUtil.getExactlyValue(((SQLIdentifierExpression) sqlExpression).getName()));
+            return getColumnWithoutOwner(tables, (SQLIdentifierExpression) sqlExpression);
         }
         return Optional.absent();
     }
     
-    private Optional<Column> getColumnWithQualifiedName(final Collection<Table> tables, final SQLPropertyExpression propertyExpression) {
-        Optional<Table> table = findTable(tables, SQLUtil.getExactlyValue((propertyExpression.getOwner()).getName()));
+    private Optional<Column> getColumnWithOwner(final Tables tables, final SQLPropertyExpression propertyExpression) {
+        Optional<Table> table = tables.find(SQLUtil.getExactlyValue((propertyExpression.getOwner()).getName()));
         return propertyExpression.getOwner() instanceof SQLIdentifierExpression && table.isPresent()
                 ? Optional.of(new Column(SQLUtil.getExactlyValue(propertyExpression.getName()), table.get().getName())) : Optional.<Column>absent();
     }
     
-    private Optional<Table> findTable(final Collection<Table> tables, final String tableNameOrAlias) {
-        Optional<Table> tableFromName = findTableFromName(tables, tableNameOrAlias);
-        return tableFromName.isPresent() ? tableFromName : findTableFromAlias(tables, tableNameOrAlias);
-    }
-    
-    private Optional<Table> findTableFromName(final Collection<Table> tables, final String name) {
-        for (Table each : tables) {
-            if (each.getName().equalsIgnoreCase(name)) {
-                return Optional.of(each);
-            }
-        }
-        return Optional.absent();
-    }
-    
-    private Optional<Table> findTableFromAlias(final Collection<Table> tables, final String alias) {
-        for (Table each : tables) {
-            if (each.getAlias().isPresent() && each.getAlias().get().equalsIgnoreCase(alias)) {
-                return Optional.of(each);
-            }
-        }
-        return Optional.absent();
-    }
-    
-    private Optional<Column> getColumnWithoutOwner(final Collection<Table> tables, final String columnName) {
-        return 1 == tables.size() ? Optional.of(new Column(columnName, tables.iterator().next().getName())) : Optional.<Column>absent();
+    private Optional<Column> getColumnWithoutOwner(final Tables tables, final SQLIdentifierExpression identifierExpression) {
+        return tables.isSingleTable() ? Optional.of(new Column(SQLUtil.getExactlyValue(identifierExpression.getName()), tables.getSingleTableName())) : Optional.<Column>absent();
     }
 }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/context/Table.java → sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/context/table/Table.java

@@ -15,7 +15,7 @@
  * </p>
  */
 
-package com.dangdang.ddframe.rdb.sharding.parsing.parser.context;
+package com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table;
 
 import com.google.common.base.Optional;
 import lombok.Getter;
@@ -23,7 +23,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.ToString;
 
 /**
- * 表对象.
+ * 表解析对象.
  * 
  * @author zhangliang
  */

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/context/table/Tables.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 com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import lombok.ToString;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.TreeSet;
+
+/**
+ * 表集合对象.
+ * 
+ * @author zhangliang
+ */
+@ToString
+public final class Tables {
+    
+    private final List<Table> tables = new ArrayList<>();
+    
+    /**
+     * 添加表解析对象.
+     */
+    public void add(final Table table) {
+        tables.add(table);
+    }
+    
+    /**
+     * 判断是否为空.
+     *
+     * @return 是否为空
+     */
+    public boolean isEmpty() {
+        return tables.isEmpty();
+    }
+    
+    /**
+     * 判断是否为单表.
+     * 
+     * @return 是否为单表
+     */
+    public boolean isSingleTable() {
+        return 1 == tables.size();
+    }
+    
+    /**
+     * 获取表名称.
+     *
+     * @return 表名称
+     */
+    public String getSingleTableName() {
+        Preconditions.checkArgument(!isEmpty());
+        return tables.get(0).getName();
+    }
+    
+    /**
+     * 获取表名称集合.
+     * 
+     * @return 表名称集合
+     */
+    public Collection<String> getTableNames() {
+        Collection<String> result = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
+        for (Table each : tables) {
+            result.add(each.getName());
+        }
+        return result;
+    }
+    
+    /**
+     * 根据表名称或别名查找表解析对象.
+     * 
+     * @param tableNameOrAlias 表名称或别名
+     * @return 表解析对象
+     */
+    public Optional<Table> find(final String tableNameOrAlias) {
+        Optional<Table> tableFromName = findTableFromName(tableNameOrAlias);
+        return tableFromName.isPresent() ? tableFromName : findTableFromAlias(tableNameOrAlias);
+    }
+    
+    private Optional<Table> findTableFromName(final String name) {
+        for (Table each : tables) {
+            if (each.getName().equalsIgnoreCase(name)) {
+                return Optional.of(each);
+            }
+        }
+        return Optional.absent();
+    }
+    
+    private Optional<Table> findTableFromAlias(final String alias) {
+        for (Table each : tables) {
+            if (each.getAlias().isPresent() && each.getAlias().get().equalsIgnoreCase(alias)) {
+                return Optional.of(each);
+            }
+        }
+        return Optional.absent();
+    }
+}

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/dialect/mysql/MySQLInsertParser.java

@@ -58,7 +58,7 @@ public final class MySQLInsertParser extends AbstractInsertParser {
         do {
             getSqlParser().getLexer().nextToken();
             Column column = new Column(
-                    SQLUtil.getExactlyValue(getSqlParser().getLexer().getCurrentToken().getLiterals()), getInsertStatement().getTables().get(0).getName());
+                    SQLUtil.getExactlyValue(getSqlParser().getLexer().getCurrentToken().getLiterals()), getInsertStatement().getTables().getSingleTableName());
             getSqlParser().getLexer().nextToken();
             getSqlParser().accept(Symbol.EQ);
             SQLExpression sqlExpression;

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/AbstractSQLStatement.java

@@ -24,13 +24,12 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GroupBy;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Limit;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderBy;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.SQLToken;
 import com.google.common.base.Optional;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
@@ -48,7 +47,7 @@ public abstract class AbstractSQLStatement implements SQLStatement {
     
     private final SQLType type;
     
-    private final List<Table> tables = new ArrayList<>();
+    private final Tables tables = new Tables();
     
     private final Map<Column, Condition> conditions = new LinkedHashMap<>();
     

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/SQLStatement.java

@@ -24,7 +24,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GroupBy;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Limit;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderBy;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.SQLToken;
 import com.google.common.base.Optional;
 
@@ -49,7 +49,7 @@ public interface SQLStatement {
      * 
      * @return 表解析对象集合
      */
-    List<Table> getTables();
+    Tables getTables();
     
     /**
      * 添加条件对象.

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/insert/AbstractInsertParser.java

@@ -114,7 +114,7 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
     private void parseColumns() {
         Collection<Column> result = new LinkedList<>();
         if (sqlParser.equalAny(Symbol.LEFT_PAREN)) {
-            String tableName = insertStatement.getTables().get(0).getName();
+            String tableName = insertStatement.getTables().getSingleTableName();
             Optional<String> generateKeyColumn = shardingRule.getGenerateKeyColumn(tableName);
             int count = 0;
             do {
@@ -187,7 +187,7 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
     }
     
     private void appendGenerateKey() {
-        String tableName = insertStatement.getTables().get(0).getName();
+        String tableName = insertStatement.getTables().getSingleTableName();
         Optional<String> generateKeyColumn = shardingRule.getGenerateKeyColumn(tableName);
         if (!generateKeyColumn.isPresent() || null != insertStatement.getGeneratedKey()) {
             return;

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/insert/InsertStatement.java

@@ -68,7 +68,7 @@ public final class InsertStatement extends AbstractSQLStatement {
         if (null != generatedKey) {
             return;
         }
-        Optional<TableRule> tableRule = shardingRule.tryFindTableRule(getTables().get(0).getName());
+        Optional<TableRule> tableRule = shardingRule.tryFindTableRule(getTables().getSingleTableName());
         if (!tableRule.isPresent()) {
             return;
         }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/select/AbstractSelectParser.java

@@ -28,7 +28,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.CommonSelectItem
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GroupBy;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderBy;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SelectItem;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLIdentifierExpression;
@@ -317,10 +317,8 @@ public abstract class AbstractSelectParser implements SQLStatementParser {
             return;
         }
         SQLPropertyExpression sqlPropertyExpression = (SQLPropertyExpression) sqlExpression;
-        for (Table each : selectStatement.getTables()) {
-            if (each.getName().equalsIgnoreCase(SQLUtil.getExactlyValue(sqlPropertyExpression.getOwner().getName()))) {
-                selectStatement.getSqlTokens().add(new TableToken(startPosition, sqlPropertyExpression.getOwner().getName()));
-            }
+        if (selectStatement.getTables().getTableNames().contains(SQLUtil.getExactlyValue(sqlPropertyExpression.getOwner().getName()))) {
+            selectStatement.getSqlTokens().add(new TableToken(startPosition, sqlPropertyExpression.getOwner().getName()));
         }
     }
     

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/update/AbstractUpdateParser.java

@@ -73,7 +73,7 @@ public abstract class AbstractUpdateParser implements SQLStatementParser {
             String literals = sqlParser.getLexer().getCurrentToken().getLiterals();
             sqlParser.getLexer().nextToken();
             if (sqlParser.skipIfEqual(Symbol.DOT)) {
-                if (updateStatement.getTables().get(0).getName().equalsIgnoreCase(SQLUtil.getExactlyValue(literals))) {
+                if (updateStatement.getTables().getSingleTableName().equalsIgnoreCase(SQLUtil.getExactlyValue(literals))) {
                     updateStatement.getSqlTokens().add(new TableToken(beginPosition - literals.length(), literals));
                 }
                 sqlParser.getLexer().nextToken();

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/rewrite/SQLRewriteEngine.java

@@ -20,7 +20,6 @@ package com.dangdang.ddframe.rdb.sharding.rewrite;
 
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Limit;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.ItemsToken;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.OffsetLimitToken;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.RowCountLimitToken;
@@ -32,7 +31,6 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.TreeSet;
 
 /**
  * SQL重写引擎.
@@ -45,16 +43,14 @@ public final class SQLRewriteEngine {
     
     private final List<SQLToken> sqlTokens = new LinkedList<>();
     
-    private final Collection<String> tableNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
+    private final Collection<String> tableNames;
     
     private final Limit limit;
     
     public SQLRewriteEngine(final String originalSQL, final SQLStatement sqlStatement) {
         this.originalSQL = originalSQL;
         sqlTokens.addAll(sqlStatement.getSqlTokens());
-        for (Table each : sqlStatement.getTables()) {
-            tableNames.add(each.getName());
-        }
+        tableNames = sqlStatement.getTables().getTableNames();
         limit = sqlStatement.getLimit();
     }
     

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/routing/router/ParsingSQLRouter.java

@@ -24,9 +24,8 @@ import com.dangdang.ddframe.rdb.sharding.jdbc.ShardingContext;
 import com.dangdang.ddframe.rdb.sharding.metrics.MetricsContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GeneratedKey;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.insert.InsertStatement;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.insert.InsertStatement;
 import com.dangdang.ddframe.rdb.sharding.rewrite.SQLBuilder;
 import com.dangdang.ddframe.rdb.sharding.rewrite.SQLRewriteEngine;
 import com.dangdang.ddframe.rdb.sharding.routing.RoutingResult;
@@ -35,14 +34,11 @@ import com.dangdang.ddframe.rdb.sharding.routing.SQLRouteResult;
 import com.dangdang.ddframe.rdb.sharding.routing.type.binding.BindingTablesRouter;
 import com.dangdang.ddframe.rdb.sharding.routing.type.mixed.MixedTablesRouter;
 import com.dangdang.ddframe.rdb.sharding.routing.type.single.SingleTableRouter;
-import com.google.common.base.Function;
-import com.google.common.collect.Collections2;
-import com.google.common.collect.Sets;
 import lombok.extern.slf4j.Slf4j;
 
+import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Set;
 
 /**
  * 需要解析的SQL路由器.
@@ -85,7 +81,7 @@ public final class ParsingSQLRouter implements SQLRouter {
             if (parameters.isEmpty()) {
                 result.getGeneratedKeys().add(generatedKey.getValue());
             } else if (parameters.size() == generatedKey.getIndex()) {
-                Number key = shardingRule.generateKey(sqlStatement.getTables().get(0).getName());
+                Number key = shardingRule.generateKey(sqlStatement.getTables().getSingleTableName());
                 parameters.add(key);
                 setGeneratedKeys(result, key);
             } else if (-1 != generatedKey.getIndex()) {
@@ -108,21 +104,15 @@ public final class ParsingSQLRouter implements SQLRouter {
     }
     
     private RoutingResult route(final List<Object> parameters, final SQLStatement sqlStatement) {
-        Set<String> logicTables = Sets.newLinkedHashSet(Collections2.transform(sqlStatement.getTables(), new Function<Table, String>() {
-            
-            @Override
-            public String apply(final Table input) {
-                return input.getName();
-            }
-        }));
-        if (1 == logicTables.size()) {
-            return new SingleTableRouter(shardingRule, parameters, logicTables.iterator().next(), sqlStatement, sqlStatement.getType()).route();
+        Collection<String> tableNames = sqlStatement.getTables().getTableNames();
+        if (1 == tableNames.size()) {
+            return new SingleTableRouter(shardingRule, parameters, tableNames.iterator().next(), sqlStatement, sqlStatement.getType()).route();
         }
-        if (shardingRule.isAllBindingTables(logicTables)) {
-            return new BindingTablesRouter(shardingRule, parameters, logicTables, sqlStatement, sqlStatement.getType()).route();
+        if (shardingRule.isAllBindingTables(tableNames)) {
+            return new BindingTablesRouter(shardingRule, parameters, tableNames, sqlStatement, sqlStatement.getType()).route();
         }
         // TODO 可配置是否执行笛卡尔积
-        return new MixedTablesRouter(shardingRule, parameters, logicTables, sqlStatement, sqlStatement.getType()).route();
+        return new MixedTablesRouter(shardingRule, parameters, tableNames, sqlStatement, sqlStatement.getType()).route();
     }
     
     private void logSQLRouteResult(final SQLRouteResult routeResult, final List<Object> parameters) {

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/AbstractBaseParseTest.java

@@ -29,7 +29,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GroupBy;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Limit;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderBy;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Column;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLNumberExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLPlaceholderExpression;

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/mysql/MySQLPreparedStatementForOneParameterTest.java

@@ -22,7 +22,7 @@ import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.parsing.AbstractBaseParseTest;
 import com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import org.junit.Test;
 import org.junit.runner.RunWith;

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/mysql/MySQLPreparedStatementForTowParametersTest.java

@@ -22,7 +22,7 @@ import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.parsing.AbstractBaseParseTest;
 import com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import org.junit.Test;
 import org.junit.runner.RunWith;

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/mysql/MySQLStatementTest.java

@@ -22,7 +22,7 @@ import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.parsing.AbstractBaseParseTest;
 import com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import org.junit.Test;
 import org.junit.runner.RunWith;

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/mysql/OrParseTest.java

@@ -22,7 +22,7 @@ import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.parsing.AbstractBaseParseTest;
 import com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import org.junit.Ignore;
 import org.junit.Test;

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/DeleteStatementParserTest.java

@@ -44,7 +44,7 @@ public final class DeleteStatementParserTest extends AbstractStatementParserTest
         ShardingRule shardingRule = createShardingRule();
         SQLParsingEngine statementParser = new SQLParsingEngine(DatabaseType.MySQL, sql, shardingRule);
         DeleteStatement deleteStatement = (DeleteStatement) statementParser.parse();
-        assertThat(deleteStatement.getTables().get(0).getName(), is("TABLE_XXX"));
+        assertThat(deleteStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
         // TODO 放入rewrite模块断言
         assertThat(new SQLRewriteEngine(sql, deleteStatement).rewrite().toString(), is("DELETE FROM [Token(TABLE_XXX)]"));
     }
@@ -62,8 +62,8 @@ public final class DeleteStatementParserTest extends AbstractStatementParserTest
     }
     
     private void assertDeleteStatementWithoutParameter(final DeleteStatement deleteStatement) {
-        assertThat(deleteStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        assertThat(deleteStatement.getTables().get(0).getAlias().get(), is("xxx"));
+        assertThat(deleteStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
+        assertThat(deleteStatement.getTables().find("xxx").get().getAlias().get(), is("xxx"));
         Condition condition1 = deleteStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition1.getValues(Collections.emptyList()).size(), is(1));
@@ -93,8 +93,8 @@ public final class DeleteStatementParserTest extends AbstractStatementParserTest
     }
     
     private void assertDeleteStatementWithParameter(final DeleteStatement deleteStatement) {
-        assertThat(deleteStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        assertThat(deleteStatement.getTables().get(0).getAlias().get(), is("xxx"));
+        assertThat(deleteStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
+        assertThat(deleteStatement.getTables().find("xxx").get().getAlias().get(), is("xxx"));
         List<Object> actualParameters = Arrays.<Object>asList(0, 10, 20, 30, 40, 50, 60, 70, 80);
         Condition condition1 = deleteStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
@@ -151,8 +151,8 @@ public final class DeleteStatementParserTest extends AbstractStatementParserTest
     
     private void parseWithSpecialSyntax(final DatabaseType dbType, final String actualSQL, final String expectedSQL) {
         DeleteStatement deleteStatement = (DeleteStatement) new SQLParsingEngine(dbType, actualSQL, createShardingRule()).parse();
-        assertThat(deleteStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        assertFalse(deleteStatement.getTables().get(0).getAlias().isPresent());
+        assertThat(deleteStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
+        assertFalse(deleteStatement.getTables().find("TABLE_XXX").get().getAlias().isPresent());
         Condition condition = deleteStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues(Collections.emptyList()).size(), is(1));

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/InsertStatementParserTest.java

@@ -85,7 +85,7 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
     }
     
     private void assertInsertStatementWithoutParameter(final InsertStatement insertStatement) {
-        assertThat(insertStatement.getTables().get(0).getName(), is("TABLE_XXX"));
+        assertThat(insertStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
         Condition condition = insertStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues(Collections.emptyList()).size(), is(1));
@@ -105,7 +105,7 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
     }
     
     private void assertInsertStatementWithParameter(final InsertStatement insertStatement) {
-        assertThat(insertStatement.getTables().get(0).getName(), is("TABLE_XXX"));
+        assertThat(insertStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
         Condition condition = insertStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues(Collections.<Object>singletonList(0)).size(), is(1));
@@ -157,8 +157,8 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
     
     private void parseWithSpecialSyntax(final DatabaseType dbType, final String actualSQL, final String expectedSQL) {
         InsertStatement insertStatement = (InsertStatement) new SQLParsingEngine(dbType, actualSQL, createShardingRule()).parse();
-        assertThat(insertStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        assertFalse(insertStatement.getTables().get(0).getAlias().isPresent());
+        assertThat(insertStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
+        assertFalse(insertStatement.getTables().find("TABLE_XXX").get().getAlias().isPresent());
         Condition condition = insertStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues(Collections.emptyList()).size(), is(1));

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/UpdateStatementParserTest.java

@@ -44,7 +44,7 @@ public final class UpdateStatementParserTest extends AbstractStatementParserTest
         ShardingRule shardingRule = createShardingRule();
         SQLParsingEngine statementParser = new SQLParsingEngine(DatabaseType.MySQL, sql, shardingRule);
         UpdateStatement updateStatement = (UpdateStatement) statementParser.parse();
-        assertThat(updateStatement.getTables().get(0).getName(), is("TABLE_XXX"));
+        assertThat(updateStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
         // TODO 放入rewrite模块断言
         assertThat(new SQLRewriteEngine(sql, updateStatement).rewrite().toString(), is("UPDATE [Token(TABLE_XXX)] SET field1=field1+1"));
     }
@@ -64,8 +64,8 @@ public final class UpdateStatementParserTest extends AbstractStatementParserTest
     }
     
     private void assertUpdateStatementWithoutParameter(final UpdateStatement updateStatement) {
-        assertThat(updateStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        assertThat(updateStatement.getTables().get(0).getAlias().get(), is("xxx"));
+        assertThat(updateStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
+        assertThat(updateStatement.getTables().find("TABLE_XXX").get().getAlias().get(), is("xxx"));
         Condition condition1 = updateStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition1.getValues(Collections.emptyList()).size(), is(1));
@@ -95,8 +95,8 @@ public final class UpdateStatementParserTest extends AbstractStatementParserTest
     }
     
     private void assertUpdateStatementWitParameter(final UpdateStatement updateStatement) {
-        assertThat(updateStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        assertThat(updateStatement.getTables().get(0).getAlias().get(), is("xxx"));
+        assertThat(updateStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
+        assertThat(updateStatement.getTables().find("TABLE_XXX").get().getAlias().get(), is("xxx"));
         List<Object> actualParameters = Arrays.<Object>asList(0, 10, 20, 30, 40, 50, 60, 70, 80);
         Condition condition1 = updateStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
@@ -146,8 +146,8 @@ public final class UpdateStatementParserTest extends AbstractStatementParserTest
     
     private void parseWithSpecialSyntax(final DatabaseType dbType, final String actualSQL, final String expectedSQL) {
         UpdateStatement updateStatement = (UpdateStatement) new SQLParsingEngine(dbType, actualSQL, createShardingRule()).parse();
-        assertThat(updateStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        assertFalse(updateStatement.getTables().get(0).getAlias().isPresent());
+        assertThat(updateStatement.getTables().find("TABLE_XXX").get().getName(), is("TABLE_XXX"));
+        assertFalse(updateStatement.getTables().find("TABLE_XXX").get().getAlias().isPresent());
         Condition condition = updateStatement.find(new Column("field1", "TABLE_XXX")).get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues(Collections.emptyList()).size(), is(1));