ConditionContext => Condition

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

@@ -22,8 +22,7 @@ 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.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 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;
@@ -34,6 +33,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLNumberExpr
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLPlaceholderExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLPropertyExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLTextExpression;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.TableToken;
 import com.dangdang.ddframe.rdb.sharding.util.SQLUtil;
 import com.google.common.base.Optional;
@@ -250,7 +250,6 @@ public class SQLParser extends AbstractParser {
     }
     
     private void parseConditions(final SQLStatement sqlStatement) {
-        sqlStatement.setConditionContext(new ConditionContext());
         do {
             parseComparisonCondition(sqlStatement);
         } while (skipIfEqual(DefaultKeyword.AND));
@@ -285,10 +284,11 @@ public class SQLParser extends AbstractParser {
         getLexer().nextToken();
         SQLExpression right = parseExpression(sqlStatement);
         // TODO 如果有多表,且找不到column是哪个表的,则不加入condition,以后需要解析binding table
-        if ((1 == sqlStatement.getTables().size() || left instanceof SQLPropertyExpression) && (right instanceof SQLNumberExpression || right instanceof SQLTextExpression || right instanceof SQLPlaceholderExpression)) {
+        if ((1 == sqlStatement.getTables().size() || left instanceof SQLPropertyExpression)
+                && (right instanceof SQLNumberExpression || right instanceof SQLTextExpression || right instanceof SQLPlaceholderExpression)) {
             Optional<ShardingColumn> column = sqlStatement.findColumn(left);
             if (column.isPresent() && shardingRule.isShardingColumn(column.get())) {
-                sqlStatement.getConditionContext().add(new ConditionContext.Condition(column.get(), right));
+                sqlStatement.add(new Condition(column.get(), right));
             }
         }
     }
@@ -305,7 +305,7 @@ public class SQLParser extends AbstractParser {
         } while (!equalAny(Symbol.RIGHT_PAREN));
         Optional<ShardingColumn> column = sqlStatement.findColumn(left);
         if (column.isPresent() && shardingRule.isShardingColumn(column.get())) {
-            sqlStatement.getConditionContext().add(new ConditionContext.Condition(column.get(), rights));
+            sqlStatement.add(new Condition(column.get(), rights));
         }
         getLexer().nextToken();
     }
@@ -318,7 +318,7 @@ public class SQLParser extends AbstractParser {
         rights.add(parseExpression(sqlStatement));
         Optional<ShardingColumn> column = sqlStatement.findColumn(left);
         if (column.isPresent() && shardingRule.isShardingColumn(column.get())) {
-            sqlStatement.getConditionContext().add(new ConditionContext.Condition(column.get(), rights.get(0), rights.get(1)));
+            sqlStatement.add(new Condition(column.get(), rights.get(0), rights.get(1)));
         }
     }
     

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

+package com.dangdang.ddframe.rdb.sharding.parsing.parser.context;
+
+import com.dangdang.ddframe.rdb.sharding.constant.ShardingOperator;
+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;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLTextExpression;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 条件对象.
+ *
+ * @author zhangliang
+ */
+@RequiredArgsConstructor
+@Getter
+@EqualsAndHashCode
+public final class Condition {
+    
+    private final ShardingColumn shardingColumn;
+    
+    private final ShardingOperator operator;
+    
+    private final List<Comparable<?>> values = new LinkedList<>();
+    
+    private final List<Integer> valueIndices = new LinkedList<>();
+    
+    public Condition(final ShardingColumn shardingColumn, final SQLExpression sqlExpr) {
+        this(shardingColumn, ShardingOperator.EQUAL);
+        initSQLExpr(sqlExpr);
+    }
+    
+    public Condition(final ShardingColumn shardingColumn, final SQLExpression beginSqlExpr, final SQLExpression endSqlExpr) {
+        this(shardingColumn, ShardingOperator.BETWEEN);
+        initSQLExpr(beginSqlExpr);
+        initSQLExpr(endSqlExpr);
+    }
+    
+    public Condition(final ShardingColumn shardingColumn, final List<SQLExpression> sqlExprs) {
+        this(shardingColumn, ShardingOperator.IN);
+        for (SQLExpression each : sqlExprs) {
+            initSQLExpr(each);
+        }
+    }
+    
+    private void initSQLExpr(final SQLExpression sqlExpression) {
+        if (sqlExpression instanceof SQLPlaceholderExpression) {
+            valueIndices.add(((SQLPlaceholderExpression) sqlExpression).getIndex());
+        } else if (sqlExpression instanceof SQLTextExpression) {
+            values.add(((SQLTextExpression) sqlExpression).getText());
+        } else if (sqlExpression instanceof SQLNumberExpression) {
+            values.add((Comparable) ((SQLNumberExpression) sqlExpression).getNumber());
+        }
+    }
+    
+    /**
+     * 获取分片值.
+     *
+     * @param parameters 参数列表
+     * @return 分片值
+     */
+    public List<Comparable<?>> getValues(final List<Object> parameters) {
+        List<Comparable<?>> result = new LinkedList<>(values);
+        for (int each : valueIndices) {
+            Object parameter = parameters.get(each);
+            if (parameter instanceof Comparable<?>) {
+                result.add((Comparable<?>) parameter);
+            }
+        }
+        return result;
+    }
+}

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/context/ConditionContext.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;
-
-import com.dangdang.ddframe.rdb.sharding.constant.ShardingOperator;
-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;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLTextExpression;
-import com.google.common.base.Optional;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import lombok.ToString;
-
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 条件对象上下文.
- * 
- * @author zhangliang
- */
-@ToString
-public final class ConditionContext {
-    
-    private final Map<ShardingColumn, Condition> conditions = new LinkedHashMap<>();
-    
-    /**
-     * 添加条件对象.
-     * 
-     * @param condition 条件对象
-     */
-    // TODO 添加condition时进行判断, 比如:如果以存在 等于操作 的condition, 而已存在包含 =符号 的相同column的condition, 则不添加现有的condition, 而且删除原有condition
-    public void add(final Condition condition) {
-        // TODO 自关联有问题，表名可考虑使用别名对应
-        conditions.put(condition.getShardingColumn(), condition);
-    }
-    
-    /**
-     * 查找条件对象.
-     * 
-     * @param table 表名称
-     * @param column 列名称
-     * @return 条件对象
-     */
-    public Optional<Condition> find(final String table, final String column) {
-        return Optional.fromNullable(conditions.get(new ShardingColumn(column, table)));
-    }
-    
-    /**
-     * 条件对象.
-     * 
-     * @author gaohongtao
-     */
-    @RequiredArgsConstructor
-    @Getter
-    @EqualsAndHashCode
-    public static final class Condition {
-        
-        private final ShardingColumn shardingColumn;
-        
-        private final ShardingOperator operator;
-        
-        private final List<Comparable<?>> values = new LinkedList<>();
-        
-        private final List<Integer> valueIndices = new LinkedList<>();
-        
-        public Condition(final ShardingColumn shardingColumn, final SQLExpression sqlExpr) {
-            this(shardingColumn, ShardingOperator.EQUAL);
-            initSQLExpr(sqlExpr);
-        }
-        
-        public Condition(final ShardingColumn shardingColumn, final SQLExpression beginSqlExpr, final SQLExpression endSqlExpr) {
-            this(shardingColumn, ShardingOperator.BETWEEN);
-            initSQLExpr(beginSqlExpr);
-            initSQLExpr(endSqlExpr);
-        }
-        
-        public Condition(final ShardingColumn shardingColumn, final List<SQLExpression> sqlExprs) {
-            this(shardingColumn, ShardingOperator.IN);
-            for (SQLExpression each : sqlExprs) {
-                initSQLExpr(each);
-            }
-        }
-        
-        private void initSQLExpr(final SQLExpression sqlExpression) {
-            if (sqlExpression instanceof SQLPlaceholderExpression) {
-                valueIndices.add(((SQLPlaceholderExpression) sqlExpression).getIndex());
-            } else if (sqlExpression instanceof SQLTextExpression) {
-                values.add(((SQLTextExpression) sqlExpression).getText());
-            } else if (sqlExpression instanceof SQLNumberExpression) {
-                values.add((Comparable) ((SQLNumberExpression) sqlExpression).getNumber());
-            }
-        }
-        
-        /**
-         * 获取分片值.
-         * 
-         * @param parameters 参数列表
-         * @return 分片值
-         */
-        public List<Comparable<?>> getValues(final List<Object> parameters) {
-            List<Comparable<?>> result = new LinkedList<>(values);
-            for (int each : valueIndices) {
-                Object parameter = parameters.get(each);
-                if (parameter instanceof Comparable<?>) {
-                    result.add((Comparable<?>) parameter);
-                }
-            }
-            return result;
-        }
-    }
-}

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

@@ -25,7 +25,7 @@ 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.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.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLIgnoreExpression;
@@ -55,7 +55,6 @@ public final class MySQLInsertParser extends AbstractInsertParser {
     }
     
     private void parseInsertSet() {
-        ConditionContext conditionContext = new ConditionContext();
         do {
             getSqlParser().getLexer().nextToken();
             ShardingColumn shardingColumn = new ShardingColumn(
@@ -80,13 +79,12 @@ public final class MySQLInsertParser extends AbstractInsertParser {
             getSqlParser().getLexer().nextToken();
             if (getSqlParser().equalAny(Symbol.COMMA, DefaultKeyword.ON, Assist.END)) {
                 if (getShardingRule().isShardingColumn(shardingColumn)) {
-                    conditionContext.add(new ConditionContext.Condition(shardingColumn, sqlExpression));
+                    getInsertStatement().add(new Condition(shardingColumn, sqlExpression));
                 }
             } else {
                 getSqlParser().skipUntil(Symbol.COMMA, DefaultKeyword.ON);
             }
         } while (getSqlParser().equalAny(Symbol.COMMA));
-        getInsertStatement().setConditionContext(conditionContext);
     }
     
     @Override

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

@@ -19,7 +19,7 @@ package com.dangdang.ddframe.rdb.sharding.parsing.parser.statement;
 
 import com.dangdang.ddframe.rdb.sharding.constant.SQLType;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.AggregationSelectItem;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
+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;
@@ -33,12 +33,13 @@ import com.dangdang.ddframe.rdb.sharding.util.SQLUtil;
 import com.google.common.base.Optional;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import lombok.Setter;
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * SQL语句对象抽象类.
@@ -47,14 +48,13 @@ import java.util.List;
  */
 @RequiredArgsConstructor
 @Getter
-@Setter
 public abstract class AbstractSQLStatement implements SQLStatement {
     
     private final SQLType type;
     
     private final List<Table> tables = new ArrayList<>();
     
-    private ConditionContext conditionContext = new ConditionContext();
+    private final Map<ShardingColumn, Condition> conditions = new LinkedHashMap<>();
     
     private final List<SQLToken> sqlTokens = new LinkedList<>();
     
@@ -63,6 +63,18 @@ public abstract class AbstractSQLStatement implements SQLStatement {
         return type;
     }
     
+    @Override
+    // TODO 添加condition时进行判断, 比如:如果以存在 等于操作 的condition, 而已存在包含 =符号 的相同column的condition, 则不添加现有的condition, 而且删除原有condition
+    public void add(final Condition condition) {
+        // TODO 自关联有问题，表名可考虑使用别名对应
+        conditions.put(condition.getShardingColumn(), condition);
+    }
+    
+    @Override
+    public Optional<Condition> find(final String table, final String column) {
+        return Optional.fromNullable(conditions.get(new ShardingColumn(column, table)));
+    }
+    
     @Override
     public Optional<ShardingColumn> findColumn(final SQLExpression sqlExpression) {
         if (sqlExpression instanceof SQLPropertyExpression) {

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

@@ -19,7 +19,7 @@ package com.dangdang.ddframe.rdb.sharding.parsing.parser.statement;
 
 import com.dangdang.ddframe.rdb.sharding.constant.SQLType;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.AggregationSelectItem;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
+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;
@@ -53,18 +53,20 @@ public interface SQLStatement {
     List<Table> getTables();
     
     /**
-     * 获取条件对象上下文.
-     * 
-     * @return 条件对象上下文
+     * 添加条件对象.
+     *
+     * @param condition 条件对象
      */
-    ConditionContext getConditionContext();
+    void add(Condition condition);
     
     /**
-     * 设置条件对象上下文.
+     * 查找条件对象.
      *
-     * @param conditionContext  条件对象上下文
+     * @param table 表名称
+     * @param column 列名称
+     * @return 条件对象
      */
-    void setConditionContext(ConditionContext conditionContext);
+    Optional<Condition> find(String table, String column);
     
     /**
      * 获取列对象.

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

@@ -23,16 +23,16 @@ import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.Assist;
 import com.dangdang.ddframe.rdb.sharding.parsing.lexer.token.DefaultKeyword;
 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.context.ConditionContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GeneratedKey;
 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.expression.SQLExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLNumberExpression;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLPlaceholderExpression;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatementParser;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.GeneratedKeyToken;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.token.ItemsToken;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatementParser;
 import com.dangdang.ddframe.rdb.sharding.util.SQLUtil;
 import com.google.common.base.Optional;
 import com.google.common.collect.Sets;
@@ -146,7 +146,6 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
             sqlParser.getLexer().nextToken();
             sqlParser.accept(Symbol.LEFT_PAREN);
             List<SQLExpression> sqlExpressions = new LinkedList<>();
-            ConditionContext conditionContext = new ConditionContext();
             do {
                 sqlExpressions.add(sqlParser.parseExpression());
             } while (sqlParser.skipIfEqual(Symbol.COMMA));
@@ -155,7 +154,7 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
             for (ShardingColumn each : insertStatement.getShardingColumns()) {
                 SQLExpression sqlExpression = sqlExpressions.get(count);
                 if (getShardingRule().isShardingColumn(each)) {
-                    conditionContext.add(new ConditionContext.Condition(each, sqlExpression));
+                    insertStatement.add(new Condition(each, sqlExpression));
                 }
                 if (generateKeyColumnIndex == count) {
                     insertStatement.setGeneratedKey(createGeneratedKey(each, sqlExpression));
@@ -164,7 +163,6 @@ public abstract class AbstractInsertParser implements SQLStatementParser {
             }
             sqlParser.accept(Symbol.RIGHT_PAREN);
             parsed = true;
-            insertStatement.setConditionContext(conditionContext);
         }
         while (sqlParser.equalAny(Symbol.COMMA));
     }

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

@@ -20,7 +20,7 @@ package com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.insert;
 import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
 import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
 import com.dangdang.ddframe.rdb.sharding.constant.SQLType;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.GeneratedKey;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLExpression;
@@ -110,7 +110,7 @@ public final class InsertStatement extends AbstractSQLStatement {
     
     private void addCondition(final ShardingRule shardingRule, final ShardingColumn shardingColumn, final SQLExpression sqlExpr) {
         if (shardingRule.isShardingColumn(shardingColumn)) {
-            getConditionContext().add(new ConditionContext.Condition(shardingColumn, sqlExpr));
+            add(new Condition(shardingColumn, sqlExpr));
         }
     }
 }

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

@@ -116,13 +116,13 @@ public final class ParsingSQLRouter implements SQLRouter {
             }
         }));
         if (1 == logicTables.size()) {
-            return new SingleTableRouter(shardingRule, parameters, logicTables.iterator().next(), sqlStatement.getConditionContext(), sqlStatement.getType()).route();
+            return new SingleTableRouter(shardingRule, parameters, logicTables.iterator().next(), sqlStatement, sqlStatement.getType()).route();
         }
         if (shardingRule.isAllBindingTables(logicTables)) {
-            return new BindingTablesRouter(shardingRule, parameters, logicTables, sqlStatement.getConditionContext(), sqlStatement.getType()).route();
+            return new BindingTablesRouter(shardingRule, parameters, logicTables, sqlStatement, sqlStatement.getType()).route();
         }
         // TODO 可配置是否执行笛卡尔积
-        return new MixedTablesRouter(shardingRule, parameters, logicTables, sqlStatement.getConditionContext(), sqlStatement.getType()).route();
+        return new MixedTablesRouter(shardingRule, parameters, logicTables, sqlStatement, sqlStatement.getType()).route();
     }
     
     private void logSQLRouteResult(final SQLRouteResult routeResult, final List<Object> parameters) {

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/routing/type/binding/BindingTablesRouter.java

@@ -20,7 +20,7 @@ package com.dangdang.ddframe.rdb.sharding.routing.type.binding;
 import com.dangdang.ddframe.rdb.sharding.api.rule.BindingTableRule;
 import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
 import com.dangdang.ddframe.rdb.sharding.constant.SQLType;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import com.dangdang.ddframe.rdb.sharding.routing.type.single.SingleTableRouter;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
@@ -43,17 +43,17 @@ public final class BindingTablesRouter {
     
     private final Collection<String> logicTables;
     
-    private final ConditionContext conditionContext;
+    private final SQLStatement sqlStatement;
     
     private final BindingTableRule bindingTableRule;
     
     private final SQLType sqlType;
     
-    public BindingTablesRouter(final ShardingRule shardingRule, final List<Object> parameters, final Collection<String> logicTables, final ConditionContext conditionContext, final SQLType sqlType) {
+    public BindingTablesRouter(final ShardingRule shardingRule, final List<Object> parameters, final Collection<String> logicTables, final SQLStatement sqlStatement, final SQLType sqlType) {
         this.shardingRule = shardingRule;
         this.parameters = parameters;
         this.logicTables = logicTables;
-        this.conditionContext = conditionContext;
+        this.sqlStatement = sqlStatement;
         this.sqlType = sqlType;
         Optional<BindingTableRule> optionalBindingTableRule = shardingRule.findBindingTableRule(logicTables.iterator().next());
         Preconditions.checkState(optionalBindingTableRule.isPresent());
@@ -69,7 +69,7 @@ public final class BindingTablesRouter {
         BindingRoutingResult result = null;
         for (final String each : logicTables) {
             if (null == result) {
-                result = new BindingRoutingResult(new SingleTableRouter(shardingRule, parameters, each, conditionContext, sqlType).route());
+                result = new BindingRoutingResult(new SingleTableRouter(shardingRule, parameters, each, sqlStatement, sqlType).route());
             } else {
                 result.bind(bindingTableRule, each);
             }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/routing/type/mixed/MixedTablesRouter.java

@@ -19,7 +19,7 @@ package com.dangdang.ddframe.rdb.sharding.routing.type.mixed;
 
 import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
 import com.dangdang.ddframe.rdb.sharding.constant.SQLType;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import com.dangdang.ddframe.rdb.sharding.routing.RoutingResult;
 import com.dangdang.ddframe.rdb.sharding.routing.type.binding.BindingTablesRouter;
 import com.dangdang.ddframe.rdb.sharding.routing.type.single.SingleRoutingResult;
@@ -47,7 +47,7 @@ public final class MixedTablesRouter {
     
     private final Collection<String> logicTables;
     
-    private final ConditionContext conditionContext;
+    private final SQLStatement sqlStatement;
     
     private final SQLType sqlType;
     
@@ -62,11 +62,11 @@ public final class MixedTablesRouter {
         Collection<String> remainingTables = new ArrayList<>(logicTables);
         Collection<SingleRoutingResult> result = new ArrayList<>(logicTables.size());
         if (1 < bindingTables.size()) {
-            result.add(new BindingTablesRouter(shardingRule, parameters, bindingTables, conditionContext, sqlType).route());
+            result.add(new BindingTablesRouter(shardingRule, parameters, bindingTables, sqlStatement, sqlType).route());
             remainingTables.removeAll(bindingTables);
         }
         for (String each : remainingTables) {
-            SingleRoutingResult routingResult = new SingleTableRouter(shardingRule, parameters, each, conditionContext, sqlType).route();
+            SingleRoutingResult routingResult = new SingleTableRouter(shardingRule, parameters, each, sqlStatement, sqlType).route();
             if (null != routingResult) {
                 result.add(routingResult);
             }

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

@@ -18,7 +18,7 @@
 package com.dangdang.ddframe.rdb.sharding.routing.type.single;
 
 import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.google.common.collect.BoundType;
 import com.google.common.collect.Range;
 import lombok.AccessLevel;
@@ -41,7 +41,7 @@ public final class SingleRouterUtil {
      * @param parameters 参数列表
      * @return 分片值对象
      */
-    public static ShardingValue<?> convertConditionToShardingValue(final ConditionContext.Condition condition, final List<Object> parameters) {
+    public static ShardingValue<?> convertConditionToShardingValue(final Condition condition, final List<Object> parameters) {
         List<Comparable<?>> conditionValues = condition.getValues(parameters);
         switch (condition.getOperator()) {
             case EQUAL:

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

@@ -26,10 +26,11 @@ 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.constant.SQLType;
 import com.dangdang.ddframe.rdb.sharding.hint.HintManagerHolder;
 import com.dangdang.ddframe.rdb.sharding.hint.ShardingKey;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.constant.SQLType;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import lombok.extern.slf4j.Slf4j;
@@ -57,17 +58,17 @@ public final class SingleTableRouter {
     
     private final String logicTable;
     
-    private final ConditionContext conditionContext;
+    private final SQLStatement sqlStatement;
     
     private final TableRule tableRule;
     
     private final SQLType sqlType;
     
-    public SingleTableRouter(final ShardingRule shardingRule, final List<Object> parameters, final String logicTable, final ConditionContext conditionContext, final SQLType sqlType) {
+    public SingleTableRouter(final ShardingRule shardingRule, final List<Object> parameters, final String logicTable, final SQLStatement sqlStatement, final SQLType sqlType) {
         this.shardingRule = shardingRule;
         this.parameters = parameters;
         this.logicTable = logicTable;
-        this.conditionContext = conditionContext;
+        this.sqlStatement = sqlStatement;
         this.sqlType = sqlType;
         Optional<TableRule> tableRuleOptional = shardingRule.tryFindTableRule(logicTable);
         if (tableRuleOptional.isPresent()) {
@@ -159,7 +160,7 @@ public final class SingleTableRouter {
     private List<ShardingValue<?>> getShardingValues(final Collection<String> shardingColumns) {
         List<ShardingValue<?>> result = new ArrayList<>(shardingColumns.size());
         for (String each : shardingColumns) {
-            Optional<ConditionContext.Condition> condition = conditionContext.find(logicTable, each);
+            Optional<Condition> condition = sqlStatement.find(logicTable, each);
             if (condition.isPresent()) {
                 result.add(SingleRouterUtil.convertConditionToShardingValue(condition.get(), parameters));
             }

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

@@ -24,14 +24,14 @@ import com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Assert;
 import com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Asserts;
 import com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Value;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.AggregationSelectItem;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ConditionContext;
+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.statement.SQLStatement;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.select.SelectStatement;
 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.statement.SQLStatement;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.select.SelectStatement;
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
 import com.google.common.base.Strings;
@@ -47,6 +47,8 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
 
 public abstract class AbstractBaseParseTest {
     
@@ -60,7 +62,7 @@ public abstract class AbstractBaseParseTest {
     
     private final Iterator<Table> expectedTables;
     
-    private final Iterator<ConditionContext> expectedConditionContexts;
+    private final Iterator<Condition> expectedConditions;
     
     private final Iterator<OrderBy> orderByList;
     
@@ -71,12 +73,12 @@ public abstract class AbstractBaseParseTest {
     private final Limit limit;
     
     protected AbstractBaseParseTest(final String testCaseName, final String sql, final String expectedSQL,
-                                    final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLStatement expectedSQLStatement) {
+                                    final Collection<Table> expectedTables, final Collection<Condition> expectedConditions, final SQLStatement expectedSQLStatement) {
         this.testCaseName = testCaseName;
         this.sql = sql;
         this.expectedSQL = expectedSQL;
         this.expectedTables = expectedTables.iterator();
-        this.expectedConditionContexts = expectedConditionContext.iterator();
+        this.expectedConditions = expectedConditions.iterator();
         this.orderByList = expectedSQLStatement.getOrderByList().iterator();
         this.groupByList = expectedSQLStatement.getGroupByList().iterator();
         this.aggregationColumns = expectedSQLStatement.getAggregationSelectItems().iterator();
@@ -117,22 +119,22 @@ public abstract class AbstractBaseParseTest {
             
             @Override
             public Table apply(final com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Table input) {
-                return new Table(input.getName(), Optional.of(input.getAlias()));
+                return new Table(input.getName(), Optional.fromNullable(input.getAlias()));
             }
         });
         if (null == assertObj.getConditionContexts()) {
-            result[4] = Collections.<ConditionContext>emptyList();
+            result[4] = Collections.<Condition>emptyList();
         } else {
-            result[4] = Lists.transform(assertObj.getConditionContexts(), new Function<com.dangdang.ddframe.rdb.sharding.parsing.jaxb.ConditionContext, ConditionContext>() {
+            result[4] = Lists.transform(assertObj.getConditionContexts(), new Function<com.dangdang.ddframe.rdb.sharding.parsing.jaxb.ConditionContext, List<Condition>>() {
                 
                 @Override
-                public ConditionContext apply(final com.dangdang.ddframe.rdb.sharding.parsing.jaxb.ConditionContext input) {
-                    ConditionContext result = new ConditionContext();
+                public List<Condition> apply(final com.dangdang.ddframe.rdb.sharding.parsing.jaxb.ConditionContext input) {
+                    List<Condition> result = new LinkedList<>();
                     if (null == input.getConditions()) {
                         return result;
                     }
                     for (com.dangdang.ddframe.rdb.sharding.parsing.jaxb.Condition each : input.getConditions()) {
-                        ConditionContext.Condition condition = new ConditionContext.Condition(
+                        Condition condition = new Condition(
                                 new ShardingColumn(each.getColumnName(), each.getTableName()), ShardingOperator.valueOf(each.getOperator().toUpperCase()));
                         condition.getValues().addAll(Lists.transform(each.getValues(), new Function<Value, Comparable<?>>() {
                             

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

@@ -17,16 +17,15 @@
 
 package com.dangdang.ddframe.rdb.sharding.parsing.jaxb;
 
-import java.util.List;
+import lombok.Getter;
+import lombok.Setter;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlAttribute;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElementWrapper;
-
-import lombok.Getter;
-import lombok.Setter;
+import java.util.List;
 
 @Getter
 @Setter

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

@@ -21,22 +21,23 @@ import com.dangdang.ddframe.rdb.sharding.api.fixture.ShardingRuleMockBuilder;
 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.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
+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.statement.SQLStatement;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
 import java.util.Collection;
+import java.util.List;
 
 @RunWith(Parameterized.class)
 public final class MySQLPreparedStatementForOneParameterTest extends AbstractBaseParseTest {
     
-    public MySQLPreparedStatementForOneParameterTest(final String testCaseName, final String sql, final String expectedSQL, final Collection<Table> expectedTables, 
-            final Collection<ConditionContext> expectedConditionContext, final SQLStatement expectedSQLStatement) {
-        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLStatement);
+    public MySQLPreparedStatementForOneParameterTest(final String testCaseName, final String sql, final String expectedSQL, final Collection<Table> expectedTables,
+                                                     final List<Condition> expectedConditions, final SQLStatement expectedSQLStatement) {
+        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditions, expectedSQLStatement);
     }
     
     @Parameters(name = "{0}")

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

@@ -21,23 +21,24 @@ import com.dangdang.ddframe.rdb.sharding.api.fixture.ShardingRuleMockBuilder;
 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.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
+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.statement.SQLStatement;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
 import java.util.Collection;
+import java.util.List;
 
 @RunWith(Parameterized.class)
 public final class MySQLPreparedStatementForTowParametersTest extends AbstractBaseParseTest {
     
     public MySQLPreparedStatementForTowParametersTest(
             final String testCaseName, final String sql, final String expectedSQL,
-            final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLStatement expectedSQLStatement) {
-        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLStatement);
+            final Collection<Table> expectedTables, final List<Condition> expectedConditions, final SQLStatement expectedSQLStatement) {
+        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditions, expectedSQLStatement);
     }
     
     @Parameters(name = "{0}")

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

@@ -21,23 +21,24 @@ import com.dangdang.ddframe.rdb.sharding.api.fixture.ShardingRuleMockBuilder;
 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.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
+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.statement.SQLStatement;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
 import java.util.Collection;
+import java.util.List;
 
 @RunWith(Parameterized.class)
 public final class MySQLStatementTest extends AbstractBaseParseTest {
     
     public MySQLStatementTest(
             final String testCaseName, final String sql, final String expectedSQL,
-            final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLStatement expectedSQLStatement) {
-        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLStatement);
+            final Collection<Table> expectedTables, final List<Condition> expectedConditions, final SQLStatement expectedSQLStatement) {
+        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditions, expectedSQLStatement);
     }
     
     @Parameters(name = "{0}")

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

@@ -21,9 +21,9 @@ import com.dangdang.ddframe.rdb.sharding.api.fixture.ShardingRuleMockBuilder;
 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.ConditionContext;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
+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.statement.SQLStatement;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -31,14 +31,15 @@ import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
 import java.util.Collection;
+import java.util.List;
 
 @RunWith(Parameterized.class)
 public final class OrParseTest extends AbstractBaseParseTest {
     
     public OrParseTest(
             final String testCaseName, final String sql, final String expectedSQL,
-            final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final SQLStatement expectedSQLStatement) {
-        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditionContext, expectedSQLStatement);
+            final Collection<Table> expectedTables, final List<Condition> expectedConditions, final SQLStatement expectedSQLStatement) {
+        super(testCaseName, sql, expectedSQL, expectedTables, expectedConditions, expectedSQLStatement);
     }
     
     @Parameters(name = "{0}")

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

@@ -21,7 +21,7 @@ import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
 import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.constant.ShardingOperator;
 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.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.delete.DeleteStatement;
 import com.dangdang.ddframe.rdb.sharding.rewrite.SQLRewriteEngine;
 import org.junit.Test;
@@ -61,16 +61,16 @@ 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"));
-        ConditionContext.Condition condition1 = deleteStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition1 = deleteStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition1.getValues().size(), is(1));
         assertThat(condition1.getValues().get(0), is((Comparable) 1));
-        ConditionContext.Condition condition2 = deleteStatement.getConditionContext().find("TABLE_XXX", "field2").get();
+        Condition condition2 = deleteStatement.find("TABLE_XXX", "field2").get();
         assertThat(condition2.getOperator(), is(ShardingOperator.IN));
         assertThat(condition2.getValues().size(), is(2));
         assertThat(condition2.getValues().get(0), is((Comparable) 1));
         assertThat(condition2.getValues().get(1), is((Comparable) 3));
-        ConditionContext.Condition condition3 = deleteStatement.getConditionContext().find("TABLE_XXX", "field3").get();
+        Condition condition3 = deleteStatement.find("TABLE_XXX", "field3").get();
         assertThat(condition3.getOperator(), is(ShardingOperator.BETWEEN));
         assertThat(condition3.getValues().size(), is(2));
         assertThat(condition3.getValues().get(0), is((Comparable) 5));
@@ -92,18 +92,18 @@ 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"));
-        ConditionContext.Condition condition1 = deleteStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition1 = deleteStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
         assertTrue(condition1.getValues().isEmpty());
         assertThat(condition1.getValueIndices().size(), is(1));
         assertThat(condition1.getValueIndices().get(0), is(1));
-        ConditionContext.Condition condition2 = deleteStatement.getConditionContext().find("TABLE_XXX", "field2").get();
+        Condition condition2 = deleteStatement.find("TABLE_XXX", "field2").get();
         assertThat(condition2.getOperator(), is(ShardingOperator.IN));
         assertTrue(condition2.getValues().isEmpty());
         assertThat(condition2.getValueIndices().size(), is(2));
         assertThat(condition2.getValueIndices().get(0), is(3));
         assertThat(condition2.getValueIndices().get(1), is(4));
-        ConditionContext.Condition condition3 = deleteStatement.getConditionContext().find("TABLE_XXX", "field3").get();
+        Condition condition3 = deleteStatement.find("TABLE_XXX", "field3").get();
         assertThat(condition3.getOperator(), is(ShardingOperator.BETWEEN));
         assertTrue(condition3.getValues().isEmpty());
         assertThat(condition3.getValueIndices().size(), is(2));
@@ -152,7 +152,7 @@ public final class DeleteStatementParserTest extends AbstractStatementParserTest
         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());
-        ConditionContext.Condition condition = deleteStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition = deleteStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues().size(), is(1));
         assertThat(condition.getValues().get(0), is((Comparable) 1));

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

@@ -26,9 +26,9 @@ import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.constant.ShardingOperator;
 import com.dangdang.ddframe.rdb.sharding.keygen.fixture.IncrementKeyGenerator;
 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.statement.insert.InsertStatement;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.insert.InsertStatement;
 import com.dangdang.ddframe.rdb.sharding.rewrite.SQLRewriteEngine;
 import org.junit.Test;
 
@@ -98,7 +98,7 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
     
     private void assertInsertStatementWithoutParameter(final InsertStatement insertStatement) {
         assertThat(insertStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        ConditionContext.Condition condition = insertStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition = insertStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues().size(), is(1));
         assertThat(condition.getValues().get(0), is((Comparable) 10));
@@ -106,7 +106,7 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
     
     private void assertInsertStatementWithParameter(final InsertStatement insertStatement) {
         assertThat(insertStatement.getTables().get(0).getName(), is("TABLE_XXX"));
-        ConditionContext.Condition condition = insertStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition = insertStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertTrue(condition.getValues().isEmpty());
         assertThat(condition.getValueIndices().size(), is(1));
@@ -160,7 +160,7 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
         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());
-        ConditionContext.Condition condition = insertStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition = insertStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues().size(), is(1));
         assertThat(condition.getValues().get(0), is((Comparable) 1));

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

@@ -21,9 +21,9 @@ import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
 import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.constant.ShardingOperator;
 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.statement.update.UpdateStatement;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.update.UpdateStatement;
 import com.dangdang.ddframe.rdb.sharding.rewrite.SQLRewriteEngine;
 import org.junit.Test;
 
@@ -62,16 +62,16 @@ 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"));
-        ConditionContext.Condition condition1 = updateStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition1 = updateStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition1.getValues().size(), is(1));
         assertThat(condition1.getValues().get(0), is((Comparable) 1));
-        ConditionContext.Condition condition2 = updateStatement.getConditionContext().find("TABLE_XXX", "field2").get();
+        Condition condition2 = updateStatement.find("TABLE_XXX", "field2").get();
         assertThat(condition2.getOperator(), is(ShardingOperator.IN));
         assertThat(condition2.getValues().size(), is(2));
         assertThat(condition2.getValues().get(0), is((Comparable) 1));
         assertThat(condition2.getValues().get(1), is((Comparable) 3));
-        ConditionContext.Condition condition3 = updateStatement.getConditionContext().find("TABLE_XXX", "field3").get();
+        Condition condition3 = updateStatement.find("TABLE_XXX", "field3").get();
         assertThat(condition3.getOperator(), is(ShardingOperator.BETWEEN));
         assertThat(condition3.getValues().size(), is(2));
         assertThat(condition3.getValues().get(0), is((Comparable) 5));
@@ -93,18 +93,18 @@ 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"));
-        ConditionContext.Condition condition1 = updateStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition1 = updateStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition1.getOperator(), is(ShardingOperator.EQUAL));
         assertTrue(condition1.getValues().isEmpty());
         assertThat(condition1.getValueIndices().size(), is(1));
         assertThat(condition1.getValueIndices().get(0), is(2));
-        ConditionContext.Condition condition2 = updateStatement.getConditionContext().find("TABLE_XXX", "field2").get();
+        Condition condition2 = updateStatement.find("TABLE_XXX", "field2").get();
         assertThat(condition2.getOperator(), is(ShardingOperator.IN));
         assertTrue(condition2.getValues().isEmpty());
         assertThat(condition2.getValueIndices().size(), is(2));
         assertThat(condition2.getValueIndices().get(0), is(4));
         assertThat(condition2.getValueIndices().get(1), is(5));
-        ConditionContext.Condition condition3 = updateStatement.getConditionContext().find("TABLE_XXX", "field3").get();
+        Condition condition3 = updateStatement.find("TABLE_XXX", "field3").get();
         assertThat(condition3.getOperator(), is(ShardingOperator.BETWEEN));
         assertTrue(condition3.getValues().isEmpty());
         assertThat(condition3.getValueIndices().size(), is(2));
@@ -146,7 +146,7 @@ public final class UpdateStatementParserTest extends AbstractStatementParserTest
         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());
-        ConditionContext.Condition condition = updateStatement.getConditionContext().find("TABLE_XXX", "field1").get();
+        Condition condition = updateStatement.find("TABLE_XXX", "field1").get();
         assertThat(condition.getOperator(), is(ShardingOperator.EQUAL));
         assertThat(condition.getValues().size(), is(1));
         assertThat(condition.getValues().get(0), is((Comparable) 1));

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

@@ -19,7 +19,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.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.ShardingColumn;
 import org.junit.Test;
 
@@ -33,12 +33,12 @@ public class SingleRouterUtilTest {
     
     @Test
     public void testConvertConditionToShardingValue() throws Exception {
-        ConditionContext.Condition condition = new ConditionContext.Condition(new ShardingColumn("test", "test"), ShardingOperator.EQUAL);
+        Condition condition = new 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 ShardingColumn("test", "test"), ShardingOperator.IN);
+        condition = new 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 ShardingColumn("test", "test"), ShardingOperator.BETWEEN);
+        condition = new Condition(new ShardingColumn("test", "test"), ShardingOperator.BETWEEN);
         condition.getValues().add(1);
         condition.getValues().add(2);
         shardingValue = SingleRouterUtil.convertConditionToShardingValue(condition, Collections.emptyList());