exprParser => sqlParser

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

@@ -29,13 +29,13 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
  */
 public final class MySQLDeleteParser extends AbstractDeleteParser {
     
-    public MySQLDeleteParser(final SQLParser exprParser) {
-        super(exprParser);
+    public MySQLDeleteParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenDeleteAndTable() {
-        getExprParser().skipAll(MySQLKeyword.LOW_PRIORITY, MySQLKeyword.QUICK, MySQLKeyword.IGNORE);
-        getExprParser().skipIfEqual(DefaultKeyword.FROM);
+        getSqlParser().skipAll(MySQLKeyword.LOW_PRIORITY, MySQLKeyword.QUICK, MySQLKeyword.IGNORE);
+        getSqlParser().skipIfEqual(DefaultKeyword.FROM);
     }
 }

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

@@ -46,8 +46,8 @@ import java.util.Set;
  */
 public final class MySQLInsertParser extends AbstractInsertParser {
     
-    public MySQLInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser exprParser) {
-        super(shardingRule, parameters, exprParser);
+    public MySQLInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser sqlParser) {
+        super(shardingRule, parameters, sqlParser);
     }
     
     @Override
@@ -59,34 +59,34 @@ public final class MySQLInsertParser extends AbstractInsertParser {
         Collection<String> autoIncrementColumns = getShardingRule().getAutoIncrementColumns(getSqlContext().getTables().get(0).getName());
         ConditionContext conditionContext = new ConditionContext();
         do {
-            getExprParser().getLexer().nextToken();
+            getSqlParser().getLexer().nextToken();
             ShardingColumnContext shardingColumnContext = getColumn(autoIncrementColumns);
-            getExprParser().getLexer().nextToken();
-            getExprParser().accept(Symbol.EQ);
+            getSqlParser().getLexer().nextToken();
+            getSqlParser().accept(Symbol.EQ);
             SQLExpr sqlExpr;
-            if (getExprParser().equalAny(Literals.INT)) {
-                sqlExpr = new SQLNumberExpr(Integer.parseInt(getExprParser().getLexer().getCurrentToken().getLiterals()));
-            } else if (getExprParser().equalAny(Literals.FLOAT)) {
-                sqlExpr = new SQLNumberExpr(Double.parseDouble(getExprParser().getLexer().getCurrentToken().getLiterals()));
-            } else if (getExprParser().equalAny(Literals.CHARS)) {
-                sqlExpr = new SQLTextExpr(getExprParser().getLexer().getCurrentToken().getLiterals());
-            } else if (getExprParser().equalAny(DefaultKeyword.NULL)) {
+            if (getSqlParser().equalAny(Literals.INT)) {
+                sqlExpr = new SQLNumberExpr(Integer.parseInt(getSqlParser().getLexer().getCurrentToken().getLiterals()));
+            } else if (getSqlParser().equalAny(Literals.FLOAT)) {
+                sqlExpr = new SQLNumberExpr(Double.parseDouble(getSqlParser().getLexer().getCurrentToken().getLiterals()));
+            } else if (getSqlParser().equalAny(Literals.CHARS)) {
+                sqlExpr = new SQLTextExpr(getSqlParser().getLexer().getCurrentToken().getLiterals());
+            } else if (getSqlParser().equalAny(DefaultKeyword.NULL)) {
                 sqlExpr = new SQLIgnoreExpr();
-            } else if (getExprParser().equalAny(Symbol.QUESTION)) {
-                sqlExpr = new SQLPlaceholderExpr(getExprParser().getParametersIndex(), getExprParser().getParameters().get(getExprParser().getParametersIndex()));
-                getExprParser().setParametersIndex(getExprParser().getParametersIndex() + 1);
+            } else if (getSqlParser().equalAny(Symbol.QUESTION)) {
+                sqlExpr = new SQLPlaceholderExpr(getSqlParser().getParametersIndex(), getSqlParser().getParameters().get(getSqlParser().getParametersIndex()));
+                getSqlParser().setParametersIndex(getSqlParser().getParametersIndex() + 1);
             } else {
                 throw new UnsupportedOperationException("");
             }
-            getExprParser().getLexer().nextToken();
-            if (getExprParser().equalAny(Symbol.COMMA, DefaultKeyword.ON, Assist.END)) {
+            getSqlParser().getLexer().nextToken();
+            if (getSqlParser().equalAny(Symbol.COMMA, DefaultKeyword.ON, Assist.END)) {
                 if (getShardingRule().isShardingColumn(shardingColumnContext)) {
                     conditionContext.add(new ConditionContext.Condition(shardingColumnContext, sqlExpr));
                 }
             } else {
-                getExprParser().skipUntil(Symbol.COMMA, DefaultKeyword.ON);
+                getSqlParser().skipUntil(Symbol.COMMA, DefaultKeyword.ON);
             }
-        } while (getExprParser().equalAny(Symbol.COMMA));
+        } while (getSqlParser().equalAny(Symbol.COMMA));
         getSqlContext().setConditionContext(conditionContext);
     }
     

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

@@ -27,16 +27,16 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
 
 public class MySQLSelectParser extends AbstractSelectParser {
     
-    public MySQLSelectParser(final SQLParser exprParser) {
-        super(exprParser);
+    public MySQLSelectParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     public void query() {
-        if (getExprParser().equalAny(DefaultKeyword.SELECT)) {
-            getExprParser().getLexer().nextToken();
+        if (getSqlParser().equalAny(DefaultKeyword.SELECT)) {
+            getSqlParser().getLexer().nextToken();
             parseDistinct();
-            getExprParser().skipAll(MySQLKeyword.HIGH_PRIORITY, DefaultKeyword.STRAIGHT_JOIN, MySQLKeyword.SQL_SMALL_RESULT, MySQLKeyword.SQL_BIG_RESULT, MySQLKeyword.SQL_BUFFER_RESULT,
+            getSqlParser().skipAll(MySQLKeyword.HIGH_PRIORITY, DefaultKeyword.STRAIGHT_JOIN, MySQLKeyword.SQL_SMALL_RESULT, MySQLKeyword.SQL_BIG_RESULT, MySQLKeyword.SQL_BUFFER_RESULT,
                     MySQLKeyword.SQL_CACHE, MySQLKeyword.SQL_NO_CACHE, MySQLKeyword.SQL_CALC_FOUND_ROWS);
             parseSelectList();
             skipToFrom();
@@ -45,59 +45,59 @@ public class MySQLSelectParser extends AbstractSelectParser {
         parseWhere();
         parseGroupBy();
         getSqlContext().getOrderByContexts().addAll(parseOrderBy(getSqlContext()));
-        if (getExprParser().equalAny(MySQLKeyword.LIMIT)) {
-            getSqlContext().setLimitContext(((MySQLParser) getExprParser()).parseLimit(getParametersIndex()));
+        if (getSqlParser().equalAny(MySQLKeyword.LIMIT)) {
+            getSqlContext().setLimitContext(((MySQLParser) getSqlParser()).parseLimit(getParametersIndex()));
         }
-        if (getExprParser().equalAny(DefaultKeyword.PROCEDURE)) {
-            throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+        if (getSqlParser().equalAny(DefaultKeyword.PROCEDURE)) {
+            throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
         }
         queryRest();
     }
     
     private void skipToFrom() {
-        while (!getExprParser().equalAny(DefaultKeyword.FROM) && !getExprParser().equalAny(Assist.END)) {
-            getExprParser().getLexer().nextToken();
+        while (!getSqlParser().equalAny(DefaultKeyword.FROM) && !getSqlParser().equalAny(Assist.END)) {
+            getSqlParser().getLexer().nextToken();
         }
     }
     
     @Override
     protected void parseJoinTable() {
-        if (getExprParser().equalAny(DefaultKeyword.USING)) {
+        if (getSqlParser().equalAny(DefaultKeyword.USING)) {
             return;
         }
-        if (getExprParser().equalAny(DefaultKeyword.USE)) {
-            getExprParser().getLexer().nextToken();
+        if (getSqlParser().equalAny(DefaultKeyword.USE)) {
+            getSqlParser().getLexer().nextToken();
             parseIndexHint();
         }
-        if (getExprParser().equalAny(OracleKeyword.IGNORE)) {
-            getExprParser().getLexer().nextToken();
+        if (getSqlParser().equalAny(OracleKeyword.IGNORE)) {
+            getSqlParser().getLexer().nextToken();
             parseIndexHint();
         }
-        if (getExprParser().equalAny(OracleKeyword.FORCE)) {
-            getExprParser().getLexer().nextToken();
+        if (getSqlParser().equalAny(OracleKeyword.FORCE)) {
+            getSqlParser().getLexer().nextToken();
             parseIndexHint();
         }
         super.parseJoinTable();
     }
 
     private void parseIndexHint() {
-        if (getExprParser().equalAny(DefaultKeyword.INDEX)) {
-            getExprParser().getLexer().nextToken();
+        if (getSqlParser().equalAny(DefaultKeyword.INDEX)) {
+            getSqlParser().getLexer().nextToken();
         } else {
-            getExprParser().accept(DefaultKeyword.KEY);
+            getSqlParser().accept(DefaultKeyword.KEY);
         }
-        if (getExprParser().equalAny(DefaultKeyword.FOR)) {
-            getExprParser().getLexer().nextToken();
-            if (getExprParser().equalAny(DefaultKeyword.JOIN)) {
-                getExprParser().getLexer().nextToken();
-            } else if (getExprParser().equalAny(DefaultKeyword.ORDER)) {
-                getExprParser().getLexer().nextToken();
-                getExprParser().accept(DefaultKeyword.BY);
+        if (getSqlParser().equalAny(DefaultKeyword.FOR)) {
+            getSqlParser().getLexer().nextToken();
+            if (getSqlParser().equalAny(DefaultKeyword.JOIN)) {
+                getSqlParser().getLexer().nextToken();
+            } else if (getSqlParser().equalAny(DefaultKeyword.ORDER)) {
+                getSqlParser().getLexer().nextToken();
+                getSqlParser().accept(DefaultKeyword.BY);
             } else {
-                getExprParser().accept(DefaultKeyword.GROUP);
-                getExprParser().accept(DefaultKeyword.BY);
+                getSqlParser().accept(DefaultKeyword.GROUP);
+                getSqlParser().accept(DefaultKeyword.BY);
             }
         }
-        getExprParser().skipParentheses();
+        getSqlParser().skipParentheses();
     }
 }

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

@@ -28,12 +28,12 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
  */
 public final class MySQLUpdateParser extends AbstractUpdateParser {
     
-    public MySQLUpdateParser(final SQLParser exprParser) {
-        super(exprParser);
+    public MySQLUpdateParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenUpdateAndTable() {
-        getExprParser().skipAll(MySQLKeyword.LOW_PRIORITY, MySQLKeyword.IGNORE);
+        getSqlParser().skipAll(MySQLKeyword.LOW_PRIORITY, MySQLKeyword.IGNORE);
     }
 }

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

@@ -24,13 +24,13 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
 
 public class OracleDeleteParser extends AbstractDeleteParser {
     
-    public OracleDeleteParser(final SQLParser exprParser) {
-        super(exprParser);
+    public OracleDeleteParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenDeleteAndTable() {
-        getExprParser().skipIfEqual(DefaultKeyword.FROM);
-        getExprParser().skipIfEqual(OracleKeyword.ONLY);
+        getSqlParser().skipIfEqual(DefaultKeyword.FROM);
+        getSqlParser().skipIfEqual(OracleKeyword.ONLY);
     }
 }

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

@@ -35,8 +35,8 @@ import java.util.Set;
  */
 public final class OracleInsertParser extends AbstractInsertParser {
     
-    public OracleInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser exprParser) {
-        super(shardingRule, parameters, exprParser);
+    public OracleInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser sqlParser) {
+        super(shardingRule, parameters, sqlParser);
     }
     
     @Override

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

@@ -29,13 +29,13 @@ import com.google.common.base.Optional;
 
 public class OracleSelectParser extends AbstractSelectParser {
     
-    public OracleSelectParser(final SQLParser exprParser) {
-        super(exprParser);
+    public OracleSelectParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void customizedSelect() {
-        if (getExprParser().equalAny(DefaultKeyword.FOR)) {
+        if (getSqlParser().equalAny(DefaultKeyword.FOR)) {
             skipForUpdate();
         }
         if (getSqlContext().getOrderByContexts().isEmpty()) {
@@ -45,8 +45,8 @@ public class OracleSelectParser extends AbstractSelectParser {
     
     @Override
     public void query() {
-        if (getExprParser().equalAny(DefaultKeyword.SELECT)) {
-            getExprParser().getLexer().nextToken();
+        if (getSqlParser().equalAny(DefaultKeyword.SELECT)) {
+            getSqlParser().getLexer().nextToken();
             parseDistinct();
             parseSelectList();
         }
@@ -60,8 +60,8 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
     
     private void skipInto() {
-        if (getExprParser().equalAny(DefaultKeyword.INTO)) {
-            throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+        if (getSqlParser().equalAny(DefaultKeyword.INTO)) {
+            throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
         }
     }
     
@@ -73,36 +73,36 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
     
     private void skipStart() {
-        if (getExprParser().skipIfEqual(OracleKeyword.START)) {
-            getExprParser().accept(DefaultKeyword.WITH);
-            getExprParser().parseComparisonCondition(getSqlContext());
+        if (getSqlParser().skipIfEqual(OracleKeyword.START)) {
+            getSqlParser().accept(DefaultKeyword.WITH);
+            getSqlParser().parseComparisonCondition(getSqlContext());
         }
     }
     
     private void skipConnect() {
-        if (getExprParser().skipIfEqual(OracleKeyword.CONNECT)) {
-            getExprParser().accept(DefaultKeyword.BY);
-            getExprParser().skipIfEqual(OracleKeyword.PRIOR);
-            if (getExprParser().skipIfEqual(OracleKeyword.NOCYCLE)) {
-                getExprParser().skipIfEqual(OracleKeyword.PRIOR);
+        if (getSqlParser().skipIfEqual(OracleKeyword.CONNECT)) {
+            getSqlParser().accept(DefaultKeyword.BY);
+            getSqlParser().skipIfEqual(OracleKeyword.PRIOR);
+            if (getSqlParser().skipIfEqual(OracleKeyword.NOCYCLE)) {
+                getSqlParser().skipIfEqual(OracleKeyword.PRIOR);
             }
-            getExprParser().parseComparisonCondition(getSqlContext());
+            getSqlParser().parseComparisonCondition(getSqlContext());
         }
     }
     
     private void skipModelClause() {
-        if (!getExprParser().skipIfEqual(OracleKeyword.MODEL)) {
+        if (!getSqlParser().skipIfEqual(OracleKeyword.MODEL)) {
             return;
         }
         skipCellReferenceOptions();
-        getExprParser().skipIfEqual(OracleKeyword.RETURN);
-        getExprParser().skipIfEqual(DefaultKeyword.ALL);
-        getExprParser().skipIfEqual(OracleKeyword.UPDATED);
-        getExprParser().skipIfEqual(OracleKeyword.ROWS);
-        while (getExprParser().skipIfEqual(OracleKeyword.REFERENCE)) {
-            getExprParser().getLexer().nextToken();
-            getExprParser().accept(DefaultKeyword.ON);
-            getExprParser().skipParentheses();
+        getSqlParser().skipIfEqual(OracleKeyword.RETURN);
+        getSqlParser().skipIfEqual(DefaultKeyword.ALL);
+        getSqlParser().skipIfEqual(OracleKeyword.UPDATED);
+        getSqlParser().skipIfEqual(OracleKeyword.ROWS);
+        while (getSqlParser().skipIfEqual(OracleKeyword.REFERENCE)) {
+            getSqlParser().getLexer().nextToken();
+            getSqlParser().accept(DefaultKeyword.ON);
+            getSqlParser().skipParentheses();
             skipModelColumnClause();
             skipCellReferenceOptions();
         }
@@ -110,55 +110,55 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
     
     private void skipCellReferenceOptions() {
-        if (getExprParser().skipIfEqual(OracleKeyword.IGNORE)) {
-            getExprParser().accept(OracleKeyword.NAV);
-        } else if (getExprParser().skipIfEqual(OracleKeyword.KEEP)) {
-            getExprParser().accept(OracleKeyword.NAV);
+        if (getSqlParser().skipIfEqual(OracleKeyword.IGNORE)) {
+            getSqlParser().accept(OracleKeyword.NAV);
+        } else if (getSqlParser().skipIfEqual(OracleKeyword.KEEP)) {
+            getSqlParser().accept(OracleKeyword.NAV);
         }
-        if (getExprParser().skipIfEqual(DefaultKeyword.UNIQUE)) {
-            getExprParser().skipIfEqual(OracleKeyword.DIMENSION, OracleKeyword.SINGLE);
-            getExprParser().skipIfEqual(OracleKeyword.REFERENCE);
+        if (getSqlParser().skipIfEqual(DefaultKeyword.UNIQUE)) {
+            getSqlParser().skipIfEqual(OracleKeyword.DIMENSION, OracleKeyword.SINGLE);
+            getSqlParser().skipIfEqual(OracleKeyword.REFERENCE);
         }
     }
     
     private void skipMainModelClause() {
-        if (getExprParser().skipIfEqual(OracleKeyword.MAIN)) {
-            getExprParser().getLexer().nextToken();
+        if (getSqlParser().skipIfEqual(OracleKeyword.MAIN)) {
+            getSqlParser().getLexer().nextToken();
         }
         skipQueryPartitionClause();
-        getExprParser().accept(OracleKeyword.DIMENSION);
-        getExprParser().accept(DefaultKeyword.BY);
-        getExprParser().skipParentheses();
-        getExprParser().accept(OracleKeyword.MEASURES);
-        getExprParser().skipParentheses();
+        getSqlParser().accept(OracleKeyword.DIMENSION);
+        getSqlParser().accept(DefaultKeyword.BY);
+        getSqlParser().skipParentheses();
+        getSqlParser().accept(OracleKeyword.MEASURES);
+        getSqlParser().skipParentheses();
         skipCellReferenceOptions();
         skipModelRulesClause();
     }
 
     private void skipModelRulesClause() {
-        if (getExprParser().skipIfEqual(OracleKeyword.RULES)) {
-            getExprParser().skipIfEqual(DefaultKeyword.UPDATE);
-            getExprParser().skipIfEqual(OracleKeyword.UPSERT);
-            if (getExprParser().skipIfEqual(OracleKeyword.AUTOMATIC)) {
-                getExprParser().accept(DefaultKeyword.ORDER);
-            } else if (getExprParser().skipIfEqual(OracleKeyword.SEQUENTIAL)) {
-                getExprParser().accept(DefaultKeyword.ORDER);
+        if (getSqlParser().skipIfEqual(OracleKeyword.RULES)) {
+            getSqlParser().skipIfEqual(DefaultKeyword.UPDATE);
+            getSqlParser().skipIfEqual(OracleKeyword.UPSERT);
+            if (getSqlParser().skipIfEqual(OracleKeyword.AUTOMATIC)) {
+                getSqlParser().accept(DefaultKeyword.ORDER);
+            } else if (getSqlParser().skipIfEqual(OracleKeyword.SEQUENTIAL)) {
+                getSqlParser().accept(DefaultKeyword.ORDER);
             }
         }
-        if (getExprParser().skipIfEqual(DefaultKeyword.ITERATE)) {
-            getExprParser().skipParentheses();
-            if (getExprParser().skipIfEqual(DefaultKeyword.UNTIL)) {
-                getExprParser().skipParentheses();
+        if (getSqlParser().skipIfEqual(DefaultKeyword.ITERATE)) {
+            getSqlParser().skipParentheses();
+            if (getSqlParser().skipIfEqual(DefaultKeyword.UNTIL)) {
+                getSqlParser().skipParentheses();
             }
         }
-        getExprParser().skipParentheses();
+        getSqlParser().skipParentheses();
     }
     
     private void skipQueryPartitionClause() {
-        if (getExprParser().skipIfEqual(OracleKeyword.PARTITION)) {
-            getExprParser().accept(DefaultKeyword.BY);
-            if (getExprParser().equalAny(Symbol.LEFT_PAREN)) {
-                getExprParser().skipParentheses();
+        if (getSqlParser().skipIfEqual(OracleKeyword.PARTITION)) {
+            getSqlParser().accept(DefaultKeyword.BY);
+            if (getSqlParser().equalAny(Symbol.LEFT_PAREN)) {
+                getSqlParser().skipParentheses();
             } else {
                 throw new UnsupportedOperationException("Cannot support PARTITION BY without ()");
             }
@@ -166,42 +166,42 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
 
     private void skipModelColumnClause() {
-        throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+        throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
     }
     
     @Override
     protected void parseGroupBy() {
         // TODO
-//        if (getExprParser().equalAny(DefaultKeyword.GROUP)) {
-//            getExprParser().getLexer().nextToken();
-//            getExprParser().accept(DefaultKeyword.BY);
+//        if (getSqlParser().equalAny(DefaultKeyword.GROUP)) {
+//            getSqlParser().getLexer().nextToken();
+//            getSqlParser().accept(DefaultKeyword.BY);
 //            while (true) {
-//                if (getExprParser().getLexer().identifierEquals("GROUPING")) {
+//                if (getSqlParser().getLexer().identifierEquals("GROUPING")) {
 //                    throw new UnsupportedOperationException("Cannot support GROUPING SETS");
 //                } 
-//                addGroupByItem(getExprParser().expr());
-//                if (!getExprParser().equalAny(Symbol.COMMA)) {
+//                addGroupByItem(getSqlParser().expr());
+//                if (!getSqlParser().equalAny(Symbol.COMMA)) {
 //                    break;
 //                }
-//                getExprParser().getLexer().nextToken();
+//                getSqlParser().getLexer().nextToken();
 //            }
-//            if (getExprParser().skipIfEqual(Token.HAVING)) {
-//                getExprParser().expr();
+//            if (getSqlParser().skipIfEqual(Token.HAVING)) {
+//                getSqlParser().expr();
 //            }
-//        } else if (getExprParser().skipIfEqual(Token.HAVING)) {
+//        } else if (getSqlParser().skipIfEqual(Token.HAVING)) {
 //            SQLSelectGroupByClause groupBy = new SQLSelectGroupByClause();
-//            groupBy.setHaving(getExprParser().expr());
-//            if (getExprParser().skipIfEqual(DefaultKeyword.GROUP)) {
-//                getExprParser().accept(DefaultKeyword.BY);
+//            groupBy.setHaving(getSqlParser().expr());
+//            if (getSqlParser().skipIfEqual(DefaultKeyword.GROUP)) {
+//                getSqlParser().accept(DefaultKeyword.BY);
 //                while (true) {
-//                    if (getExprParser().getLexer().identifierEquals("GROUPING")) {
+//                    if (getSqlParser().getLexer().identifierEquals("GROUPING")) {
 //                        throw new UnsupportedOperationException("Cannot support GROUPING SETS");
 //                    }
-//                    addGroupByItem(getExprParser().expr());
-//                    if (!getExprParser().equalAny(Symbol.COMMA)) {
+//                    addGroupByItem(getSqlParser().expr());
+//                    if (!getSqlParser().equalAny(Symbol.COMMA)) {
 //                        break;
 //                    }
-//                    getExprParser().getLexer().nextToken();
+//                    getSqlParser().getLexer().nextToken();
 //                }
 //            }
 //        }
@@ -209,16 +209,16 @@ public class OracleSelectParser extends AbstractSelectParser {
     
     @Override
     public final void parseTable() {
-        if (getExprParser().equalAny(Symbol.LEFT_PAREN)) {
+        if (getSqlParser().equalAny(Symbol.LEFT_PAREN)) {
             throw new UnsupportedOperationException("Cannot support subquery");
         }
-        if (getExprParser().equalAny(DefaultKeyword.SELECT)) {
-            throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+        if (getSqlParser().equalAny(DefaultKeyword.SELECT)) {
+            throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
         }
-        if (getExprParser().skipIfEqual(OracleKeyword.ONLY)) {
-            getExprParser().skipIfEqual(Symbol.LEFT_PAREN);
+        if (getSqlParser().skipIfEqual(OracleKeyword.ONLY)) {
+            getSqlParser().skipIfEqual(Symbol.LEFT_PAREN);
             parseQueryTableExpression();
-            getExprParser().skipIfEqual(Symbol.RIGHT_PAREN);
+            getSqlParser().skipIfEqual(Symbol.RIGHT_PAREN);
             skipFlashbackQueryClause();
         } else {
             parseQueryTableExpression();
@@ -235,11 +235,11 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
     
     private void parseSample() {
-        if (getExprParser().skipIfEqual(OracleKeyword.SAMPLE)) {
-            getExprParser().skipIfEqual(OracleKeyword.BLOCK);
-            getExprParser().skipParentheses();
-            if (getExprParser().skipIfEqual(OracleKeyword.SEED)) {
-                getExprParser().skipParentheses();
+        if (getSqlParser().skipIfEqual(OracleKeyword.SAMPLE)) {
+            getSqlParser().skipIfEqual(OracleKeyword.BLOCK);
+            getSqlParser().skipParentheses();
+            if (getSqlParser().skipIfEqual(OracleKeyword.SEED)) {
+                getSqlParser().skipParentheses();
             }
         }
     }
@@ -250,34 +250,34 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
     
     private void skipPartition(final OracleKeyword keyword) {
-        if (getExprParser().skipIfEqual(keyword)) {
-            getExprParser().skipParentheses();
-            if (getExprParser().skipIfEqual(DefaultKeyword.FOR)) {
-                getExprParser().skipParentheses();
+        if (getSqlParser().skipIfEqual(keyword)) {
+            getSqlParser().skipParentheses();
+            if (getSqlParser().skipIfEqual(DefaultKeyword.FOR)) {
+                getSqlParser().skipParentheses();
             }
         }
     }
     
     private void skipPivotClause() {
-        if (getExprParser().skipIfEqual(OracleKeyword.PIVOT)) {
-            getExprParser().skipIfEqual(OracleKeyword.XML);
-            getExprParser().skipParentheses();
-        } else if (getExprParser().skipIfEqual(OracleKeyword.UNPIVOT)) {
-            if (getExprParser().skipIfEqual(OracleKeyword.INCLUDE)) {
-                getExprParser().accept(OracleKeyword.NULLS);
-            } else if (getExprParser().skipIfEqual(OracleKeyword.EXCLUDE)) {
-                getExprParser().accept(OracleKeyword.NULLS);
+        if (getSqlParser().skipIfEqual(OracleKeyword.PIVOT)) {
+            getSqlParser().skipIfEqual(OracleKeyword.XML);
+            getSqlParser().skipParentheses();
+        } else if (getSqlParser().skipIfEqual(OracleKeyword.UNPIVOT)) {
+            if (getSqlParser().skipIfEqual(OracleKeyword.INCLUDE)) {
+                getSqlParser().accept(OracleKeyword.NULLS);
+            } else if (getSqlParser().skipIfEqual(OracleKeyword.EXCLUDE)) {
+                getSqlParser().accept(OracleKeyword.NULLS);
             }
-            getExprParser().skipParentheses();
+            getSqlParser().skipParentheses();
         }
     }
     
     private void skipFlashbackQueryClause() {
-        if (getExprParser().equalAny(OracleKeyword.VERSIONS)) {
+        if (getSqlParser().equalAny(OracleKeyword.VERSIONS)) {
             throw new UnsupportedOperationException("Cannot support Flashback Query");
-        } else if (getExprParser().skipIfEqual(DefaultKeyword.AS)) {
-            if (getExprParser().skipIfEqual(OracleKeyword.OF)) {
-                if (getExprParser().skipIfEqual(OracleKeyword.SCN) || getExprParser().skipIfEqual(OracleKeyword.TIMESTAMP)) {
+        } else if (getSqlParser().skipIfEqual(DefaultKeyword.AS)) {
+            if (getSqlParser().skipIfEqual(OracleKeyword.OF)) {
+                if (getSqlParser().skipIfEqual(OracleKeyword.SCN) || getSqlParser().skipIfEqual(OracleKeyword.TIMESTAMP)) {
                     throw new UnsupportedOperationException("Cannot support Flashback Query");
                 }
             }
@@ -285,17 +285,17 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
     
     private void skipForUpdate() {
-        getExprParser().getLexer().nextToken();
-        getExprParser().accept(DefaultKeyword.UPDATE);
-        if (getExprParser().skipIfEqual(OracleKeyword.OF)) {
+        getSqlParser().getLexer().nextToken();
+        getSqlParser().accept(DefaultKeyword.UPDATE);
+        if (getSqlParser().skipIfEqual(OracleKeyword.OF)) {
             do {
-                getExprParser().parseExpression();
-            } while (getExprParser().skipIfEqual(Symbol.COMMA));
+                getSqlParser().parseExpression();
+            } while (getSqlParser().skipIfEqual(Symbol.COMMA));
         }
-        if (getExprParser().equalAny(OracleKeyword.NOWAIT, OracleKeyword.WAIT)) {
-            getExprParser().getLexer().nextToken();
-        } else if (getExprParser().skipIfEqual(OracleKeyword.SKIP)) {
-            getExprParser().accept(OracleKeyword.LOCKED);
+        if (getSqlParser().equalAny(OracleKeyword.NOWAIT, OracleKeyword.WAIT)) {
+            getSqlParser().getLexer().nextToken();
+        } else if (getSqlParser().skipIfEqual(OracleKeyword.SKIP)) {
+            getSqlParser().accept(OracleKeyword.LOCKED);
         }
     }
     
@@ -307,10 +307,10 @@ public class OracleSelectParser extends AbstractSelectParser {
     }
     
     private void skipAfterOrderByItem() {
-        if (getExprParser().skipIfEqual(OracleKeyword.NULLS)) {
-            getExprParser().getLexer().nextToken();
-            if (!getExprParser().skipIfEqual(OracleKeyword.FIRST, OracleKeyword.LAST)) {
-                throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+        if (getSqlParser().skipIfEqual(OracleKeyword.NULLS)) {
+            getSqlParser().getLexer().nextToken();
+            if (!getSqlParser().skipIfEqual(OracleKeyword.FIRST, OracleKeyword.LAST)) {
+                throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
             }
         }
     }

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

@@ -23,12 +23,12 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
 
 public class OracleUpdateParser extends AbstractUpdateParser {
     
-    public OracleUpdateParser(final SQLParser exprParser) {
-        super(exprParser);
+    public OracleUpdateParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenUpdateAndTable() {
-        getExprParser().skipIfEqual(OracleKeyword.ONLY);
+        getSqlParser().skipIfEqual(OracleKeyword.ONLY);
     }
 }

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

@@ -29,13 +29,13 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
  */
 public final class PostgreSQLDeleteParser extends AbstractDeleteParser {
     
-    public PostgreSQLDeleteParser(final SQLParser exprParser) {
-        super(exprParser);
+    public PostgreSQLDeleteParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenDeleteAndTable() {
-        getExprParser().skipIfEqual(DefaultKeyword.FROM);
-        getExprParser().skipIfEqual(PostgreSQLKeyword.ONLY);
+        getSqlParser().skipIfEqual(DefaultKeyword.FROM);
+        getSqlParser().skipIfEqual(PostgreSQLKeyword.ONLY);
     }
 }

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

@@ -30,7 +30,7 @@ import java.util.List;
  */
 public final class PostgreSQLInsertParser extends AbstractInsertParser {
     
-    public PostgreSQLInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser exprParser) {
-        super(shardingRule, parameters, exprParser);
+    public PostgreSQLInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser sqlParser) {
+        super(shardingRule, parameters, sqlParser);
     }
 }

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

@@ -29,39 +29,39 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
 
 public class PostgreSQLSelectParser extends AbstractSelectParser {
     
-    public PostgreSQLSelectParser(final SQLParser exprParser) {
-        super(exprParser);
+    public PostgreSQLSelectParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     public void query() {
-        if (getExprParser().skipIfEqual(DefaultKeyword.SELECT)) {
+        if (getSqlParser().skipIfEqual(DefaultKeyword.SELECT)) {
             parseDistinct();
             parseSelectList();
-            if (getExprParser().skipIfEqual(DefaultKeyword.INTO)) {
-                getExprParser().skipIfEqual(PostgreSQLKeyword.TEMPORARY, PostgreSQLKeyword.TEMP, PostgreSQLKeyword.UNLOGGED);
-                getExprParser().skipIfEqual(DefaultKeyword.TABLE);
+            if (getSqlParser().skipIfEqual(DefaultKeyword.INTO)) {
+                getSqlParser().skipIfEqual(PostgreSQLKeyword.TEMPORARY, PostgreSQLKeyword.TEMP, PostgreSQLKeyword.UNLOGGED);
+                getSqlParser().skipIfEqual(DefaultKeyword.TABLE);
                 // TODO
-                // getExprParser().name();
+                // getSqlParser().name();
             }
         }
         parseFrom();
         parseWhere();
         parseGroupBy();
-        if (getExprParser().equalAny(PostgreSQLKeyword.WINDOW)) {
+        if (getSqlParser().equalAny(PostgreSQLKeyword.WINDOW)) {
             throw new SQLParsingUnsupportedException(PostgreSQLKeyword.WINDOW);
         }
         getSqlContext().getOrderByContexts().addAll(parseOrderBy(getSqlContext()));
         parseLimit();
-        if (getExprParser().skipIfEqual(DefaultKeyword.FETCH)) {
+        if (getSqlParser().skipIfEqual(DefaultKeyword.FETCH)) {
             throw new SQLParsingUnsupportedException(DefaultKeyword.FETCH);
         }
-        if (getExprParser().skipIfEqual(DefaultKeyword.FOR)) {
-            getExprParser().skipIfEqual(DefaultKeyword.UPDATE, PostgreSQLKeyword.SHARE);
-            if (getExprParser().equalAny(PostgreSQLKeyword.OF)) {
+        if (getSqlParser().skipIfEqual(DefaultKeyword.FOR)) {
+            getSqlParser().skipIfEqual(DefaultKeyword.UPDATE, PostgreSQLKeyword.SHARE);
+            if (getSqlParser().equalAny(PostgreSQLKeyword.OF)) {
                 throw new SQLParsingUnsupportedException(PostgreSQLKeyword.OF);
             }
-            getExprParser().skipIfEqual(PostgreSQLKeyword.NOWAIT);
+            getSqlParser().skipIfEqual(PostgreSQLKeyword.NOWAIT);
         }
         queryRest();
     }
@@ -69,31 +69,31 @@ public class PostgreSQLSelectParser extends AbstractSelectParser {
     // TODO 解析和改写limit
     private void parseLimit() {
         while (true) {
-            if (getExprParser().equalAny(PostgreSQLKeyword.LIMIT)) {
+            if (getSqlParser().equalAny(PostgreSQLKeyword.LIMIT)) {
                 
-                getExprParser().getLexer().nextToken();
-                if (getExprParser().equalAny(DefaultKeyword.ALL)) {
+                getSqlParser().getLexer().nextToken();
+                if (getSqlParser().equalAny(DefaultKeyword.ALL)) {
                     new SQLIdentifierExpr("ALL");
-                    getExprParser().getLexer().nextToken();
+                    getSqlParser().getLexer().nextToken();
                 } else {
                     // rowCount
-                    if (getExprParser().equalAny(Literals.INT)) {
-                    } else if (getExprParser().equalAny(Symbol.QUESTION)) {
+                    if (getSqlParser().equalAny(Literals.INT)) {
+                    } else if (getSqlParser().equalAny(Symbol.QUESTION)) {
                     } else {
-                        throw new SQLParsingException(getExprParser().getLexer());
+                        throw new SQLParsingException(getSqlParser().getLexer());
                     }
-                    getExprParser().getLexer().nextToken();
+                    getSqlParser().getLexer().nextToken();
                 }
-            } else if (getExprParser().equalAny(PostgreSQLKeyword.OFFSET)) {
-                getExprParser().getLexer().nextToken();
+            } else if (getSqlParser().equalAny(PostgreSQLKeyword.OFFSET)) {
+                getSqlParser().getLexer().nextToken();
                 // offset
-                if (getExprParser().equalAny(Literals.INT)) {
-                } else if (getExprParser().equalAny(Symbol.QUESTION)) {
+                if (getSqlParser().equalAny(Literals.INT)) {
+                } else if (getSqlParser().equalAny(Symbol.QUESTION)) {
                 } else {
-                    throw new SQLParsingException(getExprParser().getLexer());
+                    throw new SQLParsingException(getSqlParser().getLexer());
                 }
-                getExprParser().getLexer().nextToken();
-                getExprParser().skipIfEqual(PostgreSQLKeyword.ROW, PostgreSQLKeyword.ROWS);
+                getSqlParser().getLexer().nextToken();
+                getSqlParser().skipIfEqual(PostgreSQLKeyword.ROW, PostgreSQLKeyword.ROWS);
             } else {
                 break;
             }

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

@@ -28,12 +28,12 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
  */
 public final class PostgreSQLUpdateParser extends AbstractUpdateParser {
     
-    public PostgreSQLUpdateParser(final SQLParser exprParser) {
-        super(exprParser);
+    public PostgreSQLUpdateParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenUpdateAndTable() {
-        getExprParser().skipIfEqual(PostgreSQLKeyword.ONLY);
+        getSqlParser().skipIfEqual(PostgreSQLKeyword.ONLY);
     }
 }

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

@@ -28,14 +28,14 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
  */
 public final class SQLServerDeleteParser extends AbstractDeleteParser {
     
-    public SQLServerDeleteParser(final SQLParser exprParser) {
-        super(exprParser);
+    public SQLServerDeleteParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenDeleteAndTable() {
-        ((SQLServerParser) getExprParser()).parseTop();
-        ((SQLServerParser) getExprParser()).skipOutput();
-        getExprParser().skipIfEqual(DefaultKeyword.FROM);
+        ((SQLServerParser) getSqlParser()).parseTop();
+        ((SQLServerParser) getSqlParser()).skipOutput();
+        getSqlParser().skipIfEqual(DefaultKeyword.FROM);
     }
 }

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

@@ -30,7 +30,7 @@ import java.util.List;
  */
 public final class SQLServerInsertParser extends AbstractInsertParser {
     
-    public SQLServerInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser exprParser) {
-        super(shardingRule, parameters, exprParser);
+    public SQLServerInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser sqlParser) {
+        super(shardingRule, parameters, sqlParser);
     }
 }

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

@@ -26,32 +26,32 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
 
 public class SQLServerSelectParser extends AbstractSelectParser {
     
-    public SQLServerSelectParser(final SQLParser exprParser) {
-        super(exprParser);
+    public SQLServerSelectParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void customizedSelect() {
-        if (getExprParser().equalAny(DefaultKeyword.FOR)) {
+        if (getSqlParser().equalAny(DefaultKeyword.FOR)) {
             parseFor();
         }
-        if (getExprParser().equalAny(SQLServerKeyword.OFFSET)) {
-            ((SQLServerParser) getExprParser()).parseOffset(getSqlContext());
+        if (getSqlParser().equalAny(SQLServerKeyword.OFFSET)) {
+            ((SQLServerParser) getSqlParser()).parseOffset(getSqlContext());
         }
     }
     
     @Override
     public void query() {
-        if (getExprParser().skipIfEqual(DefaultKeyword.SELECT)) {
+        if (getSqlParser().skipIfEqual(DefaultKeyword.SELECT)) {
             parseDistinct();
-            if (getExprParser().equalAny(SQLServerKeyword.TOP)) {
+            if (getSqlParser().equalAny(SQLServerKeyword.TOP)) {
                 // TODO save topContext
-                ((SQLServerParser) getExprParser()).parseTop();
+                ((SQLServerParser) getSqlParser()).parseTop();
             }
             parseSelectList();
         }
-        if (getExprParser().equalAny(DefaultKeyword.INTO)) {
-            throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+        if (getSqlParser().equalAny(DefaultKeyword.INTO)) {
+            throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
         }
         parseFrom();
         parseWhere();
@@ -61,33 +61,33 @@ public class SQLServerSelectParser extends AbstractSelectParser {
     
     @Override
     protected void parseJoinTable() {
-        if (getExprParser().skipIfEqual(DefaultKeyword.WITH)) {
-            getExprParser().skipParentheses();
+        if (getSqlParser().skipIfEqual(DefaultKeyword.WITH)) {
+            getSqlParser().skipParentheses();
         }
         super.parseJoinTable();
     }
     
     private void parseFor() {
-        getExprParser().getLexer().nextToken();
-        if (getExprParser().equalAny(SQLServerKeyword.BROWSE)) {
-            getExprParser().getLexer().nextToken();
-        } else if (getExprParser().skipIfEqual(SQLServerKeyword.XML)) {
+        getSqlParser().getLexer().nextToken();
+        if (getSqlParser().equalAny(SQLServerKeyword.BROWSE)) {
+            getSqlParser().getLexer().nextToken();
+        } else if (getSqlParser().skipIfEqual(SQLServerKeyword.XML)) {
             while (true) {
-                if (getExprParser().equalAny(SQLServerKeyword.AUTO, SQLServerKeyword.TYPE, SQLServerKeyword.XMLSCHEMA)) {
-                    getExprParser().getLexer().nextToken();
-                } else if (getExprParser().skipIfEqual(SQLServerKeyword.ELEMENTS)) {
-                    getExprParser().skipIfEqual(SQLServerKeyword.XSINIL);
+                if (getSqlParser().equalAny(SQLServerKeyword.AUTO, SQLServerKeyword.TYPE, SQLServerKeyword.XMLSCHEMA)) {
+                    getSqlParser().getLexer().nextToken();
+                } else if (getSqlParser().skipIfEqual(SQLServerKeyword.ELEMENTS)) {
+                    getSqlParser().skipIfEqual(SQLServerKeyword.XSINIL);
                 } else {
                     break;
                 }
-                if (getExprParser().equalAny(Symbol.COMMA)) {
-                    getExprParser().getLexer().nextToken();
+                if (getSqlParser().equalAny(Symbol.COMMA)) {
+                    getSqlParser().getLexer().nextToken();
                 } else {
                     break;
                 }
             }
         } else {
-            throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+            throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
         }
     }
 }

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

@@ -27,12 +27,12 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.SQLParser;
  */
 public final class SQLServerUpdateParser extends AbstractUpdateParser {
     
-    public SQLServerUpdateParser(final SQLParser exprParser) {
-        super(exprParser);
+    public SQLServerUpdateParser(final SQLParser sqlParser) {
+        super(sqlParser);
     }
     
     @Override
     protected void skipBetweenUpdateAndTable() {
-        ((SQLServerParser) getExprParser()).parseTop();
+        ((SQLServerParser) getSqlParser()).parseTop();
     }
 }

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

@@ -33,14 +33,14 @@ import lombok.RequiredArgsConstructor;
 public abstract class AbstractDeleteParser {
     
     @Getter(AccessLevel.PROTECTED)
-    private final SQLParser exprParser;
+    private final SQLParser sqlParser;
     
     private final DeleteSQLContext sqlContext;
     
-    public AbstractDeleteParser(final SQLParser exprParser) {
-        this.exprParser = exprParser;
+    public AbstractDeleteParser(final SQLParser sqlParser) {
+        this.sqlParser = sqlParser;
         sqlContext = new DeleteSQLContext();
-        sqlContext.setSqlBuilderContext(exprParser.getSqlBuilderContext());
+        sqlContext.setSqlBuilderContext(sqlParser.getSqlBuilderContext());
     }
     
     /**
@@ -49,11 +49,11 @@ public abstract class AbstractDeleteParser {
      * @return 解析结果
      */
     public DeleteSQLContext parse() {
-        exprParser.getLexer().nextToken();
+        sqlParser.getLexer().nextToken();
         skipBetweenDeleteAndTable();
-        exprParser.parseSingleTable(sqlContext);
-        exprParser.skipUntil(DefaultKeyword.WHERE);
-        exprParser.parseWhere(sqlContext);
+        sqlParser.parseSingleTable(sqlContext);
+        sqlParser.skipUntil(DefaultKeyword.WHERE);
+        sqlParser.parseWhere(sqlContext);
         return sqlContext;
     }
     

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

@@ -50,7 +50,7 @@ import java.util.Set;
 @Getter(AccessLevel.PROTECTED)
 public abstract class AbstractInsertParser {
     
-    private final SQLParser exprParser;
+    private final SQLParser sqlParser;
     
     private final ShardingRule shardingRule;
     
@@ -58,12 +58,12 @@ public abstract class AbstractInsertParser {
     
     private final InsertSQLContext sqlContext;
     
-    public AbstractInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser exprParser) {
-        this.exprParser = exprParser;
+    public AbstractInsertParser(final ShardingRule shardingRule, final List<Object> parameters, final SQLParser sqlParser) {
+        this.sqlParser = sqlParser;
         this.shardingRule = shardingRule;
         this.parameters = parameters;
         sqlContext = new InsertSQLContext();
-        sqlContext.setSqlBuilderContext(exprParser.getSqlBuilderContext());
+        sqlContext.setSqlBuilderContext(sqlParser.getSqlBuilderContext());
     }
     
     /**
@@ -72,15 +72,15 @@ public abstract class AbstractInsertParser {
      * @return 解析结果
      */
     public final InsertSQLContext parse() {
-        exprParser.getLexer().nextToken();
+        sqlParser.getLexer().nextToken();
         parseInto();
         Collection<ShardingColumnContext> shardingColumnContexts = parseColumns();
-        if (exprParser.equalAny(DefaultKeyword.SELECT, Symbol.LEFT_PAREN)) {
+        if (sqlParser.equalAny(DefaultKeyword.SELECT, Symbol.LEFT_PAREN)) {
             throw new UnsupportedOperationException("Cannot support subquery");
         }
-        if (getValuesKeywords().contains(exprParser.getLexer().getCurrentToken().getType())) {
+        if (getValuesKeywords().contains(sqlParser.getLexer().getCurrentToken().getType())) {
             parseValues(shardingColumnContexts);
-        } else if (getCustomizedInsertKeywords().contains(exprParser.getLexer().getCurrentToken().getType())) {
+        } else if (getCustomizedInsertKeywords().contains(sqlParser.getLexer().getCurrentToken().getType())) {
             parseCustomizedInsert();
         }
         return sqlContext;
@@ -91,20 +91,20 @@ public abstract class AbstractInsertParser {
     }
     
     private void parseInto() {
-        if (getUnsupportedKeywords().contains(exprParser.getLexer().getCurrentToken().getType())) {
-            throw new SQLParsingUnsupportedException(exprParser.getLexer().getCurrentToken().getType());
+        if (getUnsupportedKeywords().contains(sqlParser.getLexer().getCurrentToken().getType())) {
+            throw new SQLParsingUnsupportedException(sqlParser.getLexer().getCurrentToken().getType());
         }
-        exprParser.skipUntil(DefaultKeyword.INTO);
-        exprParser.getLexer().nextToken();
-        exprParser.parseSingleTable(sqlContext);
+        sqlParser.skipUntil(DefaultKeyword.INTO);
+        sqlParser.getLexer().nextToken();
+        sqlParser.parseSingleTable(sqlContext);
         skipBetweenTableAndValues();
     }
     
     private void skipBetweenTableAndValues() {
-        while (getSkippedKeywordsBetweenTableAndValues().contains(exprParser.getLexer().getCurrentToken().getType())) {
-            exprParser.getLexer().nextToken();
-            if (exprParser.equalAny(Symbol.LEFT_PAREN)) {
-                exprParser.skipParentheses();
+        while (getSkippedKeywordsBetweenTableAndValues().contains(sqlParser.getLexer().getCurrentToken().getType())) {
+            sqlParser.getLexer().nextToken();
+            if (sqlParser.equalAny(Symbol.LEFT_PAREN)) {
+                sqlParser.skipParentheses();
             }
         }
     }
@@ -116,27 +116,27 @@ public abstract class AbstractInsertParser {
     private Collection<ShardingColumnContext> parseColumns() {
         Collection<ShardingColumnContext> result = new LinkedList<>();
         Collection<String> autoIncrementColumns = shardingRule.getAutoIncrementColumns(sqlContext.getTables().get(0).getName());
-        if (exprParser.equalAny(Symbol.LEFT_PAREN)) {
+        if (sqlParser.equalAny(Symbol.LEFT_PAREN)) {
             do {
-                exprParser.getLexer().nextToken();
+                sqlParser.getLexer().nextToken();
                 result.add(getColumn(autoIncrementColumns));
-                exprParser.getLexer().nextToken();
-            } while (!exprParser.equalAny(Symbol.RIGHT_PAREN) && !exprParser.equalAny(Assist.END));
-            ItemsToken itemsToken = new ItemsToken(exprParser.getLexer().getCurrentToken().getEndPosition() - exprParser.getLexer().getCurrentToken().getLiterals().length());
+                sqlParser.getLexer().nextToken();
+            } while (!sqlParser.equalAny(Symbol.RIGHT_PAREN) && !sqlParser.equalAny(Assist.END));
+            ItemsToken itemsToken = new ItemsToken(sqlParser.getLexer().getCurrentToken().getEndPosition() - sqlParser.getLexer().getCurrentToken().getLiterals().length());
             for (String each : autoIncrementColumns) {
                 itemsToken.getItems().add(each);
                 result.add(new ShardingColumnContext(each, sqlContext.getTables().get(0).getName(), true));
             }
             if (!itemsToken.getItems().isEmpty()) {
-                exprParser.getSqlBuilderContext().getSqlTokens().add(itemsToken);
+                sqlParser.getSqlBuilderContext().getSqlTokens().add(itemsToken);
             }
-            exprParser.getLexer().nextToken();
+            sqlParser.getLexer().nextToken();
         }
         return result;
     }
     
     protected final ShardingColumnContext getColumn(final Collection<String> autoIncrementColumns) {
-        String columnName = SQLUtil.getExactlyValue(exprParser.getLexer().getCurrentToken().getLiterals());
+        String columnName = SQLUtil.getExactlyValue(sqlParser.getLexer().getCurrentToken().getLiterals());
         if (autoIncrementColumns.contains(columnName)) {
             autoIncrementColumns.remove(columnName);
         }
@@ -153,14 +153,14 @@ public abstract class AbstractInsertParser {
             if (parsed) {
                 throw new UnsupportedOperationException("Cannot support multiple insert");
             }
-            exprParser.getLexer().nextToken();
-            exprParser.accept(Symbol.LEFT_PAREN);
+            sqlParser.getLexer().nextToken();
+            sqlParser.accept(Symbol.LEFT_PAREN);
             List<SQLExpr> sqlExprs = new LinkedList<>();
             ConditionContext conditionContext = new ConditionContext();
             do {
-                sqlExprs.add(exprParser.parseExpression());
-            } while (exprParser.skipIfEqual(Symbol.COMMA));
-            ItemsToken itemsToken = new ItemsToken(exprParser.getLexer().getCurrentToken().getEndPosition() - exprParser.getLexer().getCurrentToken().getLiterals().length());
+                sqlExprs.add(sqlParser.parseExpression());
+            } while (sqlParser.skipIfEqual(Symbol.COMMA));
+            ItemsToken itemsToken = new ItemsToken(sqlParser.getLexer().getCurrentToken().getEndPosition() - sqlParser.getLexer().getCurrentToken().getLiterals().length());
             int count = 0;
             for (ShardingColumnContext each : shardingColumnContexts) {
                 if (each.isAutoIncrement()) {
@@ -182,13 +182,13 @@ public abstract class AbstractInsertParser {
                 count++;
             }
             if (!itemsToken.getItems().isEmpty()) {
-                exprParser.getSqlBuilderContext().getSqlTokens().add(itemsToken);
+                sqlParser.getSqlBuilderContext().getSqlTokens().add(itemsToken);
             }
-            exprParser.accept(Symbol.RIGHT_PAREN);
+            sqlParser.accept(Symbol.RIGHT_PAREN);
             parsed = true;
             sqlContext.setConditionContext(conditionContext);
         }
-        while (exprParser.equalAny(Symbol.COMMA));
+        while (sqlParser.equalAny(Symbol.COMMA));
     }
     
     protected Set<TokenType> getCustomizedInsertKeywords() {

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

@@ -51,7 +51,7 @@ public abstract class AbstractSelectParser {
     
     private static final String SHARDING_GEN_ALIAS = "sharding_gen_%s";
     
-    private SQLParser exprParser;
+    private SQLParser sqlParser;
     
     private final SelectSQLContext sqlContext;
     
@@ -62,10 +62,10 @@ public abstract class AbstractSelectParser {
     
     private ItemsToken itemsToken;
     
-    public AbstractSelectParser(final SQLParser exprParser) {
-        this.exprParser = exprParser;
+    public AbstractSelectParser(final SQLParser sqlParser) {
+        this.sqlParser = sqlParser;
         sqlContext = new SelectSQLContext();
-        sqlContext.setSqlBuilderContext(exprParser.getSqlBuilderContext());
+        sqlContext.setSqlBuilderContext(sqlParser.getSqlBuilderContext());
     }
     
     /**
@@ -78,7 +78,7 @@ public abstract class AbstractSelectParser {
         sqlContext.getOrderByContexts().addAll(parseOrderBy(getSqlContext()));
         customizedSelect();
         if (!itemsToken.getItems().isEmpty()) {
-            exprParser.getSqlBuilderContext().getSqlTokens().add(itemsToken);
+            sqlParser.getSqlBuilderContext().getSqlTokens().add(itemsToken);
         }
         return sqlContext;
     }
@@ -87,7 +87,7 @@ public abstract class AbstractSelectParser {
     }
     
     protected void query() {
-        getExprParser().accept(DefaultKeyword.SELECT);
+        getSqlParser().accept(DefaultKeyword.SELECT);
         parseDistinct();
         parseSelectList();
         parseFrom();
@@ -97,15 +97,15 @@ public abstract class AbstractSelectParser {
     }
     
     protected final void parseDistinct() {
-        if (getExprParser().equalAny(DefaultKeyword.DISTINCT, DefaultKeyword.DISTINCTROW, DefaultKeyword.UNION)) {
+        if (getSqlParser().equalAny(DefaultKeyword.DISTINCT, DefaultKeyword.DISTINCTROW, DefaultKeyword.UNION)) {
             sqlContext.setDistinct(true);
-            getExprParser().getLexer().nextToken();
-            if (hasDistinctOn() && getExprParser().equalAny(DefaultKeyword.ON)) {
-                getExprParser().getLexer().nextToken();
-                getExprParser().skipParentheses();
+            getSqlParser().getLexer().nextToken();
+            if (hasDistinctOn() && getSqlParser().equalAny(DefaultKeyword.ON)) {
+                getSqlParser().getLexer().nextToken();
+                getSqlParser().skipParentheses();
             }
-        } else if (getExprParser().equalAny(DefaultKeyword.ALL)) {
-            getExprParser().getLexer().nextToken();
+        } else if (getSqlParser().equalAny(DefaultKeyword.ALL)) {
+            getSqlParser().getLexer().nextToken();
         }
     }
     
@@ -116,14 +116,14 @@ public abstract class AbstractSelectParser {
     protected final void parseSelectList() {
         int index = 1;
         do {
-            SelectItemContext selectItemContext = exprParser.parseSelectItem(index);
+            SelectItemContext selectItemContext = sqlParser.parseSelectItem(index);
             sqlContext.getItemContexts().add(selectItemContext);
             if (selectItemContext instanceof CommonSelectItemContext && ((CommonSelectItemContext) selectItemContext).isStar()) {
                 sqlContext.setContainStar(true);
             }
             index++;
-        } while (getExprParser().skipIfEqual(Symbol.COMMA));
-        sqlContext.setSelectListLastPosition(getExprParser().getLexer().getCurrentToken().getEndPosition() - getExprParser().getLexer().getCurrentToken().getLiterals().length());
+        } while (getSqlParser().skipIfEqual(Symbol.COMMA));
+        sqlContext.setSelectListLastPosition(getSqlParser().getLexer().getCurrentToken().getEndPosition() - getSqlParser().getLexer().getCurrentToken().getLiterals().length());
         itemsToken = new ItemsToken(sqlContext.getSelectListLastPosition());
         for (SelectItemContext each : sqlContext.getItemContexts()) {
             if (each instanceof AggregationSelectItemContext) {
@@ -144,8 +144,8 @@ public abstract class AbstractSelectParser {
     }
     
     protected void queryRest() {
-        if (getExprParser().equalAny(DefaultKeyword.UNION, DefaultKeyword.EXCEPT, DefaultKeyword.INTERSECT, DefaultKeyword.MINUS)) {
-            throw new SQLParsingUnsupportedException(getExprParser().getLexer().getCurrentToken().getType());
+        if (getSqlParser().equalAny(DefaultKeyword.UNION, DefaultKeyword.EXCEPT, DefaultKeyword.INTERSECT, DefaultKeyword.MINUS)) {
+            throw new SQLParsingUnsupportedException(getSqlParser().getLexer().getCurrentToken().getType());
         }
     }
     
@@ -153,8 +153,8 @@ public abstract class AbstractSelectParser {
         if (sqlContext.getTables().isEmpty()) {
             return;
         }
-        exprParser.parseWhere(sqlContext);
-        parametersIndex = exprParser.getParametersIndex();
+        sqlParser.parseWhere(sqlContext);
+        parametersIndex = sqlParser.getParametersIndex();
     }
     
     /**
@@ -164,28 +164,28 @@ public abstract class AbstractSelectParser {
      * @return 排序上下文
      */
     public final List<OrderByContext> parseOrderBy(final SelectSQLContext sqlContext) {
-        if (!exprParser.skipIfEqual(DefaultKeyword.ORDER)) {
+        if (!sqlParser.skipIfEqual(DefaultKeyword.ORDER)) {
             return Collections.emptyList();
         }
         List<OrderByContext> result = new LinkedList<>();
-        exprParser.skipIfEqual(DefaultKeyword.SIBLINGS);
-        exprParser.accept(DefaultKeyword.BY);
+        sqlParser.skipIfEqual(DefaultKeyword.SIBLINGS);
+        sqlParser.accept(DefaultKeyword.BY);
         do {
             Optional<OrderByContext> orderByContext = parseSelectOrderByItem(sqlContext);
             if (orderByContext.isPresent()) {
                 result.add(orderByContext.get());
             }
         }
-        while (exprParser.skipIfEqual(Symbol.COMMA));
+        while (sqlParser.skipIfEqual(Symbol.COMMA));
         return result;
     }
     
     protected Optional<OrderByContext> parseSelectOrderByItem(final SelectSQLContext sqlContext) {
-        SQLExpr expr = exprParser.parseExpression(sqlContext);
+        SQLExpr expr = sqlParser.parseExpression(sqlContext);
         OrderType orderByType = OrderType.ASC;
-        if (exprParser.skipIfEqual(DefaultKeyword.ASC)) {
+        if (sqlParser.skipIfEqual(DefaultKeyword.ASC)) {
             orderByType = OrderType.ASC;
-        } else if (exprParser.skipIfEqual(DefaultKeyword.DESC)) {
+        } else if (sqlParser.skipIfEqual(DefaultKeyword.DESC)) {
             orderByType = OrderType.DESC;
         }
         OrderByContext result;
@@ -218,31 +218,31 @@ public abstract class AbstractSelectParser {
     }
     
     protected void parseGroupBy() {
-        if (getExprParser().skipIfEqual(DefaultKeyword.GROUP)) {
-            getExprParser().accept(DefaultKeyword.BY);
+        if (getSqlParser().skipIfEqual(DefaultKeyword.GROUP)) {
+            getSqlParser().accept(DefaultKeyword.BY);
             while (true) {
-                addGroupByItem(exprParser.parseExpression(sqlContext));
-                if (!getExprParser().equalAny(Symbol.COMMA)) {
+                addGroupByItem(sqlParser.parseExpression(sqlContext));
+                if (!getSqlParser().equalAny(Symbol.COMMA)) {
                     break;
                 }
-                getExprParser().getLexer().nextToken();
+                getSqlParser().getLexer().nextToken();
             }
-            while (getExprParser().equalAny(DefaultKeyword.WITH) || getExprParser().getLexer().getCurrentToken().getLiterals().equalsIgnoreCase("ROLLUP")) {
-                getExprParser().getLexer().nextToken();
+            while (getSqlParser().equalAny(DefaultKeyword.WITH) || getSqlParser().getLexer().getCurrentToken().getLiterals().equalsIgnoreCase("ROLLUP")) {
+                getSqlParser().getLexer().nextToken();
             }
-            if (getExprParser().skipIfEqual(DefaultKeyword.HAVING)) {
-                exprParser.parseExpression(sqlContext);
+            if (getSqlParser().skipIfEqual(DefaultKeyword.HAVING)) {
+                sqlParser.parseExpression(sqlContext);
             }
-        } else if (getExprParser().skipIfEqual(DefaultKeyword.HAVING)) {
-            exprParser.parseExpression(sqlContext);
+        } else if (getSqlParser().skipIfEqual(DefaultKeyword.HAVING)) {
+            sqlParser.parseExpression(sqlContext);
         }
     }
     
     protected final void addGroupByItem(final SQLExpr sqlExpr) {
         OrderType orderByType = OrderType.ASC;
-        if (getExprParser().equalAny(DefaultKeyword.ASC)) {
-            getExprParser().getLexer().nextToken();
-        } else if (getExprParser().skipIfEqual(DefaultKeyword.DESC)) {
+        if (getSqlParser().equalAny(DefaultKeyword.ASC)) {
+            getSqlParser().getLexer().nextToken();
+        } else if (getSqlParser().skipIfEqual(DefaultKeyword.DESC)) {
             orderByType = OrderType.DESC;
         }
         GroupByContext groupByContext;
@@ -294,13 +294,13 @@ public abstract class AbstractSelectParser {
     }
     
     public final void parseFrom() {
-        if (getExprParser().skipIfEqual(DefaultKeyword.FROM)) {
+        if (getSqlParser().skipIfEqual(DefaultKeyword.FROM)) {
             parseTable();
         }
     }
     
     public void parseTable() {
-        if (getExprParser().equalAny(Symbol.LEFT_PAREN)) {
+        if (getSqlParser().equalAny(Symbol.LEFT_PAREN)) {
             throw new UnsupportedOperationException("Cannot support subquery");
         }
         parseTableFactor();
@@ -308,45 +308,45 @@ public abstract class AbstractSelectParser {
     }
     
     protected final void parseTableFactor() {
-        int beginPosition = getExprParser().getLexer().getCurrentToken().getEndPosition() - getExprParser().getLexer().getCurrentToken().getLiterals().length();
-        String literals = getExprParser().getLexer().getCurrentToken().getLiterals();
-        getExprParser().getLexer().nextToken();
+        int beginPosition = getSqlParser().getLexer().getCurrentToken().getEndPosition() - getSqlParser().getLexer().getCurrentToken().getLiterals().length();
+        String literals = getSqlParser().getLexer().getCurrentToken().getLiterals();
+        getSqlParser().getLexer().nextToken();
         // TODO 包含Schema解析
-        if (getExprParser().skipIfEqual(Symbol.DOT)) {
-            getExprParser().getLexer().nextToken();
-            getExprParser().parseAlias();
+        if (getSqlParser().skipIfEqual(Symbol.DOT)) {
+            getSqlParser().getLexer().nextToken();
+            getSqlParser().parseAlias();
             return;
         }
         // FIXME 根据shardingRule过滤table
-        exprParser.getSqlBuilderContext().getSqlTokens().add(new TableToken(beginPosition, literals, SQLUtil.getExactlyValue(literals)));
-        sqlContext.getTables().add(new TableContext(literals, SQLUtil.getExactlyValue(literals), getExprParser().parseAlias()));
+        sqlParser.getSqlBuilderContext().getSqlTokens().add(new TableToken(beginPosition, literals, SQLUtil.getExactlyValue(literals)));
+        sqlContext.getTables().add(new TableContext(literals, SQLUtil.getExactlyValue(literals), getSqlParser().parseAlias()));
     }
     
     protected void parseJoinTable() {
-        if (getExprParser().skipJoin()) {
+        if (getSqlParser().skipJoin()) {
             parseTable();
-            if (getExprParser().skipIfEqual(DefaultKeyword.ON)) {
+            if (getSqlParser().skipIfEqual(DefaultKeyword.ON)) {
                 do {
-                    parseTableCondition(getExprParser().getLexer().getCurrentToken().getEndPosition());
-                    getExprParser().accept(Symbol.EQ);
-                    parseTableCondition(getExprParser().getLexer().getCurrentToken().getEndPosition() - getExprParser().getLexer().getCurrentToken().getLiterals().length());
-                } while (getExprParser().skipIfEqual(DefaultKeyword.AND));
-            } else if (getExprParser().skipIfEqual(DefaultKeyword.USING)) {
-                getExprParser().skipParentheses();
+                    parseTableCondition(getSqlParser().getLexer().getCurrentToken().getEndPosition());
+                    getSqlParser().accept(Symbol.EQ);
+                    parseTableCondition(getSqlParser().getLexer().getCurrentToken().getEndPosition() - getSqlParser().getLexer().getCurrentToken().getLiterals().length());
+                } while (getSqlParser().skipIfEqual(DefaultKeyword.AND));
+            } else if (getSqlParser().skipIfEqual(DefaultKeyword.USING)) {
+                getSqlParser().skipParentheses();
             }
             parseJoinTable();
         }
     }
     
     private void parseTableCondition(final int startPosition) {
-        SQLExpr sqlExpr = exprParser.parseExpression();
+        SQLExpr sqlExpr = sqlParser.parseExpression();
         if (!(sqlExpr instanceof SQLPropertyExpr)) {
             return;
         }
         SQLPropertyExpr sqlPropertyExpr = (SQLPropertyExpr) sqlExpr;
         for (TableContext each : sqlContext.getTables()) {
             if (each.getName().equalsIgnoreCase(SQLUtil.getExactlyValue(sqlPropertyExpr.getOwner().getName()))) {
-                exprParser.getSqlBuilderContext().getSqlTokens().add(
+                sqlParser.getSqlBuilderContext().getSqlTokens().add(
                         new TableToken(startPosition, sqlPropertyExpr.getOwner().getName(), SQLUtil.getExactlyValue(sqlPropertyExpr.getOwner().getName())));
             }
         }

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

@@ -34,16 +34,16 @@ import lombok.Getter;
 @Getter(AccessLevel.PROTECTED)
 public abstract class AbstractUpdateParser {
     
-    private final SQLParser exprParser;
+    private final SQLParser sqlParser;
     
     private final UpdateSQLContext sqlContext;
     
     private int parametersIndex;
     
-    public AbstractUpdateParser(final SQLParser exprParser) {
-        this.exprParser = exprParser;
+    public AbstractUpdateParser(final SQLParser sqlParser) {
+        this.sqlParser = sqlParser;
         sqlContext = new UpdateSQLContext();
-        sqlContext.setSqlBuilderContext(exprParser.getSqlBuilderContext());
+        sqlContext.setSqlBuilderContext(sqlParser.getSqlBuilderContext());
     }
     
     /**
@@ -52,42 +52,42 @@ public abstract class AbstractUpdateParser {
      * @return 解析结果
      */
     public UpdateSQLContext parse() {
-        exprParser.getLexer().nextToken();
+        sqlParser.getLexer().nextToken();
         skipBetweenUpdateAndTable();
-        exprParser.parseSingleTable(sqlContext);
+        sqlParser.parseSingleTable(sqlContext);
         parseSetItems();
-        exprParser.skipUntil(DefaultKeyword.WHERE);
-        exprParser.setParametersIndex(parametersIndex);
-        exprParser.parseWhere(sqlContext);
+        sqlParser.skipUntil(DefaultKeyword.WHERE);
+        sqlParser.setParametersIndex(parametersIndex);
+        sqlParser.parseWhere(sqlContext);
         return sqlContext;
     }
     
     protected abstract void skipBetweenUpdateAndTable();
     
     private void parseSetItems() {
-        exprParser.accept(DefaultKeyword.SET);
+        sqlParser.accept(DefaultKeyword.SET);
         do {
             parseSetItem();
-        } while (exprParser.skipIfEqual(Symbol.COMMA));
+        } while (sqlParser.skipIfEqual(Symbol.COMMA));
     }
     
     private void parseSetItem() {
-        if (exprParser.equalAny(Symbol.LEFT_PAREN)) {
-            exprParser.skipParentheses();
+        if (sqlParser.equalAny(Symbol.LEFT_PAREN)) {
+            sqlParser.skipParentheses();
         } else {
-            int beginPosition = exprParser.getLexer().getCurrentToken().getEndPosition();
-            String literals = exprParser.getLexer().getCurrentToken().getLiterals();
-            exprParser.getLexer().nextToken();
+            int beginPosition = sqlParser.getLexer().getCurrentToken().getEndPosition();
+            String literals = sqlParser.getLexer().getCurrentToken().getLiterals();
+            sqlParser.getLexer().nextToken();
             String tableName = sqlContext.getTables().get(0).getName();
-            if (exprParser.skipIfEqual(Symbol.DOT)) {
+            if (sqlParser.skipIfEqual(Symbol.DOT)) {
                 if (tableName.equalsIgnoreCase(SQLUtil.getExactlyValue(literals))) {
-                    exprParser.getSqlBuilderContext().getSqlTokens().add(new TableToken(beginPosition - literals.length(), literals, tableName));
+                    sqlParser.getSqlBuilderContext().getSqlTokens().add(new TableToken(beginPosition - literals.length(), literals, tableName));
                 }
-                exprParser.getLexer().nextToken();
+                sqlParser.getLexer().nextToken();
             }
         }
-        exprParser.skipIfEqual(Symbol.EQ, Symbol.COLON_EQ);
-        exprParser.parseExpression(sqlContext);
-        parametersIndex = exprParser.getParametersIndex();
+        sqlParser.skipIfEqual(Symbol.EQ, Symbol.COLON_EQ);
+        sqlParser.parseExpression(sqlContext);
+        parametersIndex = sqlParser.getParametersIndex();
     }
 }