rename TableContext => Table, ShardingColumnContext => ShardingColumn

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/api/rule/ShardingRule.java

@@ -25,7 +25,7 @@ import com.dangdang.ddframe.rdb.sharding.exception.ShardingJdbcException;
 import com.dangdang.ddframe.rdb.sharding.keygen.DefaultKeyGenerator;
 import com.dangdang.ddframe.rdb.sharding.keygen.KeyGenerator;
 import com.dangdang.ddframe.rdb.sharding.keygen.KeyGeneratorFactory;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumnContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import lombok.AccessLevel;
@@ -205,22 +205,22 @@ public final class ShardingRule {
     /**
      * 判断是否为分片列.
      *
-     * @param shardingColumnContext 表对象
+     * @param shardingColumn 表对象
      * @return 是否为分片列
      */
-    public boolean isShardingColumn(final ShardingColumnContext shardingColumnContext) {
-        if (databaseShardingStrategy.getShardingColumns().contains(shardingColumnContext.getColumnName())
-                || tableShardingStrategy.getShardingColumns().contains(shardingColumnContext.getColumnName())) {
+    public boolean isShardingColumn(final ShardingColumn shardingColumn) {
+        if (databaseShardingStrategy.getShardingColumns().contains(shardingColumn.getColumnName())
+                || tableShardingStrategy.getShardingColumns().contains(shardingColumn.getColumnName())) {
             return true;
         }
         for (TableRule each : tableRules) {
-            if (!each.getLogicTable().equalsIgnoreCase(shardingColumnContext.getTableName())) {
+            if (!each.getLogicTable().equalsIgnoreCase(shardingColumn.getTableName())) {
                 continue;
             }
-            if (null != each.getDatabaseShardingStrategy() && each.getDatabaseShardingStrategy().getShardingColumns().contains(shardingColumnContext.getColumnName())) {
+            if (null != each.getDatabaseShardingStrategy() && each.getDatabaseShardingStrategy().getShardingColumns().contains(shardingColumn.getColumnName())) {
                 return true;
             }
-            if (null != each.getTableShardingStrategy() && each.getTableShardingStrategy().getShardingColumns().contains(shardingColumnContext.getColumnName())) {
+            if (null != each.getTableShardingStrategy() && each.getTableShardingStrategy().getShardingColumns().contains(shardingColumn.getColumnName())) {
                 return true;
             }
         }

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

@@ -24,8 +24,8 @@ 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.ConditionContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumnContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLExpr;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLIdentifierExpr;
@@ -188,7 +188,7 @@ public class SQLParser extends AbstractParser {
             }
             hasParentheses = true;
         }
-        TableContext tableContext;
+        Table table;
         final int beginPosition = getLexer().getCurrentToken().getEndPosition() - getLexer().getCurrentToken().getLiterals().length();
         String literals = getLexer().getCurrentToken().getLiterals();
         getLexer().nextToken();
@@ -197,18 +197,18 @@ public class SQLParser extends AbstractParser {
             if (hasParentheses) {
                 accept(Symbol.RIGHT_PAREN);
             }
-            tableContext = new TableContext(SQLUtil.getExactlyValue(literals), parseAlias());
+            table = new Table(SQLUtil.getExactlyValue(literals), parseAlias());
         } else {
             if (hasParentheses) {
                 accept(Symbol.RIGHT_PAREN);
             }
-            tableContext = new TableContext(SQLUtil.getExactlyValue(literals), parseAlias());
+            table = new Table(SQLUtil.getExactlyValue(literals), parseAlias());
         }
         if (skipJoin()) {
             throw new UnsupportedOperationException("Cannot support Multiple-Table.");
         }
         sqlContext.getSqlTokens().add(new TableToken(beginPosition, literals));
-        sqlContext.getTables().add(tableContext);
+        sqlContext.getTables().add(table);
     }
     
     /**
@@ -286,7 +286,7 @@ public class SQLParser extends AbstractParser {
         SQLExpr right = parseExpression(sqlContext);
         // TODO 如果有多表,且找不到column是哪个表的,则不加入condition,以后需要解析binding table
         if ((1 == sqlContext.getTables().size() || left instanceof SQLPropertyExpr) && (right instanceof SQLNumberExpr || right instanceof SQLTextExpr || right instanceof SQLPlaceholderExpr)) {
-            Optional<ShardingColumnContext> column = sqlContext.findColumn(left);
+            Optional<ShardingColumn> column = sqlContext.findColumn(left);
             if (column.isPresent() && shardingRule.isShardingColumn(column.get())) {
                 sqlContext.getConditionContext().add(new ConditionContext.Condition(column.get(), right));
             }
@@ -303,7 +303,7 @@ public class SQLParser extends AbstractParser {
             }
             rights.add(parseExpression(sqlContext));
         } while (!equalAny(Symbol.RIGHT_PAREN));
-        Optional<ShardingColumnContext> column = sqlContext.findColumn(left);
+        Optional<ShardingColumn> column = sqlContext.findColumn(left);
         if (column.isPresent() && shardingRule.isShardingColumn(column.get())) {
             sqlContext.getConditionContext().add(new ConditionContext.Condition(column.get(), rights));
         }
@@ -316,7 +316,7 @@ public class SQLParser extends AbstractParser {
         rights.add(parseExpression(sqlContext));
         accept(DefaultKeyword.AND);
         rights.add(parseExpression(sqlContext));
-        Optional<ShardingColumnContext> column = sqlContext.findColumn(left);
+        Optional<ShardingColumn> column = sqlContext.findColumn(left);
         if (column.isPresent() && shardingRule.isShardingColumn(column.get())) {
             sqlContext.getConditionContext().add(new ConditionContext.Condition(column.get(), rights.get(0), rights.get(1)));
         }

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

@@ -45,7 +45,7 @@ public abstract class AbstractSQLContext implements SQLContext {
     
     private final SQLType type;
     
-    private final List<TableContext> tables = new ArrayList<>();
+    private final List<Table> tables = new ArrayList<>();
     
     private ConditionContext conditionContext = new ConditionContext();
     
@@ -57,7 +57,7 @@ public abstract class AbstractSQLContext implements SQLContext {
     }
     
     @Override
-    public Optional<ShardingColumnContext> findColumn(final SQLExpr expr) {
+    public Optional<ShardingColumn> findColumn(final SQLExpr expr) {
         if (expr instanceof SQLPropertyExpr) {
             return Optional.fromNullable(getColumnWithQualifiedName((SQLPropertyExpr) expr));
         }
@@ -67,18 +67,18 @@ public abstract class AbstractSQLContext implements SQLContext {
         return Optional.absent();
     }
     
-    private ShardingColumnContext getColumnWithQualifiedName(final SQLPropertyExpr expr) {
-        Optional<TableContext> table = findTable((expr.getOwner()).getName());
+    private ShardingColumn getColumnWithQualifiedName(final SQLPropertyExpr expr) {
+        Optional<Table> table = findTable((expr.getOwner()).getName());
         return expr.getOwner() instanceof SQLIdentifierExpr && table.isPresent() ? createColumn(expr.getName(), table.get().getName()) : null;
     }
     
-    private Optional<TableContext> findTable(final String tableNameOrAlias) {
-        Optional<TableContext> tableFromName = findTableFromName(tableNameOrAlias);
+    private Optional<Table> findTable(final String tableNameOrAlias) {
+        Optional<Table> tableFromName = findTableFromName(tableNameOrAlias);
         return tableFromName.isPresent() ? tableFromName : findTableFromAlias(tableNameOrAlias);
     }
     
-    private Optional<TableContext> findTableFromName(final String name) {
-        for (TableContext each : tables) {
+    private Optional<Table> findTableFromName(final String name) {
+        for (Table each : tables) {
             if (each.getName().equalsIgnoreCase(SQLUtil.getExactlyValue(name))) {
                 return Optional.of(each);
             }
@@ -86,8 +86,8 @@ public abstract class AbstractSQLContext implements SQLContext {
         return Optional.absent();
     }
     
-    private Optional<TableContext> findTableFromAlias(final String alias) {
-        for (TableContext each : tables) {
+    private Optional<Table> findTableFromAlias(final String alias) {
+        for (Table each : tables) {
             if (each.getAlias().isPresent() && each.getAlias().get().equalsIgnoreCase(SQLUtil.getExactlyValue(alias))) {
                 return Optional.of(each);
             }
@@ -95,12 +95,12 @@ public abstract class AbstractSQLContext implements SQLContext {
         return Optional.absent();
     }
     
-    private ShardingColumnContext getColumnWithoutAlias(final SQLIdentifierExpr expr) {
+    private ShardingColumn getColumnWithoutAlias(final SQLIdentifierExpr expr) {
         return 1 == tables.size() ? createColumn(expr.getName(), tables.iterator().next().getName()) : null;
     }
     
-    private ShardingColumnContext createColumn(final String columnName, final String tableName) {
-        return new ShardingColumnContext(SQLUtil.getExactlyValue(columnName), SQLUtil.getExactlyValue(tableName));
+    private ShardingColumn createColumn(final String columnName, final String tableName) {
+        return new ShardingColumn(SQLUtil.getExactlyValue(columnName), SQLUtil.getExactlyValue(tableName));
     }
     
     @Override

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

@@ -41,7 +41,7 @@ import java.util.Map;
 @ToString
 public final class ConditionContext {
     
-    private final Map<ShardingColumnContext, Condition> conditions = new LinkedHashMap<>();
+    private final Map<ShardingColumn, Condition> conditions = new LinkedHashMap<>();
     
     /**
      * 添加条件对象.
@@ -51,7 +51,7 @@ public final class ConditionContext {
     // TODO 添加condition时进行判断, 比如:如果以存在 等于操作 的condition, 而已存在包含 =符号 的相同column的condition, 则不添加现有的condition, 而且删除原有condition
     public void add(final Condition condition) {
         // TODO 自关联有问题，表名可考虑使用别名对应
-        conditions.put(condition.getShardingColumnContext(), condition);
+        conditions.put(condition.getShardingColumn(), condition);
     }
     
     /**
@@ -62,7 +62,7 @@ public final class ConditionContext {
      * @return 条件对象
      */
     public Optional<Condition> find(final String table, final String column) {
-        return Optional.fromNullable(conditions.get(new ShardingColumnContext(column, table)));
+        return Optional.fromNullable(conditions.get(new ShardingColumn(column, table)));
     }
     
     /**
@@ -75,7 +75,7 @@ public final class ConditionContext {
     @EqualsAndHashCode
     public static final class Condition {
         
-        private final ShardingColumnContext shardingColumnContext;
+        private final ShardingColumn shardingColumn;
         
         private final ShardingOperator operator;
         
@@ -83,19 +83,19 @@ public final class ConditionContext {
         
         private final List<Integer> valueIndices = new LinkedList<>();
         
-        public Condition(final ShardingColumnContext shardingColumnContext, final SQLExpr sqlExpr) {
-            this(shardingColumnContext, ShardingOperator.EQUAL);
+        public Condition(final ShardingColumn shardingColumn, final SQLExpr sqlExpr) {
+            this(shardingColumn, ShardingOperator.EQUAL);
             initSQLExpr(sqlExpr);
         }
         
-        public Condition(final ShardingColumnContext shardingColumnContext, final SQLExpr beginSqlExpr, final SQLExpr endSqlExpr) {
-            this(shardingColumnContext, ShardingOperator.BETWEEN);
+        public Condition(final ShardingColumn shardingColumn, final SQLExpr beginSqlExpr, final SQLExpr endSqlExpr) {
+            this(shardingColumn, ShardingOperator.BETWEEN);
             initSQLExpr(beginSqlExpr);
             initSQLExpr(endSqlExpr);
         }
         
-        public Condition(final ShardingColumnContext shardingColumnContext, final List<SQLExpr> sqlExprs) {
-            this(shardingColumnContext, ShardingOperator.IN);
+        public Condition(final ShardingColumn shardingColumn, final List<SQLExpr> sqlExprs) {
+            this(shardingColumn, ShardingOperator.IN);
             for (SQLExpr each : sqlExprs) {
                 initSQLExpr(each);
             }

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

@@ -42,7 +42,7 @@ import java.util.LinkedList;
 @Setter
 public final class InsertSQLContext extends AbstractSQLContext {
     
-    private final Collection<ShardingColumnContext> shardingColumnContexts = new LinkedList<>();
+    private final Collection<ShardingColumn> shardingColumns = new LinkedList<>();
     
     private GeneratedKeyContext generatedKeyContext;
     
@@ -85,13 +85,13 @@ public final class InsertSQLContext extends AbstractSQLContext {
     private void appendGenerateKeyToken(final ShardingRule shardingRule, final TableRule tableRule, final ItemsToken valuesToken) {
         Number generatedKey = shardingRule.generateKey(tableRule.getLogicTable());
         valuesToken.getItems().add(generatedKey.toString());
-        addCondition(shardingRule, new ShardingColumnContext(tableRule.getGenerateKeyColumn(), tableRule.getLogicTable(), true), new SQLNumberExpr(generatedKey));
+        addCondition(shardingRule, new ShardingColumn(tableRule.getGenerateKeyColumn(), tableRule.getLogicTable()), new SQLNumberExpr(generatedKey));
         generatedKeyContext = new GeneratedKeyContext(tableRule.getLogicTable(), -1, generatedKey);
     }
     
     private void appendGenerateKeyToken(final ShardingRule shardingRule, final TableRule tableRule, final ItemsToken valuesToken, final int parametersSize) {
         valuesToken.getItems().add("?");
-        addCondition(shardingRule, new ShardingColumnContext(tableRule.getGenerateKeyColumn(), tableRule.getLogicTable(), true), new SQLPlaceholderExpr(parametersSize));
+        addCondition(shardingRule, new ShardingColumn(tableRule.getGenerateKeyColumn(), tableRule.getLogicTable()), new SQLPlaceholderExpr(parametersSize));
         generatedKeyContext = new GeneratedKeyContext(tableRule.getGenerateKeyColumn(), parametersSize, null);
     }
     
@@ -104,9 +104,9 @@ public final class InsertSQLContext extends AbstractSQLContext {
         return Optional.absent();
     }
     
-    private void addCondition(final ShardingRule shardingRule, final ShardingColumnContext shardingColumnContext, final SQLExpr sqlExpr) {
-        if (shardingRule.isShardingColumn(shardingColumnContext)) {
-            getConditionContext().add(new ConditionContext.Condition(shardingColumnContext, sqlExpr));
+    private void addCondition(final ShardingRule shardingRule, final ShardingColumn shardingColumn, final SQLExpr sqlExpr) {
+        if (shardingRule.isShardingColumn(shardingColumn)) {
+            getConditionContext().add(new ConditionContext.Condition(shardingColumn, sqlExpr));
         }
     }
 }

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

@@ -43,7 +43,7 @@ public interface SQLContext {
      * 
      * @return 表解析对象集合
      */
-    List<TableContext> getTables();
+    List<Table> getTables();
     
     /**
      * 获取条件对象上下文.
@@ -65,7 +65,7 @@ public interface SQLContext {
      * @param expr SQL表达式
      * @return 列对象
      */
-    Optional<ShardingColumnContext> findColumn(SQLExpr expr);
+    Optional<ShardingColumn> findColumn(SQLExpr expr);
     
     /**
      * 获取排序上下文集合.

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

@@ -17,27 +17,21 @@
 
 package com.dangdang.ddframe.rdb.sharding.parsing.parser.context;
 
-import lombok.AllArgsConstructor;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 
 /**
- * 列对象.
+ * 分片列对象.
  *
  * @author zhangliang
  */
-@AllArgsConstructor
+@RequiredArgsConstructor
 @Getter
-@EqualsAndHashCode(exclude = "generateKey")
-public final class ShardingColumnContext {
+@EqualsAndHashCode
+public final class ShardingColumn {
     
     private final String columnName;
     
     private final String tableName;
-    
-    private final boolean generateKey;
-    
-    public ShardingColumnContext(final String columnName, final String tableName) {
-        this(columnName, tableName, false);
-    }
 }

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

@@ -25,13 +25,12 @@ import lombok.ToString;
 /**
  * 表上下文.
  * 
- * @author gaohongtao
  * @author zhangliang
  */
 @RequiredArgsConstructor
 @Getter
 @ToString
-public final class TableContext {
+public final class Table {
     
     private final String name;
     

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

@@ -26,7 +26,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.Symbol;
 import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.TokenType;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumnContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLExpr;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLIgnoreExpr;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLNumberExpr;
@@ -58,7 +58,7 @@ public final class MySQLInsertParser extends AbstractInsertParser {
         ConditionContext conditionContext = new ConditionContext();
         do {
             getSqlParser().getLexer().nextToken();
-            ShardingColumnContext shardingColumnContext = new ShardingColumnContext(
+            ShardingColumn shardingColumn = new ShardingColumn(
                     SQLUtil.getExactlyValue(getSqlParser().getLexer().getCurrentToken().getLiterals()), getSqlContext().getTables().get(0).getName());
             getSqlParser().getLexer().nextToken();
             getSqlParser().accept(Symbol.EQ);
@@ -79,8 +79,8 @@ public final class MySQLInsertParser extends AbstractInsertParser {
             }
             getSqlParser().getLexer().nextToken();
             if (getSqlParser().equalAny(Symbol.COMMA, DefaultKeyword.ON, Assist.END)) {
-                if (getShardingRule().isShardingColumn(shardingColumnContext)) {
-                    conditionContext.add(new ConditionContext.Condition(shardingColumnContext, sqlExpr));
+                if (getShardingRule().isShardingColumn(shardingColumn)) {
+                    conditionContext.add(new ConditionContext.Condition(shardingColumn, sqlExpr));
                 }
             } else {
                 getSqlParser().skipUntil(Symbol.COMMA, DefaultKeyword.ON);

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

@@ -26,7 +26,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.TokenType;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GeneratedKeyContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.InsertSQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumnContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLExpr;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLNumberExpr;
@@ -113,7 +113,7 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
     }
     
     private void parseColumns() {
-        Collection<ShardingColumnContext> result = new LinkedList<>();
+        Collection<ShardingColumn> result = new LinkedList<>();
         if (sqlParser.equalAny(Symbol.LEFT_PAREN)) {
             String tableName = sqlContext.getTables().get(0).getName();
             Optional<String> generateKeyColumn = shardingRule.getGenerateKeyColumn(tableName);
@@ -121,7 +121,7 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
             do {
                 sqlParser.getLexer().nextToken();
                 String columnName = SQLUtil.getExactlyValue(sqlParser.getLexer().getCurrentToken().getLiterals());
-                result.add(new ShardingColumnContext(columnName, tableName));
+                result.add(new ShardingColumn(columnName, tableName));
                 sqlParser.getLexer().nextToken();
                 if (generateKeyColumn.isPresent() && generateKeyColumn.get().equalsIgnoreCase(columnName)) {
                     generateKeyColumnIndex = count;
@@ -131,7 +131,7 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
             sqlContext.setColumnsListLastPosition(sqlParser.getLexer().getCurrentToken().getEndPosition() - sqlParser.getLexer().getCurrentToken().getLiterals().length());
             sqlParser.getLexer().nextToken();
         }
-        sqlContext.getShardingColumnContexts().addAll(result);
+        sqlContext.getShardingColumns().addAll(result);
     }
     
     protected Set<TokenType> getValuesKeywords() {
@@ -153,7 +153,7 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
             } while (sqlParser.skipIfEqual(Symbol.COMMA));
             sqlContext.setValuesListLastPosition(sqlParser.getLexer().getCurrentToken().getEndPosition() - sqlParser.getLexer().getCurrentToken().getLiterals().length());
             int count = 0;
-            for (ShardingColumnContext each : sqlContext.getShardingColumnContexts()) {
+            for (ShardingColumn each : sqlContext.getShardingColumns()) {
                 SQLExpr sqlExpr = sqlExprs.get(count);
                 if (getShardingRule().isShardingColumn(each)) {
                     conditionContext.add(new ConditionContext.Condition(each, sqlExpr));
@@ -170,12 +170,12 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
         while (sqlParser.equalAny(Symbol.COMMA));
     }
     
-    private GeneratedKeyContext createGeneratedKeyContext(final ShardingColumnContext shardingColumnContext, final SQLExpr sqlExpr) {
+    private GeneratedKeyContext createGeneratedKeyContext(final ShardingColumn shardingColumn, final SQLExpr sqlExpr) {
         GeneratedKeyContext result;
         if (sqlExpr instanceof SQLPlaceholderExpr) {
-            result = new GeneratedKeyContext(shardingColumnContext.getColumnName(), ((SQLPlaceholderExpr) sqlExpr).getIndex(), null);
+            result = new GeneratedKeyContext(shardingColumn.getColumnName(), ((SQLPlaceholderExpr) sqlExpr).getIndex(), null);
         } else if (sqlExpr instanceof SQLNumberExpr) {
-            result = new GeneratedKeyContext(shardingColumnContext.getColumnName(), -1, ((SQLNumberExpr) sqlExpr).getNumber());
+            result = new GeneratedKeyContext(shardingColumn.getColumnName(), -1, ((SQLNumberExpr) sqlExpr).getNumber());
         } else {
             throw new ShardingJdbcException("Generated key only support number.");
         }

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

@@ -29,7 +29,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GroupByContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderByContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SelectItemContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SelectSQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLExpr;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expr.SQLIdentifierExpr;
@@ -291,7 +291,7 @@ public abstract class AbstractSelectParser implements SQLStatementParser {
         }
         // FIXME 根据shardingRule过滤table
         sqlContext.getSqlTokens().add(new TableToken(beginPosition, literals));
-        sqlContext.getTables().add(new TableContext(SQLUtil.getExactlyValue(literals), sqlParser.parseAlias()));
+        sqlContext.getTables().add(new Table(SQLUtil.getExactlyValue(literals), sqlParser.parseAlias()));
     }
     
     protected void parseJoinTable() {
@@ -316,7 +316,7 @@ public abstract class AbstractSelectParser implements SQLStatementParser {
             return;
         }
         SQLPropertyExpr sqlPropertyExpr = (SQLPropertyExpr) sqlExpr;
-        for (TableContext each : sqlContext.getTables()) {
+        for (Table each : sqlContext.getTables()) {
             if (each.getName().equalsIgnoreCase(SQLUtil.getExactlyValue(sqlPropertyExpr.getOwner().getName()))) {
                 sqlContext.getSqlTokens().add(new TableToken(startPosition, sqlPropertyExpr.getOwner().getName()));
             }

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

@@ -20,7 +20,7 @@ package com.dangdang.ddframe.rdb.sharding.rewrite;
 
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.LimitContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+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;
@@ -52,7 +52,7 @@ public final class SQLRewriteEngine {
     public SQLRewriteEngine(final String originalSQL, final SQLContext sqlContext) {
         this.originalSQL = originalSQL;
         sqlTokens.addAll(sqlContext.getSqlTokens());
-        for (TableContext each : sqlContext.getTables()) {
+        for (Table each : sqlContext.getTables()) {
             tableNames.add(each.getName());
         }
         limit = sqlContext.getLimitContext();

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

@@ -26,7 +26,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GeneratedKeyContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.InsertSQLContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import com.dangdang.ddframe.rdb.sharding.rewrite.SQLBuilder;
 import com.dangdang.ddframe.rdb.sharding.rewrite.SQLRewriteEngine;
 import com.dangdang.ddframe.rdb.sharding.routing.RoutingResult;
@@ -108,10 +108,10 @@ public final class ParsingSQLRouter implements SQLRouter {
     }
     
     private RoutingResult route(final List<Object> parameters, final SQLContext sqlContext) {
-        Set<String> logicTables = Sets.newLinkedHashSet(Collections2.transform(sqlContext.getTables(), new Function<TableContext, String>() {
+        Set<String> logicTables = Sets.newLinkedHashSet(Collections2.transform(sqlContext.getTables(), new Function<Table, String>() {
             
             @Override
-            public String apply(final TableContext input) {
+            public String apply(final Table input) {
                 return input.getName();
             }
         }));

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/routing/type/single/SingleRouterUtil.java

@@ -47,11 +47,11 @@ public final class SingleRouterUtil {
             case EQUAL:
             case IN:
                 if (1 == conditionValues.size()) {
-                    return new ShardingValue<Comparable<?>>(condition.getShardingColumnContext().getTableName(), condition.getShardingColumnContext().getColumnName(), conditionValues.get(0));
+                    return new ShardingValue<Comparable<?>>(condition.getShardingColumn().getTableName(), condition.getShardingColumn().getColumnName(), conditionValues.get(0));
                 }
-                return new ShardingValue<>(condition.getShardingColumnContext().getTableName(), condition.getShardingColumnContext().getColumnName(), conditionValues);
+                return new ShardingValue<>(condition.getShardingColumn().getTableName(), condition.getShardingColumn().getColumnName(), conditionValues);
             case BETWEEN:
-                return new ShardingValue<>(condition.getShardingColumnContext().getTableName(), condition.getShardingColumnContext().getColumnName(), 
+                return new ShardingValue<>(condition.getShardingColumn().getTableName(), condition.getShardingColumn().getColumnName(), 
                         Range.range(conditionValues.get(0), BoundType.CLOSED, conditionValues.get(1), BoundType.CLOSED));
             default:
                 throw new UnsupportedOperationException(condition.getOperator().getExpression());

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/api/rule/ShardingRuleTest.java

@@ -21,7 +21,7 @@ import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingS
 import com.dangdang.ddframe.rdb.sharding.api.strategy.database.NoneDatabaseShardingAlgorithm;
 import com.dangdang.ddframe.rdb.sharding.api.strategy.table.NoneTableShardingAlgorithm;
 import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumnContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import org.junit.Test;
 
 import javax.sql.DataSource;
@@ -195,31 +195,31 @@ public final class ShardingRuleTest {
     @Test
     public void assertIsShardingColumnForDefaultDatabaseShardingStrategy() {
         assertTrue(ShardingRule.builder().databaseShardingStrategy(createDatabaseShardingStrategy()).dataSourceRule(createDataSourceRule())
-                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumnContext("column", "")));
+                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumn("column", "")));
     }
     
     @Test
     public void assertIsShardingColumnForDefaultTableShardingStrategy() {
         assertTrue(ShardingRule.builder().tableShardingStrategy(createTableShardingStrategy()).dataSourceRule(createDataSourceRule())
-                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumnContext("column", "")));
+                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumn("column", "")));
     }
     
     @Test
     public void assertIsShardingColumnForDatabaseShardingStrategy() {
         assertTrue(ShardingRule.builder().dataSourceRule(createDataSourceRule())
-                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumnContext("column", "logicTable")));
+                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumn("column", "logicTable")));
     }
     
     @Test
     public void assertIsShardingColumnForTableShardingStrategy() {
         assertTrue(ShardingRule.builder().dataSourceRule(createDataSourceRule())
-                .tableRules(Collections.singletonList(createTableRuleWithTableStrategies())).build().isShardingColumn(new ShardingColumnContext("column", "logicTable")));
+                .tableRules(Collections.singletonList(createTableRuleWithTableStrategies())).build().isShardingColumn(new ShardingColumn("column", "logicTable")));
     }
     
     @Test
     public void assertIsNotShardingColumn() {
         assertFalse(ShardingRule.builder().dataSourceRule(createDataSourceRule())
-                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumnContext("column", "otherTable")));
+                .tableRules(Collections.singletonList(createTableRuleWithAllStrategies())).build().isShardingColumn(new ShardingColumn("column", "otherTable")));
     }
     
     private ShardingRule createShardingRule() {

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/merger/AllMergerTests.java

@@ -50,7 +50,7 @@ import org.junit.runners.Suite;
     ComparableAggregationUnitTest.class, 
     AccumulationAggregationUnitTest.class, 
     AverageAggregationUnitTest.class, 
-    UnsupportedOperationDerivedShardingColumnContextResultSetTest.class, 
+    UnsupportedOperationDerivedShardingColumnResultSetTest.class, 
     MemoryResultSetTest.class, 
     ResultSetUtilTest.class
     })

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/merger/UnsupportedOperationDerivedShardingColumnContextResultSetTest.java → sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/merger/UnsupportedOperationDerivedShardingColumnResultSetTest.java

@@ -27,7 +27,7 @@ import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
 import java.util.HashMap;
 
-public class UnsupportedOperationDerivedShardingColumnContextResultSetTest extends AbstractShardingDataBasesOnlyDBUnitTest {
+public class UnsupportedOperationDerivedShardingColumnResultSetTest extends AbstractShardingDataBasesOnlyDBUnitTest {
     
     private ResultSet actual;
     

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

@@ -30,8 +30,8 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.LimitContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderByContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SelectSQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumnContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
 import com.google.common.base.Strings;
@@ -58,7 +58,7 @@ public abstract class AbstractBaseParseTest {
     
     private final String expectedSQL;
     
-    private final Iterator<TableContext> expectedTables;
+    private final Iterator<Table> expectedTables;
     
     private final Iterator<ConditionContext> expectedConditionContexts;
     
@@ -71,7 +71,7 @@ public abstract class AbstractBaseParseTest {
     private final LimitContext limit;
     
     protected AbstractBaseParseTest(final String testCaseName, final String sql, final String expectedSQL,
-                                 final Collection<TableContext> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
+                                    final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
         this.testCaseName = testCaseName;
         this.sql = sql;
         this.expectedSQL = expectedSQL;
@@ -113,11 +113,11 @@ public abstract class AbstractBaseParseTest {
         result[0] = assertObj.getId();
         result[1] = assertObj.getSql();
         result[2] = assertObj.getExpectedSQL();
-        result[3] = Lists.transform(assertObj.getTables(), new Function<com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Table, TableContext>() {
+        result[3] = Lists.transform(assertObj.getTables(), new Function<com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Table, Table>() {
             
             @Override
-            public TableContext apply(final com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Table input) {
-                return new TableContext(input.getName(), Optional.of(input.getAlias()));
+            public Table apply(final com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Table input) {
+                return new Table(input.getName(), Optional.of(input.getAlias()));
             }
         });
         if (null == assertObj.getConditionContexts()) {
@@ -133,7 +133,7 @@ public abstract class AbstractBaseParseTest {
                     }
                     for (com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Condition each : input.getConditions()) {
                         ConditionContext.Condition condition = new ConditionContext.Condition(
-                                new ShardingColumnContext(each.getColumnName(), each.getTableName()), ShardingOperator.valueOf(each.getOperator().toUpperCase()));
+                                new ShardingColumn(each.getColumnName(), each.getTableName()), ShardingOperator.valueOf(each.getOperator().toUpperCase()));
                         condition.getValues().addAll(Lists.transform(each.getValues(), new Function<Value, Comparable<?>>() {
                             
                             @Override

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

@@ -23,7 +23,7 @@ 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.ConditionContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -34,7 +34,7 @@ import java.util.Collection;
 @RunWith(Parameterized.class)
 public final class MySQLPreparedStatementForOneParameterTest extends AbstractBaseParseTest {
     
-    public MySQLPreparedStatementForOneParameterTest(final String testCaseName, final String sql, final String expectedSQL, final Collection<TableContext> expectedTables, 
+    public MySQLPreparedStatementForOneParameterTest(final String testCaseName, final String sql, final String expectedSQL, final Collection<Table> expectedTables, 
             final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
         super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLContext);
     }

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

@@ -23,7 +23,7 @@ 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.ConditionContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -35,8 +35,8 @@ import java.util.Collection;
 public final class MySQLPreparedStatementForTowParametersTest extends AbstractBaseParseTest {
     
     public MySQLPreparedStatementForTowParametersTest(
-            final String testCaseName, final String sql, final String expectedSQL, 
-            final Collection<TableContext> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
+            final String testCaseName, final String sql, final String expectedSQL,
+            final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
         super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLContext);
     }
     

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

@@ -23,7 +23,7 @@ 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.ConditionContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -35,8 +35,8 @@ import java.util.Collection;
 public final class MySQLStatementTest extends AbstractBaseParseTest {
     
     public MySQLStatementTest(
-            final String testCaseName, final String sql, final String expectedSQL, 
-            final Collection<TableContext> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
+            final String testCaseName, final String sql, final String expectedSQL,
+            final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
         super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLContext);
     }
     

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

@@ -23,7 +23,7 @@ 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.ConditionContext;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.SQLContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.TableContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Table;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -36,8 +36,8 @@ import java.util.Collection;
 public final class OrParseTest extends AbstractBaseParseTest {
     
     public OrParseTest(
-            final String testCaseName, final String sql, final String expectedSQL, 
-            final Collection<TableContext> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
+            final String testCaseName, final String sql, final String expectedSQL,
+            final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLContext expectedSQLContext) {
         super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLContext);
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/routing/type/single/SingleRouterUtilTest.java

@@ -20,7 +20,7 @@ package com.dangdang.ddframe.rdb.sharding.routing.type.single;
 import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
 import com.dangdang.ddframe.rdb.sharding.constant.ShardingOperator;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumnContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import org.junit.Test;
 
 import java.util.Collections;
@@ -33,12 +33,12 @@ public class SingleRouterUtilTest {
     
     @Test
     public void testConvertConditionToShardingValue() throws Exception {
-        ConditionContext.Condition condition = new ConditionContext.Condition(new ShardingColumnContext("test", "test"), ShardingOperator.EQUAL);
+        ConditionContext.Condition condition = new ConditionContext.Condition(new ShardingColumn("test", "test"), ShardingOperator.EQUAL);
         condition.getValues().add(1);
         ShardingValue<?> shardingValue = SingleRouterUtil.convertConditionToShardingValue(condition, Collections.emptyList());
         assertThat(shardingValue.getType(), is(ShardingValue.ShardingValueType.SINGLE));
         assertThat((Integer) shardingValue.getValue(), is(1));
-        condition = new ConditionContext.Condition(new ShardingColumnContext("test", "test"), ShardingOperator.IN);
+        condition = new ConditionContext.Condition(new ShardingColumn("test", "test"), ShardingOperator.IN);
         condition.getValues().add(1);
         condition.getValues().add(2);
         shardingValue = SingleRouterUtil.convertConditionToShardingValue(condition, Collections.emptyList());
@@ -46,7 +46,7 @@ public class SingleRouterUtilTest {
         Iterator<?> iterator = shardingValue.getValues().iterator();
         assertThat((Integer) iterator.next(), is(1));
         assertThat((Integer) iterator.next(), is(2));
-        condition = new ConditionContext.Condition(new ShardingColumnContext("test", "test"), ShardingOperator.BETWEEN);
+        condition = new ConditionContext.Condition(new ShardingColumn("test", "test"), ShardingOperator.BETWEEN);
         condition.getValues().add(1);
         condition.getValues().add(2);
         shardingValue = SingleRouterUtil.convertConditionToShardingValue(condition, Collections.emptyList());