method query

src/main/java/org/elasticsearch/druid/ElasticSqlExprParser.java

@@ -36,11 +36,13 @@ public class ElasticSqlExprParser extends SQLExprParser {
                 limit.setOffset(temp);
                 lexer.nextToken();
                 limit.setRowCount(this.expr());
-            } else if (identifierEquals("OFFSET")) {
+            }
+            else if (identifierEquals("OFFSET")) {
                 limit.setRowCount(temp);
                 lexer.nextToken();
                 limit.setOffset(this.expr());
-            } else {
+            }
+            else {
                 limit.setRowCount(temp);
             }
             return limit;
@@ -50,7 +52,7 @@ public class ElasticSqlExprParser extends SQLExprParser {
     }
 
     public ElasticSqlSelectQueryBlock.Routing parseRoutingBy() {
-        if(lexer.token() == Token.INDEX && "ROUTING".equalsIgnoreCase(lexer.stringVal())) {
+        if (lexer.token() == Token.INDEX && "ROUTING".equalsIgnoreCase(lexer.stringVal())) {
             lexer.nextToken();
 
             accept(Token.BY);
@@ -58,7 +60,7 @@ public class ElasticSqlExprParser extends SQLExprParser {
             List<SQLExpr> routingValues = Lists.newLinkedList();
             routingValues.add(this.expr());
 
-            while(lexer.token() == (Token.COMMA)) {
+            while (lexer.token() == (Token.COMMA)) {
                 lexer.nextToken();
                 routingValues.add(this.expr());
             }

src/main/java/org/elasticsearch/druid/ElasticSqlLexer.java

@@ -3,15 +3,15 @@ package org.elasticsearch.druid;
 import com.alibaba.druid.sql.parser.Keywords;
 import com.alibaba.druid.sql.parser.Lexer;
 import com.alibaba.druid.sql.parser.Token;
+import com.google.common.collect.Maps;
 
-import java.util.HashMap;
 import java.util.Map;
 
 public class ElasticSqlLexer extends Lexer {
     public final static Keywords DEFAULT_ELASTIC_SQL_KEYWORDS;
 
     static {
-        Map<String, Token> map = new HashMap<String, Token>();
+        Map<String, Token> map = Maps.newHashMap();
 
         map.put("SELECT", Token.SELECT);
         map.put("DISTINCT", Token.DISTINCT);

src/main/java/org/elasticsearch/druid/ElasticSqlSelectParser.java

@@ -44,10 +44,12 @@ public class ElasticSqlSelectParser extends SQLSelectParser {
         if (lexer.token() == Token.DISTINCT) {
             queryBlock.setDistionOption(SQLSetQuantifier.DISTINCT);
             lexer.nextToken();
-        } else if (lexer.token() == Token.UNIQUE) {
+        }
+        else if (lexer.token() == Token.UNIQUE) {
             queryBlock.setDistionOption(SQLSetQuantifier.UNIQUE);
             lexer.nextToken();
-        } else if (lexer.token() == Token.ALL) {
+        }
+        else if (lexer.token() == Token.ALL) {
             queryBlock.setDistionOption(SQLSetQuantifier.ALL);
             lexer.nextToken();
         }

src/main/java/org/elasticsearch/druid/ElasticSqlSelectQueryBlock.java

@@ -8,24 +8,23 @@ import com.alibaba.druid.sql.visitor.SQLASTVisitor;
 import org.apache.commons.collections.CollectionUtils;
 
 import java.util.List;
-import java.util.function.Consumer;
 
 public class ElasticSqlSelectQueryBlock extends SQLSelectQueryBlock implements SQLObject {
-    /*DSL: from to*/
+    //DSL: from to
     private Limit limit;
 
     private Routing routing;
 
     private SQLExpr matchQuery;
 
-    public void setMatchQuery(SQLExpr matchQuery) {
-        this.matchQuery = matchQuery;
-    }
-
     public SQLExpr getMatchQuery() {
         return matchQuery;
     }
 
+    public void setMatchQuery(SQLExpr matchQuery) {
+        this.matchQuery = matchQuery;
+    }
+
     public Limit getLimit() {
         return limit;
     }
@@ -48,12 +47,9 @@ public class ElasticSqlSelectQueryBlock extends SQLSelectQueryBlock implements S
         public Routing(List<SQLExpr> routingValues) {
             this.routingValues = routingValues;
             if (CollectionUtils.isNotEmpty(routingValues)) {
-                routingValues.stream().forEach(new Consumer<SQLExpr>() {
-                    @Override
-                    public void accept(SQLExpr sqlExpr) {
-                        sqlExpr.setParent(ElasticSqlSelectQueryBlock.Routing.this);
-                    }
-                });
+                for (SQLExpr sqlExpr : routingValues) {
+                    sqlExpr.setParent(ElasticSqlSelectQueryBlock.Routing.this);
+                }
             }
         }
 

src/main/java/org/elasticsearch/dsl/bean/ElasticDslContext.java

@@ -3,11 +3,11 @@ package org.elasticsearch.dsl.bean;
 import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 
 public class ElasticDslContext {
-    /*SQL*/
+    //SQL
     private SQLQueryExpr queryExpr;
-    /*SQL Args*/
+    //SQL Args
     private Object[] sqlArgs;
-    /*Result*/
+    //Result
     private ElasticSqlParseResult parseResult;
 
     public ElasticDslContext(SQLQueryExpr queryExpr, Object[] sqlArgs) {

src/main/java/org/elasticsearch/dsl/bean/ElasticSqlParseResult.java

@@ -121,14 +121,14 @@ public class ElasticSqlParseResult {
         this.routingBy = routingBy;
     }
 
-    public void setGroupBy(List<AbstractAggregationBuilder> groupBy) {
-        this.groupBy = groupBy;
-    }
-
     public List<AbstractAggregationBuilder> getGroupBy() {
         return groupBy;
     }
 
+    public void setGroupBy(List<AbstractAggregationBuilder> groupBy) {
+        this.groupBy = groupBy;
+    }
+
     public void setTopStatsAgg() {
         this.isTopStatsAgg = true;
     }
@@ -150,15 +150,18 @@ public class ElasticSqlParseResult {
         }
 
         if (whereCondition != null && whereCondition.hasClauses()) {
-            if(matchCondition != null && matchCondition.hasClauses()) {
-                requestBuilder.setQuery(QueryBuilders.boolQuery().must(matchCondition).filter(whereCondition));
-            } else {
+            if (matchCondition != null && matchCondition.hasClauses()) {
+                requestBuilder.setQuery(matchCondition.filter(whereCondition));
+            }
+            else {
                 requestBuilder.setQuery(QueryBuilders.boolQuery().filter(whereCondition));
             }
-        } else {
-            if(matchCondition != null && matchCondition.hasClauses()) {
-                requestBuilder.setQuery(QueryBuilders.boolQuery().must(matchCondition));
-            } else {
+        }
+        else {
+            if (matchCondition != null && matchCondition.hasClauses()) {
+                requestBuilder.setQuery(matchCondition);
+            }
+            else {
                 requestBuilder.setQuery(QueryBuilders.matchAllQuery());
             }
         }
@@ -189,7 +192,8 @@ public class ElasticSqlParseResult {
                     preAgg = (AggregationBuilder) aggItem;
                 }
                 requestBuilder.addAggregation(groupBy.get(0));
-            } else {
+            }
+            else {
                 for (AbstractAggregationBuilder aggItem : groupBy) {
                     requestBuilder.addAggregation(aggItem);
                 }

src/main/java/org/elasticsearch/dsl/enums/SortOption.java

@@ -26,13 +26,6 @@ public enum SortOption {
         }
     };
 
-    public abstract String mode();
-
-    @Override
-    public String toString() {
-        return mode();
-    }
-
     public static SortOption get(String mode) {
         SortOption op = null;
         for (SortOption option : SortOption.values()) {
@@ -42,4 +35,11 @@ public enum SortOption {
         }
         return op;
     }
+
+    public abstract String mode();
+
+    @Override
+    public String toString() {
+        return mode();
+    }
 }

src/main/java/org/elasticsearch/dsl/helper/ElasticSqlDateParseHelper.java

@@ -15,46 +15,6 @@ public class ElasticSqlDateParseHelper {
     public static final Pattern SQL_DATE_REGEX_PATTERN_02 = Pattern.compile("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}");
     public static final Pattern SQL_DATE_REGEX_PATTERN_03 = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
 
-    private enum SqlDateRegex {
-        DATE_REGEX_01 {
-            @Override
-            Pattern getPattern() {
-                return SQL_DATE_REGEX_PATTERN_01;
-            }
-
-            @Override
-            String getPatternString() {
-                return "yyyy-MM-dd HH:mm:ss";
-            }
-        },
-        DATE_REGEX_02 {
-            @Override
-            Pattern getPattern() {
-                return SQL_DATE_REGEX_PATTERN_02;
-            }
-
-            @Override
-            String getPatternString() {
-                return "yyyy-MM-dd HH:mm";
-            }
-        },
-        DATE_REGEX_03 {
-            @Override
-            Pattern getPattern() {
-                return SQL_DATE_REGEX_PATTERN_03;
-            }
-
-            @Override
-            String getPatternString() {
-                return "yyyy-MM-dd";
-            }
-        };
-
-        abstract Pattern getPattern();
-
-        abstract String getPatternString();
-    }
-
     public static boolean isDateMethod(SQLMethodInvokeExpr dateMethodExpr) {
         return ElasticSqlMethodInvokeHelper.DATE_METHOD.equalsIgnoreCase(dateMethodExpr.getMethodName());
     }
@@ -66,10 +26,7 @@ public class ElasticSqlDateParseHelper {
     }
 
     public static boolean isDateArgObjectValue(Object date) {
-        if (date instanceof Date) {
-            return true;
-        }
-        return false;
+        return date instanceof Date;
     }
 
     public static String formatDefaultEsDateStringValue(String date) {
@@ -100,8 +57,49 @@ public class ElasticSqlDateParseHelper {
 
             dateFormat = new SimpleDateFormat(DEFAULT_ES_DATE_FORMAT);
             return dateFormat.format(date);
-        } catch (ParseException pex) {
+        }
+        catch (ParseException pex) {
             throw new ElasticSql2DslException("[syntax error] Parse time arg error: " + timeValArg);
         }
     }
+
+    private enum SqlDateRegex {
+        DATE_REGEX_01 {
+            @Override
+            Pattern getPattern() {
+                return SQL_DATE_REGEX_PATTERN_01;
+            }
+
+            @Override
+            String getPatternString() {
+                return "yyyy-MM-dd HH:mm:ss";
+            }
+        },
+        DATE_REGEX_02 {
+            @Override
+            Pattern getPattern() {
+                return SQL_DATE_REGEX_PATTERN_02;
+            }
+
+            @Override
+            String getPatternString() {
+                return "yyyy-MM-dd HH:mm";
+            }
+        },
+        DATE_REGEX_03 {
+            @Override
+            Pattern getPattern() {
+                return SQL_DATE_REGEX_PATTERN_03;
+            }
+
+            @Override
+            String getPatternString() {
+                return "yyyy-MM-dd";
+            }
+        };
+
+        abstract Pattern getPattern();
+
+        abstract String getPatternString();
+    }
 }

src/main/java/org/elasticsearch/dsl/parser/ElasticSql2DslParser.java

@@ -5,14 +5,14 @@ import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 import com.alibaba.druid.sql.parser.ParserException;
 import com.alibaba.druid.sql.parser.Token;
 import com.google.common.collect.ImmutableList;
+import org.elasticsearch.druid.ElasticSqlExprParser;
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.listener.ParseActionListenerAdapter;
 import org.elasticsearch.dsl.parser.sql.*;
-import org.elasticsearch.druid.ElasticSqlExprParser;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 
 import java.lang.reflect.Array;
 import java.util.Collection;
@@ -39,7 +39,8 @@ public class ElasticSql2DslParser {
             SQLExpr sqlQueryExpr = elasticSqlExprParser.expr();
             check(elasticSqlExprParser, sqlQueryExpr, sqlArgs);
             queryExpr = (SQLQueryExpr) sqlQueryExpr;
-        } catch (ParserException ex) {
+        }
+        catch (ParserException ex) {
             throw new ElasticSql2DslException(ex);
         }
 
@@ -48,7 +49,8 @@ public class ElasticSql2DslParser {
             for (QueryParser sqlParser : buildSqlParserChain(parseActionListener)) {
                 sqlParser.parse(elasticDslContext);
             }
-        } else {
+        }
+        else {
             throw new ElasticSql2DslException("[syntax error] Sql only support Select Sql");
         }
         return elasticDslContext.getParseResult();

src/main/java/org/elasticsearch/dsl/parser/query/exact/InListAtomQueryParser.java

@@ -20,8 +20,10 @@ public class InListAtomQueryParser extends AbstractAtomExactQueryParser {
         if (CollectionUtils.isEmpty(inListQueryExpr.getTargetList())) {
             throw new ElasticSql2DslException("[syntax error] In list expr target list cannot be blank");
         }
+
         Object[] targetInList = ElasticSqlArgTransferHelper.transferSqlArgs(inListQueryExpr.getTargetList(), sqlArgs);
         SQLConditionOperator operator = inListQueryExpr.isNot() ? SQLConditionOperator.NotIn : SQLConditionOperator.In;
+
         return parseCondition(inListQueryExpr.getExpr(), operator, targetInList, queryAs, new IConditionExactQueryBuilder() {
             @Override
             public QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {

src/main/java/org/elasticsearch/dsl/parser/query/method/AbstractAtomMethodQueryParser.java

@@ -67,23 +67,34 @@ public abstract class AbstractAtomMethodQueryParser {
         catch (Exception ex) {
             try {
                 parseActionListener.onFailure(ex);
-            } catch (Exception exp) {
+            }
+            catch (Exception exp) {
                 //ignore;
             }
         }
     }
 
     protected Map<String, String> buildExtraMethodQueryParamsMap(String strMatchQueryParams) {
-        try {
-            Map<String, String> extraParamMap = Maps.newHashMap();
-            for (String paramPair : strMatchQueryParams.split(COMMA)) {
-                String[] paramPairArr = paramPair.split(COLON);
+        Map<String, String> extraParamMap = Maps.newHashMap();
+        for (String paramPair : strMatchQueryParams.split(COMMA)) {
+            String[] paramPairArr = paramPair.split(COLON);
+            if (paramPairArr.length == 2) {
                 extraParamMap.put(paramPairArr[0].trim(), paramPairArr[1].trim());
             }
-            return extraParamMap;
+            else {
+                throw new ElasticSql2DslException("[fulltext_query] Fulltext match query method param format error!");
+            }
         }
-        catch (Exception ex) {
-            throw new ElasticSql2DslException("[fulltext_query] Fulltext match query method param format error!");
+        return extraParamMap;
+    }
+
+    protected Boolean isExtraParamsString(String extraParams) {
+        for (String paramPair : extraParams.split(COMMA)) {
+            String[] paramPairArr = paramPair.split(COLON);
+            if (paramPairArr.length != 2) {
+                return Boolean.FALSE;
+            }
         }
+        return Boolean.TRUE;
     }
 }

src/main/java/org/elasticsearch/dsl/parser/query/method/fulltext/FullTextAtomQueryParser.java

@@ -14,6 +14,27 @@ public class FullTextAtomQueryParser {
         this.parseActionListener = parseActionListener;
     }
 
+    private static Boolean isMatchQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "match".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isMatchPrefixQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "multiMatch".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isQueryStringQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "queryString".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isSimpleQueryStringQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "simpleQueryString".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    public static Boolean isFulltextAtomQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return isMatchQuery(methodQueryExpr) || isMatchPrefixQuery(methodQueryExpr) ||
+                isQueryStringQuery(methodQueryExpr) || isSimpleQueryStringQuery(methodQueryExpr);
+    }
+
     public AtomQuery parseFullTextAtomQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
         AbstractAtomMethodQueryParser matchAtomQueryParser = getQueryParser(methodQueryExpr);
         return matchAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
@@ -23,31 +44,19 @@ public class FullTextAtomQueryParser {
         if (Boolean.TRUE == isMatchQuery(methodQueryExpr)) {
             return new MatchAtomQueryParser(parseActionListener);
         }
-        else if (Boolean.TRUE == isMatchPrefixQuery(methodQueryExpr)) {
+
+        if (Boolean.TRUE == isMatchPrefixQuery(methodQueryExpr)) {
             return new MultiMatchAtomQueryParser(parseActionListener);
         }
-        else if(Boolean.TRUE == isQueryStringQuery(methodQueryExpr)) {
+
+        if (Boolean.TRUE == isQueryStringQuery(methodQueryExpr)) {
             return new QueryStringAtomQueryParser(parseActionListener);
         }
-        else if(Boolean.TRUE == isSimpleQueryStringQuery(methodQueryExpr)) {
+
+        if (Boolean.TRUE == isSimpleQueryStringQuery(methodQueryExpr)) {
             return new SimpleQueryStringAtomQueryParser(parseActionListener);
         }
-        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", methodQueryExpr.getMethodName()));
-    }
 
-    private Boolean isMatchQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return "match".equalsIgnoreCase(methodQueryExpr.getMethodName());
-    }
-
-    private Boolean isMatchPrefixQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return "multiMatch".equalsIgnoreCase(methodQueryExpr.getMethodName());
-    }
-
-    private Boolean isQueryStringQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return "queryString".equalsIgnoreCase(methodQueryExpr.getMethodName());
-    }
-
-    private Boolean isSimpleQueryStringQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return "simpleQueryString".equalsIgnoreCase(methodQueryExpr.getMethodName());
+        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", methodQueryExpr.getMethodName()));
     }
 }

src/main/java/org/elasticsearch/dsl/parser/query/method/fulltext/MatchAtomQueryParser.java

@@ -37,7 +37,7 @@ public class MatchAtomQueryParser extends AbstractAtomMethodQueryParser {
         SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
         String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
-        if(StringUtils.isEmpty(text)) {
+        if (StringUtils.isEmpty(text)) {
             throw new ElasticSql2DslException("[syntax error] Search text can not be blank!");
         }
     }
@@ -50,8 +50,8 @@ public class MatchAtomQueryParser extends AbstractAtomMethodQueryParser {
 
         Map<String, String> extraParamMap = null;
         if (methodQueryExpr.getParameters().size() == 3) {
-            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
-            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+            SQLExpr extraParamExpr = methodQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
 
             extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
         }

src/main/java/org/elasticsearch/dsl/parser/query/method/fulltext/MultiMatchAtomQueryParser.java

@@ -54,8 +54,8 @@ public class MultiMatchAtomQueryParser extends AbstractAtomMethodQueryParser {
 
         Map<String, String> extraParamMap = null;
         if (methodQueryExpr.getParameters().size() == 3) {
-            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
-            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+            SQLExpr extraParamExpr = methodQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
 
             extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
         }
@@ -160,14 +160,14 @@ public class MultiMatchAtomQueryParser extends AbstractAtomMethodQueryParser {
         if (extraParamMap.containsKey("fuzziness")) {
             String val = extraParamMap.get("fuzziness");
 
-            if ("ZERO".equalsIgnoreCase(val)) {
+            if ("ZERO".equalsIgnoreCase(val) || "0".equals(val)) {
                 multiMatchQuery.fuzziness(Fuzziness.ZERO);
             }
-            if ("ONE".equalsIgnoreCase(val)) {
+            if ("ONE".equalsIgnoreCase(val) || "1".equals(val)) {
                 multiMatchQuery.fuzziness(Fuzziness.ONE);
             }
 
-            if ("TWO".equalsIgnoreCase(val)) {
+            if ("TWO".equalsIgnoreCase(val) || "2".equals(val)) {
                 multiMatchQuery.fuzziness(Fuzziness.TWO);
             }
 

src/main/java/org/elasticsearch/dsl/parser/query/method/fulltext/QueryStringAtomQueryParser.java

@@ -68,7 +68,8 @@ public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
 
         if (methodQueryExpr.getParameters().size() == 2) {
             extraParamExpr = methodQueryExpr.getParameters().get(1);
-        } else if (methodQueryExpr.getParameters().size() == 3) {
+        }
+        else if (methodQueryExpr.getParameters().size() == 3) {
             queryFields = methodQueryExpr.getParameters().get(1);
             extraParamExpr = methodQueryExpr.getParameters().get(2);
         }
@@ -226,14 +227,14 @@ public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
         if (extraParamMap.containsKey("fuzziness")) {
             String val = extraParamMap.get("fuzziness");
 
-            if ("ZERO".equalsIgnoreCase(val)) {
+            if ("ZERO".equalsIgnoreCase(val) || "0".equals(val)) {
                 queryStringQuery.fuzziness(Fuzziness.ZERO);
             }
-            if ("ONE".equalsIgnoreCase(val)) {
+            if ("ONE".equalsIgnoreCase(val) || "1".equals(val)) {
                 queryStringQuery.fuzziness(Fuzziness.ONE);
             }
 
-            if ("TWO".equalsIgnoreCase(val)) {
+            if ("TWO".equalsIgnoreCase(val) || "2".equals(val)) {
                 queryStringQuery.fuzziness(Fuzziness.TWO);
             }
 

src/main/java/org/elasticsearch/dsl/parser/query/method/fulltext/SimpleQueryStringAtomQueryParser.java

@@ -70,7 +70,8 @@ public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryPar
 
         if (methodQueryExpr.getParameters().size() == 2) {
             extraParamExpr = methodQueryExpr.getParameters().get(1);
-        } else if (methodQueryExpr.getParameters().size() == 3) {
+        }
+        else if (methodQueryExpr.getParameters().size() == 3) {
             queryFields = methodQueryExpr.getParameters().get(1);
             extraParamExpr = methodQueryExpr.getParameters().get(2);
         }
@@ -94,7 +95,6 @@ public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryPar
             extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
         }
 
-
         setExtraMatchQueryParam(simpleQueryString, extraParamMap);
 
         return new AtomQuery(simpleQueryString);

src/main/java/org/elasticsearch/dsl/parser/query/method/term/FuzzyAtomQueryParser.java

@@ -0,0 +1,120 @@
+package org.elasticsearch.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.common.unit.Fuzziness;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.IConditionMethodQueryBuilder;
+import org.elasticsearch.index.query.FuzzyQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+import java.util.Map;
+
+public class FuzzyAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public FuzzyAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "fuzzy".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected fuzzy query method name is [fuzzy],but get [%s]", methodQueryExpr.getMethodName()));
+        }
+
+        int paramCount = methodQueryExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: fuzzy", paramCount));
+        }
+
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Fuzzy text can not be blank!");
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryField = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        Map<String, String> extraParamMap = null;
+        if (methodQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+        }
+
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+
+        return parseCondition(queryField, new Object[]{text, extraParamMap}, queryAs, new IConditionMethodQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
+                FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery(queryFieldName, parameters[0].toString());
+
+                if (parameters.length == 2 && parameters[1] != null) {
+                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
+                    setExtraMatchQueryParam(fuzzyQuery, tExtraParamMap);
+                }
+
+                return fuzzyQuery;
+            }
+        });
+    }
+
+    private void setExtraMatchQueryParam(FuzzyQueryBuilder fuzzyQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            fuzzyQuery.boost(Float.valueOf(val));
+        }
+        if (extraParamMap.containsKey("transpositions")) {
+            String val = extraParamMap.get("transpositions");
+            fuzzyQuery.transpositions(Boolean.parseBoolean(val));
+        }
+        if (extraParamMap.containsKey("prefix_length")) {
+            String val = extraParamMap.get("prefix_length");
+            fuzzyQuery.prefixLength(Integer.valueOf(val));
+        }
+        if (extraParamMap.containsKey("max_expansions")) {
+            String val = extraParamMap.get("max_expansions");
+            fuzzyQuery.maxExpansions(Integer.valueOf(val));
+        }
+        if (extraParamMap.containsKey("rewrite")) {
+            String val = extraParamMap.get("rewrite");
+            fuzzyQuery.rewrite(val);
+        }
+
+        if (extraParamMap.containsKey("fuzziness")) {
+            String val = extraParamMap.get("fuzziness");
+
+            if ("ZERO".equalsIgnoreCase(val) || "0".equals(val)) {
+                fuzzyQuery.fuzziness(Fuzziness.ZERO);
+            }
+            if ("ONE".equalsIgnoreCase(val) || "1".equals(val)) {
+                fuzzyQuery.fuzziness(Fuzziness.ONE);
+            }
+
+            if ("TWO".equalsIgnoreCase(val) || "2".equals(val)) {
+                fuzzyQuery.fuzziness(Fuzziness.TWO);
+            }
+
+            if ("AUTO".equalsIgnoreCase(val)) {
+                fuzzyQuery.fuzziness(Fuzziness.AUTO);
+            }
+        }
+    }
+}

src/main/java/org/elasticsearch/dsl/parser/query/method/term/PrefixAtomQueryParser.java

@@ -1,9 +1,20 @@
 package org.elasticsearch.dsl.parser.query.method.term;
 
+import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
 import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.IConditionMethodQueryBuilder;
+import org.elasticsearch.index.query.PrefixQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+import java.util.Map;
 
 public class PrefixAtomQueryParser extends AbstractAtomMethodQueryParser {
 
@@ -13,28 +24,65 @@ public class PrefixAtomQueryParser extends AbstractAtomMethodQueryParser {
 
     @Override
     protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        /*
-        if (Boolean.FALSE == "match".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected match query method name is [match],but get [%s]", matchQueryExpr.getMethodName()));
+        if (Boolean.FALSE == "prefix".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected prefix query method name is [prefix],but get [%s]", methodQueryExpr.getMethodName()));
         }
 
-        int paramCount = matchQueryExpr.getParameters().size();
+        int paramCount = methodQueryExpr.getParameters().size();
         if (paramCount != 2 && paramCount != 3) {
             throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: match", paramCount));
         }
 
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
         String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
-        if(StringUtils.isEmpty(text)) {
-            throw new ElasticSql2DslException("[syntax error] Search text can not be blank!");
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Prefix text can not be blank!");
         }
-        */
     }
 
     @Override
     @SuppressWarnings("unchecked")
     protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        return null;
+        SQLExpr queryField = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        Map<String, String> extraParamMap = null;
+        if (methodQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+        }
+
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+
+        return parseCondition(queryField, new Object[]{text, extraParamMap}, queryAs, new IConditionMethodQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
+                PrefixQueryBuilder prefixQuery = QueryBuilders.prefixQuery(queryFieldName, parameters[0].toString());
+
+                if (parameters.length == 2 && parameters[1] != null) {
+                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
+                    setExtraMatchQueryParam(prefixQuery, tExtraParamMap);
+                }
+
+                return prefixQuery;
+            }
+        });
+    }
+
+    private void setExtraMatchQueryParam(PrefixQueryBuilder prefixQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            prefixQuery.boost(Float.valueOf(val));
+        }
+        if (extraParamMap.containsKey("rewrite")) {
+            String val = extraParamMap.get("rewrite");
+            prefixQuery.rewrite(val);
+        }
     }
 }

src/main/java/org/elasticsearch/dsl/parser/query/method/term/RegexpAtomQueryParser.java

@@ -0,0 +1,111 @@
+package org.elasticsearch.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import com.google.common.collect.Lists;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.IConditionMethodQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.RegexpFlag;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
+
+import java.util.List;
+import java.util.Map;
+
+public class RegexpAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public RegexpAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "regexp".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected regexp query method name is [regexp],but get [%s]", methodQueryExpr.getMethodName()));
+        }
+
+        int paramCount = methodQueryExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: regexp", paramCount));
+        }
+
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Regexp text can not be blank!");
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryField = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        Map<String, String> extraParamMap = null;
+        if (methodQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+        }
+
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+
+        return parseCondition(queryField, new Object[]{text, extraParamMap}, queryAs, new IConditionMethodQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
+                RegexpQueryBuilder regexpQuery = QueryBuilders.regexpQuery(queryFieldName, parameters[0].toString());
+
+                if (parameters.length == 2 && parameters[1] != null) {
+                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
+                    setExtraMatchQueryParam(regexpQuery, tExtraParamMap);
+                }
+
+                return regexpQuery;
+            }
+        });
+    }
+
+    private void setExtraMatchQueryParam(RegexpQueryBuilder regexpQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            regexpQuery.boost(Float.valueOf(val));
+        }
+        if (extraParamMap.containsKey("rewrite")) {
+            String val = extraParamMap.get("rewrite");
+            regexpQuery.rewrite(val);
+        }
+        if (extraParamMap.containsKey("max_determinized_states")) {
+            String val = extraParamMap.get("max_determinized_states");
+            regexpQuery.maxDeterminizedStates(Integer.valueOf(val));
+        }
+        if (extraParamMap.containsKey("flags")) {
+            String[] flags = extraParamMap.get("flags").split("\\|");
+            List<RegexpFlag> flagList = Lists.newLinkedList();
+            for (String flag : flags) {
+                flagList.add(RegexpFlag.valueOf(flag.toUpperCase()));
+            }
+            regexpQuery.flags(flagList.toArray(new RegexpFlag[flagList.size()]));
+        }
+        if (extraParamMap.containsKey("flags_value")) {
+            String[] flags = extraParamMap.get("flags_value").split("\\|");
+            List<RegexpFlag> flagList = Lists.newLinkedList();
+            for (String flag : flags) {
+                flagList.add(RegexpFlag.valueOf(flag.toUpperCase()));
+            }
+            regexpQuery.flags(flagList.toArray(new RegexpFlag[flagList.size()]));
+        }
+    }
+}

src/main/java/org/elasticsearch/dsl/parser/query/method/term/TermAtomQueryParser.java

@@ -0,0 +1,84 @@
+package org.elasticsearch.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.IConditionMethodQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.TermQueryBuilder;
+
+import java.util.Map;
+
+public class TermAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public TermAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "term".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected term query method name is [term],but get [%s]", methodQueryExpr.getMethodName()));
+        }
+
+        int paramCount = methodQueryExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: term", paramCount));
+        }
+
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Term text can not be blank!");
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryField = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        Map<String, String> extraParamMap = null;
+        if (methodQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+        }
+
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+
+        return parseCondition(queryField, new Object[]{text, extraParamMap}, queryAs, new IConditionMethodQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
+                TermQueryBuilder termQuery = QueryBuilders.termQuery(queryFieldName, parameters[0].toString());
+
+                if (parameters.length == 2 && parameters[1] != null) {
+                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
+                    setExtraMatchQueryParam(termQuery, tExtraParamMap);
+                }
+
+                return termQuery;
+            }
+        });
+    }
+
+    private void setExtraMatchQueryParam(TermQueryBuilder termQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            termQuery.boost(Float.valueOf(val));
+        }
+    }
+}

src/main/java/org/elasticsearch/dsl/parser/query/method/term/TermLevelAtomMethodQueryParser.java

@@ -1,32 +0,0 @@
-package org.elasticsearch.dsl.parser.query.method.term;
-
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
-import org.elasticsearch.dsl.bean.AtomQuery;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
-
-public class TermLevelAtomMethodQueryParser {
-
-    protected ParseActionListener parseActionListener;
-
-    public TermLevelAtomMethodQueryParser(ParseActionListener parseActionListener) {
-        this.parseActionListener = parseActionListener;
-    }
-
-    public AtomQuery parseTermLevelAtomQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        AbstractAtomMethodQueryParser matchAtomQueryParser = getQueryParser(methodQueryExpr);
-        return matchAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
-    }
-
-    private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr methodQueryExpr) {
-        if (Boolean.TRUE == isPrefixQuery(methodQueryExpr)) {
-            return new PrefixAtomQueryParser(parseActionListener);
-        }
-        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", methodQueryExpr.getMethodName()));
-    }
-
-    private Boolean isPrefixQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return "prefix".equalsIgnoreCase(methodQueryExpr.getMethodName());
-    }
-}

src/main/java/org/elasticsearch/dsl/parser/query/method/term/TermLevelAtomQueryParser.java

@@ -0,0 +1,73 @@
+package org.elasticsearch.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+
+public class TermLevelAtomQueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public TermLevelAtomQueryParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    private static Boolean isPrefixQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "prefix".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isTermQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "term".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isTermsQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "terms".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isWildcardQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "wildcard".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isRegexpQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "regexp".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private static Boolean isFuzzyQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "fuzzy".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    public static Boolean isTermLevelAtomQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return isPrefixQuery(methodQueryExpr) || isTermQuery(methodQueryExpr) ||
+                isTermsQuery(methodQueryExpr) || isWildcardQuery(methodQueryExpr) ||
+                isRegexpQuery(methodQueryExpr) || isFuzzyQuery(methodQueryExpr);
+    }
+
+    public AtomQuery parseTermLevelAtomQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        AbstractAtomMethodQueryParser matchAtomQueryParser = getQueryParser(methodQueryExpr);
+        return matchAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
+    }
+
+    private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr methodQueryExpr) {
+        if (Boolean.TRUE == isPrefixQuery(methodQueryExpr)) {
+            return new PrefixAtomQueryParser(parseActionListener);
+        }
+        if (Boolean.TRUE == isTermQuery(methodQueryExpr)) {
+            return new TermAtomQueryParser(parseActionListener);
+        }
+        if (Boolean.TRUE == isTermsQuery(methodQueryExpr)) {
+            return new TermsAtomQueryParser(parseActionListener);
+        }
+        if (Boolean.TRUE == isWildcardQuery(methodQueryExpr)) {
+            return new WildcardAtomQueryParser(parseActionListener);
+        }
+        if (Boolean.TRUE == isRegexpQuery(methodQueryExpr)) {
+            return new RegexpAtomQueryParser(parseActionListener);
+        }
+        if (Boolean.TRUE == isFuzzyQuery(methodQueryExpr)) {
+            return new FuzzyAtomQueryParser(parseActionListener);
+        }
+        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", methodQueryExpr.getMethodName()));
+    }
+}

src/main/java/org/elasticsearch/dsl/parser/query/method/term/TermsAtomQueryParser.java

@@ -0,0 +1,117 @@
+package org.elasticsearch.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import com.google.common.collect.Lists;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.IConditionMethodQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.TermsQueryBuilder;
+
+import java.util.List;
+import java.util.Map;
+
+public class TermsAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public TermsAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "terms".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected terms query method name is [terms],but get [%s]", methodQueryExpr.getMethodName()));
+        }
+
+        int paramCount = methodQueryExpr.getParameters().size();
+        if (paramCount <= 1) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: term", paramCount));
+        }
+
+        for (int idx = 1; idx < paramCount - 1; idx++) {
+            SQLExpr textExpr = methodQueryExpr.getParameters().get(idx);
+
+            String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+            if (StringUtils.isEmpty(text)) {
+                throw new ElasticSql2DslException("[syntax error] Terms text can not be blank!");
+            }
+        }
+
+        SQLExpr lastParam = methodQueryExpr.getParameters().get(paramCount - 1);
+        String lastParamText = ElasticSqlArgTransferHelper.transferSqlArg(lastParam, sqlArgs, false).toString();
+
+        if (Boolean.FALSE == isExtraParamsString(lastParamText) && StringUtils.isEmpty(lastParamText)) {
+            throw new ElasticSql2DslException("[syntax error] Terms text can not be blank!");
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryField = methodQueryExpr.getParameters().get(0);
+        int paramCount = methodQueryExpr.getParameters().size();
+
+        List<String> termTextList = Lists.newArrayList();
+        for (int idx = 1; idx < paramCount - 1; idx++) {
+            SQLExpr textExpr = methodQueryExpr.getParameters().get(idx);
+            String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+            termTextList.add(text);
+        }
+
+
+        SQLExpr lastParam = methodQueryExpr.getParameters().get(paramCount - 1);
+        String lastParamText = ElasticSqlArgTransferHelper.transferSqlArg(lastParam, sqlArgs, false).toString();
+
+        Map<String, String> extraParamMap = null;
+        if (isExtraParamsString(lastParamText)) {
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(lastParam, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+        }
+        else {
+            termTextList.add(lastParamText);
+        }
+
+
+        return parseCondition(queryField, new Object[]{termTextList, extraParamMap}, queryAs, new IConditionMethodQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
+                TermsQueryBuilder termsQuery = QueryBuilders.termsQuery(queryFieldName, (List<String>) parameters[0]);
+
+                if (parameters.length == 2 && parameters[1] != null) {
+                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
+                    setExtraMatchQueryParam(termsQuery, tExtraParamMap);
+                }
+
+                return termsQuery;
+            }
+        });
+    }
+
+    private void setExtraMatchQueryParam(TermsQueryBuilder termsQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            termsQuery.boost(Float.valueOf(val));
+        }
+        if (extraParamMap.containsKey("minimum_should_match")) {
+            String val = extraParamMap.get("minimum_should_match");
+            termsQuery.minimumShouldMatch(val);
+        }
+        if (extraParamMap.containsKey("disable_coord")) {
+            String val = extraParamMap.get("disable_coord");
+            termsQuery.disableCoord(Boolean.parseBoolean(val));
+        }
+
+
+    }
+}

src/main/java/org/elasticsearch/dsl/parser/query/method/term/WildcardAtomQueryParser.java

@@ -0,0 +1,88 @@
+package org.elasticsearch.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.IConditionMethodQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
+
+import java.util.Map;
+
+public class WildcardAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public WildcardAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "wildcard".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected wildcard query method name is [wildcard],but get [%s]", methodQueryExpr.getMethodName()));
+        }
+
+        int paramCount = methodQueryExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: wildcard", paramCount));
+        }
+
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Wildcard text can not be blank!");
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryField = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+
+        Map<String, String> extraParamMap = null;
+        if (methodQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+        }
+
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+
+        return parseCondition(queryField, new Object[]{text, extraParamMap}, queryAs, new IConditionMethodQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
+                WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery(queryFieldName, parameters[0].toString());
+
+                if (parameters.length == 2 && parameters[1] != null) {
+                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
+                    setExtraMatchQueryParam(wildcardQuery, tExtraParamMap);
+                }
+
+                return wildcardQuery;
+            }
+        });
+    }
+
+    private void setExtraMatchQueryParam(WildcardQueryBuilder wildcardQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            wildcardQuery.boost(Float.valueOf(val));
+        }
+        if (extraParamMap.containsKey("rewrite")) {
+            String val = extraParamMap.get("rewrite");
+            wildcardQuery.rewrite(val);
+        }
+    }
+}

src/main/java/org/elasticsearch/dsl/parser/sql/AbstractQueryConditionParser.java

@@ -11,10 +11,11 @@ import org.elasticsearch.dsl.enums.SQLBoolOperator;
 import org.elasticsearch.dsl.enums.SQLConditionType;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.exact.InListAtomQueryParser;
-import org.elasticsearch.dsl.parser.query.method.fulltext.FullTextAtomQueryParser;
 import org.elasticsearch.dsl.parser.query.exact.BetweenAndAtomQueryParser;
 import org.elasticsearch.dsl.parser.query.exact.BinaryAtomQueryParser;
+import org.elasticsearch.dsl.parser.query.exact.InListAtomQueryParser;
+import org.elasticsearch.dsl.parser.query.method.fulltext.FullTextAtomQueryParser;
+import org.elasticsearch.dsl.parser.query.method.term.TermLevelAtomQueryParser;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
@@ -57,11 +58,11 @@ public abstract class AbstractQueryConditionParser implements QueryParser {
                 return new SQLCondition(mergedQueryList, operator);
             }
         }
-        else if(conditionExpr instanceof SQLNotExpr) {
+        else if (conditionExpr instanceof SQLNotExpr) {
             SQLCondition innerSqlCondition = recursiveParseQueryCondition(((SQLNotExpr) conditionExpr).getExpr(), queryAs, sqlArgs);
 
             SQLBoolOperator operator = innerSqlCondition.getOperator();
-            if(SQLConditionType.Atom == innerSqlCondition.getSQLConditionType()) {
+            if (SQLConditionType.Atom == innerSqlCondition.getSQLConditionType()) {
                 operator = SQLBoolOperator.AND;
             }
 
@@ -76,8 +77,17 @@ public abstract class AbstractQueryConditionParser implements QueryParser {
 
     private AtomQuery parseAtomQueryCondition(SQLExpr sqlConditionExpr, String queryAs, Object[] sqlArgs) {
         if (sqlConditionExpr instanceof SQLMethodInvokeExpr) {
-            FullTextAtomQueryParser fullTextAtomQueryParser = new FullTextAtomQueryParser(parseActionListener);
-            return fullTextAtomQueryParser.parseFullTextAtomQuery((SQLMethodInvokeExpr) sqlConditionExpr, queryAs, sqlArgs);
+            SQLMethodInvokeExpr methodQueryExpr = (SQLMethodInvokeExpr) sqlConditionExpr;
+
+            if (FullTextAtomQueryParser.isFulltextAtomQuery(methodQueryExpr)) {
+                FullTextAtomQueryParser fullTextAtomQueryParser = new FullTextAtomQueryParser(parseActionListener);
+                return fullTextAtomQueryParser.parseFullTextAtomQuery(methodQueryExpr, queryAs, sqlArgs);
+            }
+
+            if (TermLevelAtomQueryParser.isTermLevelAtomQuery(methodQueryExpr)) {
+                TermLevelAtomQueryParser termLevelAtomQueryParser = new TermLevelAtomQueryParser(parseActionListener);
+                return termLevelAtomQueryParser.parseTermLevelAtomQuery(methodQueryExpr, queryAs, sqlArgs);
+            }
         }
         else if (sqlConditionExpr instanceof SQLBinaryOpExpr) {
             BinaryAtomQueryParser binaryQueryParser = new BinaryAtomQueryParser(parseActionListener);

src/main/java/org/elasticsearch/dsl/parser/sql/QueryFieldParser.java

@@ -21,6 +21,57 @@ public class QueryFieldParser {
     private static final String NESTED_DOC_IDF = "$";
     private static final String FIELD_REF_PATH_DOT = ".";
 
+    private static List<QueryFieldReferenceNode> parseQueryFieldExprToRefPath(SQLExpr queryFieldExpr) {
+        List<QueryFieldReferenceNode> referencePathNodes = Lists.newLinkedList();
+
+        if (queryFieldExpr instanceof SQLIdentifierExpr) {
+            String idfName = ((SQLIdentifierExpr) queryFieldExpr).getName();
+            QueryFieldReferenceNode referenceNode = buildReferenceNode(idfName);
+            referencePathNodes.add(referenceNode);
+
+            return referencePathNodes;
+        }
+
+        if (queryFieldExpr instanceof SQLPropertyExpr) {
+            List<String> queryFieldTextList = Lists.newLinkedList();
+
+            SQLExpr tmpLoopExpr = queryFieldExpr;
+
+            while ((tmpLoopExpr != null) && (tmpLoopExpr instanceof SQLPropertyExpr)) {
+                queryFieldTextList.add(((SQLPropertyExpr) tmpLoopExpr).getName());
+                tmpLoopExpr = ((SQLPropertyExpr) tmpLoopExpr).getOwner();
+            }
+
+            if (tmpLoopExpr instanceof SQLIdentifierExpr) {
+                queryFieldTextList.add(((SQLIdentifierExpr) tmpLoopExpr).getName());
+            }
+
+            Collections.reverse(queryFieldTextList);
+            for (String strRefNode : queryFieldTextList) {
+                QueryFieldReferenceNode referenceNode = buildReferenceNode(strRefNode);
+                referencePathNodes.add(referenceNode);
+            }
+
+            return referencePathNodes;
+        }
+
+        throw new ElasticSql2DslException(String.format("[syntax error] can not support query field type[%s]", queryFieldExpr.toString()));
+    }
+
+    private static QueryFieldReferenceNode buildReferenceNode(String strRefNodeName) {
+        QueryFieldReferenceNode referenceNode = null;
+        if (strRefNodeName.startsWith(NESTED_DOC_IDF)) {
+            if (NESTED_DOC_IDF.equals(strRefNodeName)) {
+                throw new ElasticSql2DslException("[syntax error] nested doc query field can not be blank");
+            }
+            referenceNode = new QueryFieldReferenceNode(strRefNodeName.substring(1), true);
+        }
+        else {
+            referenceNode = new QueryFieldReferenceNode(strRefNodeName, false);
+        }
+        return referenceNode;
+    }
+
     public ElasticSqlQueryField parseSelectQueryField(SQLExpr queryFieldExpr, String queryAs) {
         if (queryFieldExpr instanceof SQLAllColumnExpr) {
             return ElasticSqlQueryFields.newMatchAllRootDocField();
@@ -115,54 +166,4 @@ public class QueryFieldParser {
 
         return referencePath;
     }
-
-    private static List<QueryFieldReferenceNode> parseQueryFieldExprToRefPath(SQLExpr queryFieldExpr) {
-        List<QueryFieldReferenceNode> referencePathNodes = Lists.newLinkedList();
-
-        if (queryFieldExpr instanceof SQLIdentifierExpr) {
-            String idfName = ((SQLIdentifierExpr) queryFieldExpr).getName();
-            QueryFieldReferenceNode referenceNode = buildReferenceNode(idfName);
-            referencePathNodes.add(referenceNode);
-
-            return referencePathNodes;
-        }
-
-        if (queryFieldExpr instanceof SQLPropertyExpr) {
-            List<String> queryFieldTextList = Lists.newLinkedList();
-
-            SQLExpr tmpLoopExpr = queryFieldExpr;
-
-            while ((tmpLoopExpr != null) && (tmpLoopExpr instanceof SQLPropertyExpr)) {
-                queryFieldTextList.add(((SQLPropertyExpr) tmpLoopExpr).getName());
-                tmpLoopExpr = ((SQLPropertyExpr) tmpLoopExpr).getOwner();
-            }
-
-            if (tmpLoopExpr instanceof SQLIdentifierExpr) {
-                queryFieldTextList.add(((SQLIdentifierExpr) tmpLoopExpr).getName());
-            }
-
-            Collections.reverse(queryFieldTextList);
-            for (String strRefNode : queryFieldTextList) {
-                QueryFieldReferenceNode referenceNode = buildReferenceNode(strRefNode);
-                referencePathNodes.add(referenceNode);
-            }
-
-            return referencePathNodes;
-        }
-
-        throw new ElasticSql2DslException(String.format("[syntax error] can not support query field type[%s]", queryFieldExpr.toString()));
-    }
-
-    private static QueryFieldReferenceNode buildReferenceNode(String strRefNodeName) {
-        QueryFieldReferenceNode referenceNode = null;
-        if (strRefNodeName.startsWith(NESTED_DOC_IDF)) {
-            if(NESTED_DOC_IDF.equals(strRefNodeName)) {
-                throw new ElasticSql2DslException("[syntax error] nested doc query field can not be blank");
-            }
-            referenceNode = new QueryFieldReferenceNode(strRefNodeName.substring(1), true);
-        } else {
-            referenceNode = new QueryFieldReferenceNode(strRefNodeName, false);
-        }
-        return referenceNode;
-    }
 }

src/main/java/org/elasticsearch/dsl/parser/sql/QueryFromParser.java

@@ -4,10 +4,10 @@ import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
 import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
 import com.alibaba.druid.sql.ast.statement.SQLExprTableSource;
 import com.google.common.collect.Lists;
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
-import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
+import org.elasticsearch.dsl.listener.ParseActionListener;
 
 public class QueryFromParser implements QueryParser {
 
@@ -29,12 +29,14 @@ public class QueryFromParser implements QueryParser {
                 dslContext.getParseResult().setIndices(Lists.newArrayList(index));
                 return;
             }
+
             if (tableSource.getExpr() instanceof SQLPropertyExpr) {
                 SQLPropertyExpr idxExpr = (SQLPropertyExpr) tableSource.getExpr();
 
                 if (!(idxExpr.getOwner() instanceof SQLIdentifierExpr)) {
                     throw new ElasticSql2DslException("[syntax error] From table should like [index].[type]");
                 }
+
                 String index = ((SQLIdentifierExpr) idxExpr.getOwner()).getName();
                 dslContext.getParseResult().setIndices(Lists.newArrayList(index));
                 dslContext.getParseResult().setType(idxExpr.getName());

src/main/java/org/elasticsearch/dsl/parser/sql/QueryGroupByParser.java

@@ -5,6 +5,7 @@ import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.statement.SQLSelectGroupByClause;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.bean.RangeSegment;
@@ -21,7 +22,6 @@ import org.elasticsearch.search.aggregations.bucket.range.RangeBuilder;
 import org.elasticsearch.search.aggregations.bucket.range.date.DateRangeBuilder;
 import org.elasticsearch.search.aggregations.bucket.terms.Terms;
 import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.joda.time.DateTime;
 import org.joda.time.format.DateTimeFormat;
 import org.joda.time.format.DateTimeFormatter;
@@ -41,6 +41,12 @@ public class QueryGroupByParser implements QueryParser {
         this.parseActionListener = parseActionListener;
     }
 
+    public static Date getDateRangeVal(String date) {
+        final String dateRangeValPattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
+        DateTimeFormatter formatter = DateTimeFormat.forPattern(dateRangeValPattern);
+        return formatter.parseDateTime(date).toDate();
+    }
+
     @Override
     public void parse(ElasticDslContext dslContext) {
 
@@ -87,7 +93,7 @@ public class QueryGroupByParser implements QueryParser {
         QueryFieldParser queryFieldParser = new QueryFieldParser();
 
         ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(termsFieldExpr, queryAs);
-        if(queryField.getQueryFieldType() != QueryFieldType.RootDocField && queryField.getQueryFieldType() != QueryFieldType.InnerDocField) {
+        if (queryField.getQueryFieldType() != QueryFieldType.RootDocField && queryField.getQueryFieldType() != QueryFieldType.InnerDocField) {
             throw new ElasticSql2DslException(String.format("[syntax error] can not support terms aggregation for field type[%s]", queryField.getQueryFieldType()));
         }
 
@@ -99,7 +105,7 @@ public class QueryGroupByParser implements QueryParser {
         QueryFieldParser queryFieldParser = new QueryFieldParser();
 
         ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(rangeFieldExpr, queryAs);
-        if(queryField.getQueryFieldType() != QueryFieldType.RootDocField && queryField.getQueryFieldType() != QueryFieldType.InnerDocField) {
+        if (queryField.getQueryFieldType() != QueryFieldType.RootDocField && queryField.getQueryFieldType() != QueryFieldType.InnerDocField) {
             throw new ElasticSql2DslException(String.format("[syntax error] can not support range aggregation for field type[%s]", queryField.getQueryFieldType()));
         }
 
@@ -161,10 +167,4 @@ public class QueryGroupByParser implements QueryParser {
         final String dateRangeKeyPattern = "yyyy-MM-dd HH:mm:ss";
         return new DateTime(date).toString(dateRangeKeyPattern);
     }
-
-    public static Date getDateRangeVal(String date) {
-        final String dateRangeValPattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
-        DateTimeFormatter formatter = DateTimeFormat.forPattern(dateRangeValPattern);
-        return formatter.parseDateTime(date).toDate();
-    }
 }

src/main/java/org/elasticsearch/dsl/parser/sql/QueryLimitSizeParser.java

@@ -3,11 +3,11 @@ package org.elasticsearch.dsl.parser.sql;
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 
 public class QueryLimitSizeParser implements QueryParser {
 
@@ -26,7 +26,8 @@ public class QueryLimitSizeParser implements QueryParser {
 
             Integer size = parseLimitInteger(queryBlock.getLimit().getRowCount(), dslContext.getSqlArgs());
             dslContext.getParseResult().setSize(size);
-        } else {
+        }
+        else {
             dslContext.getParseResult().setFrom(0);
             dslContext.getParseResult().setSize(15);
         }
@@ -35,14 +36,16 @@ public class QueryLimitSizeParser implements QueryParser {
     public Integer parseLimitInteger(SQLExpr limitInt, Object[] args) {
         if (limitInt instanceof SQLIntegerExpr) {
             return ((SQLIntegerExpr) limitInt).getNumber().intValue();
-        } else if (limitInt instanceof SQLVariantRefExpr) {
+        }
+        else if (limitInt instanceof SQLVariantRefExpr) {
             SQLVariantRefExpr varLimitExpr = (SQLVariantRefExpr) limitInt;
-            final Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(varLimitExpr, args);
+            Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(varLimitExpr, args);
             if (!(targetVal instanceof Integer)) {
                 throw new ElasticSql2DslException("[syntax error] Sql limit expr should be a non-negative number");
             }
             return Integer.valueOf(targetVal.toString());
-        } else {
+        }
+        else {
             throw new ElasticSql2DslException("[syntax error] Sql limit expr should be a non-negative number");
         }
     }

src/main/java/org/elasticsearch/dsl/parser/sql/QueryMatchConditionParser.java

@@ -1,9 +1,9 @@
 package org.elasticsearch.dsl.parser.sql;
 
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 
 public class QueryMatchConditionParser extends AbstractQueryConditionParser {
 

src/main/java/org/elasticsearch/dsl/parser/sql/QueryOrderConditionParser.java

@@ -10,6 +10,7 @@ import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
 import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.enums.QueryFieldType;
@@ -22,7 +23,6 @@ import org.elasticsearch.search.sort.FieldSortBuilder;
 import org.elasticsearch.search.sort.SortBuilder;
 import org.elasticsearch.search.sort.SortBuilders;
 import org.elasticsearch.search.sort.SortOrder;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
 
@@ -57,7 +57,8 @@ public class QueryOrderConditionParser implements QueryParser {
                 public FieldSortBuilder buildSort(String queryFieldName) {
                     if (SQLOrderingSpecification.ASC == orderByItem.getType()) {
                         return SortBuilders.fieldSort(queryFieldName).order(SortOrder.ASC);
-                    } else {
+                    }
+                    else {
                         return SortBuilders.fieldSort(queryFieldName).order(SortOrder.DESC);
                     }
                 }
@@ -76,7 +77,8 @@ public class QueryOrderConditionParser implements QueryParser {
 
                         if (SQLOrderingSpecification.ASC == orderByItem.getType()) {
                             fieldSortBuilder = SortBuilders.fieldSort(idfName).order(SortOrder.ASC).missing(valueArg);
-                        } else {
+                        }
+                        else {
                             fieldSortBuilder = SortBuilders.fieldSort(idfName).order(SortOrder.DESC).missing(valueArg);
                         }
 
@@ -99,17 +101,17 @@ public class QueryOrderConditionParser implements QueryParser {
         ElasticSqlQueryField sortField = queryFieldParser.parseConditionQueryField(sqlExpr, queryAs);
 
         SortBuilder rtnSortBuilder = null;
-        if(sortField.getQueryFieldType() == QueryFieldType.RootDocField || sortField.getQueryFieldType() == QueryFieldType.InnerDocField) {
+        if (sortField.getQueryFieldType() == QueryFieldType.RootDocField || sortField.getQueryFieldType() == QueryFieldType.InnerDocField) {
             rtnSortBuilder = sortBuilder.buildSort(sortField.getQueryFieldFullName());
         }
 
-        if(sortField.getQueryFieldType() == QueryFieldType.NestedDocField) {
+        if (sortField.getQueryFieldType() == QueryFieldType.NestedDocField) {
             FieldSortBuilder originalSort = sortBuilder.buildSort(sortField.getQueryFieldFullName());
             originalSort.setNestedPath(sortField.getNestedDocContextPath());
             rtnSortBuilder = originalSort;
         }
 
-        if(rtnSortBuilder == null) {
+        if (rtnSortBuilder == null) {
             throw new ElasticSql2DslException(String.format("[syntax error] sort condition field can not support type[%s]", sortField.getQueryFieldType()));
         }
 

src/main/java/org/elasticsearch/dsl/parser/sql/QueryRoutingValParser.java

@@ -5,11 +5,11 @@ import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
 
@@ -29,13 +29,15 @@ public class QueryRoutingValParser implements QueryParser {
             for (SQLExpr routingVal : queryBlock.getRouting().getRoutingValues()) {
                 if (routingVal instanceof SQLCharExpr) {
                     routingStringValues.add(((SQLCharExpr) routingVal).getText());
-                } else if (routingVal instanceof SQLVariantRefExpr) {
+                }
+                else if (routingVal instanceof SQLVariantRefExpr) {
                     Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(routingVal, dslContext.getSqlArgs());
                     if (!(targetVal instanceof String)) {
                         throw new ElasticSql2DslException("[syntax error] Index routing val must be a string");
                     }
                     routingStringValues.add((String) targetVal);
-                } else {
+                }
+                else {
                     throw new ElasticSql2DslException("[syntax error] Index routing val must be a string");
                 }
             }

src/main/java/org/elasticsearch/dsl/parser/sql/QuerySelectFieldListParser.java

@@ -5,6 +5,7 @@ import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr;
 import com.alibaba.druid.sql.ast.statement.SQLSelectItem;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.enums.QueryFieldType;
@@ -14,7 +15,6 @@ import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilders;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
 
@@ -68,7 +68,8 @@ public class QuerySelectFieldListParser implements QueryParser {
                 for (AbstractAggregationBuilder aggItem : aggregations) {
                     lastLevelAggItem.subAggregation(aggItem);
                 }
-            } else {
+            }
+            else {
                 dslContext.getParseResult().setTopStatsAgg();
                 dslContext.getParseResult().setGroupBy(aggregations);
             }
@@ -102,10 +103,12 @@ public class QuerySelectFieldListParser implements QueryParser {
     private void onSelectFieldParse(ElasticSqlQueryField field) {
         try {
             parseActionListener.onSelectFieldParse(field);
-        } catch (Exception ex) {
+        }
+        catch (Exception ex) {
             try {
                 parseActionListener.onFailure(ex);
-            } catch (Exception exp) {
+            }
+            catch (Exception exp) {
                 //ignore;
             }
         }

src/main/java/org/elasticsearch/dsl/parser/sql/QueryWhereConditionParser.java

@@ -1,9 +1,9 @@
 package org.elasticsearch.dsl.parser.sql;
 
+import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.druid.ElasticSqlSelectQueryBlock;
 
 public class QueryWhereConditionParser extends AbstractQueryConditionParser {
 

src/main/java/org/elasticsearch/util/ElasticMockClient.java

@@ -49,6 +49,12 @@ import org.elasticsearch.threadpool.ThreadPool;
 
 public class ElasticMockClient implements Client {
 
+    private static final Client mockClient = new ElasticMockClient();
+
+    public static Client get() {
+        return mockClient;
+    }
+
     @Override
     public AdminClient admin() {
         return null;
@@ -483,10 +489,4 @@ public class ElasticMockClient implements Client {
     public void close() {
 
     }
-
-    private static final Client mockClient = new ElasticMockClient();
-
-    public static Client get() {
-        return mockClient;
-    }
 }

src/test/java/org/elasticsearch/SqlParserLimitTest.java

@@ -30,4 +30,18 @@ public class SqlParserLimitTest {
 
         System.out.println(parseResult.toDsl());
     }
+
+    @Test
+    public void testX() {
+        //String sql = "select $bookCategories from index.library t where t.manager.managerName='lcy'";
+        //String sql = "select $bookCategories from index.library where $bookCategories.$books.bookStock > 10";
+        //String sql = "select $bookCategories from index.library where $bookCategories.$books.bookPublisher.$bookProvider.providerName='PVD_01'";
+        //String sql = "select $bookCategories from index.library where $bookCategories.$books.bookStock > 10 and $bookCategories.$books.bookPublisher.$bookProvider.providerName='PVD_01'";
+
+        String sql = "select * from index.library t query prefix(t.manager.managerName, 'lc') where $bookCategories.$books.bookStock > 10";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+        System.out.println(parseResult.toDsl());
+    }
 }

src/test/java/org/elasticsearch/SqlParserListenerTest.java

@@ -3,8 +3,8 @@ package org.elasticsearch;
 import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
 import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.enums.SQLConditionOperator;
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
 import org.elasticsearch.dsl.listener.ParseActionListenerAdapter;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
 import org.junit.Assert;
 import org.junit.Test;
 

src/test/java/org/elasticsearch/SqlParserOrderByTest.java

@@ -59,20 +59,4 @@ public class SqlParserOrderByTest {
 //        targetSort = SortBuilders.fieldSort("productTags.sortNo").order(SortOrder.DESC).setNestedPath("productTags");
 //        Assert.assertEquals(parseResult.getOrderBy().get(1).toString(), targetSort.toString());
     }
-
-    @Test
-    public void testX() {
-
-        //String druid = "select * from index.order where status='SUCCESS' match_query id=123 limit 0,100";
-
-        String sql = "select * from index.order query id=123 where status='SUCCESS' limit 0,100";
-
-        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
-        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
-        String dsl = parseResult.toDsl();
-
-        System.out.println(dsl);
-
-    }
-
 }

src/test/java/org/elasticsearch/SqlParserQueryTest.java

@@ -56,4 +56,76 @@ public class SqlParserQueryTest {
 
         System.out.println(parseResult.toDsl());
     }
+
+    @Test
+    public void testParsePrefixQueryExpr() {
+        String sql = "select id,status from index.order t "
+                + "query prefix(t.productName, '皮鞋', 'boost:2.0f')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseTermQueryExpr() {
+        String sql = "select id,status from index.order t "
+                + "query term(t.productName, '皮鞋', 'boost:2.0f')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseTermsQueryExpr() {
+        String sql = "select id,status from index.order t "
+                + "query terms(t.productName, '皮鞋', '凉鞋', 'boost:2.0f')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseWildcardQueryExpr() {
+        String sql = "select id,status from index.order t "
+                + "query wildcard(t.productName, '*鞋', 'boost:2.0f')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseRegexpQueryExpr() {
+        String sql = "select id,status from index.order t "
+                + "query regexp(t.productName, '*鞋', 'boost:2.0f,flags:INTERSECTION|COMPLEMENT')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseFuzzyQueryExpr() {
+        String sql = "select id,status from index.order t "
+                + "query fuzzy(t.productName, '鞋', 'boost:2.0f,fuzziness:2')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
 }

src/test/java/org/elasticsearch/SqlParserRoutingTest.java

@@ -1,7 +1,7 @@
 package org.elasticsearch;
 
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
 import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
 import org.junit.Assert;
 import org.junit.Test;
 

src/test/java/org/elasticsearch/SqlParserSelectFieldTest.java

@@ -1,8 +1,8 @@
 package org.elasticsearch;
 
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
 import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
 import org.junit.Assert;
 import org.junit.Test;