x

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

@@ -13,7 +13,7 @@ import org.elasticsearch.index.query.QueryBuilder;
 
 import java.util.Map;
 
-public abstract class AbstractAtomMethodQueryParser {
+public abstract class AbstractAtomMethodQueryParser implements MethodQueryParser {
 
     protected static final String COMMA = ",";
 
@@ -34,10 +34,10 @@ public abstract class AbstractAtomMethodQueryParser {
     }
 
 
-    public final AtomQuery parseAtomMethodQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        checkQueryMethod(methodQueryExpr, queryAs, sqlArgs);
+    public final AtomQuery parseAtomMethodQuery(MethodInvocation invocation) {
+        checkQueryMethod(invocation.getMatchQueryExpr(), invocation.getQueryAs(), invocation.getSqlArgs());
 
-        return parseMethodQueryExpr(methodQueryExpr, queryAs, sqlArgs);
+        return parseMethodQueryExpr(invocation.getMatchQueryExpr(), invocation.getQueryAs(), invocation.getSqlArgs());
     }
 
     protected AtomQuery parseCondition(SQLExpr queryFieldExpr, Object[] parameters, String queryAs, IConditionMethodQueryBuilder queryBuilder) {

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/query/method/AbstractFieldSpecificMethodQueryParser.java

@@ -0,0 +1,75 @@
+package org.elasticsearch.dsl.parser.query.method;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
+import org.elasticsearch.dsl.enums.QueryFieldType;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.sql.QueryFieldParser;
+import org.elasticsearch.index.query.QueryBuilder;
+
+import java.util.Map;
+
+public abstract class AbstractFieldSpecificMethodQueryParser extends ParameterizedMethodQueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public AbstractFieldSpecificMethodQueryParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    protected abstract QueryBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams);
+
+    protected abstract SQLExpr getFieldExpr(MethodInvocation invocation);
+
+    @Override
+    protected String getExtraParamString(MethodInvocation invocation) {
+        //ignore extra params, subclass can override if necessary
+        return null;
+    }
+
+    @Override
+    protected AtomQuery parseMethodQueryWithExtraParams(MethodInvocation invocation, Map<String, String> extraParamMap) throws ElasticSql2DslException {
+        return parseCondition(invocation, extraParamMap);
+    }
+
+    private AtomQuery parseCondition(MethodInvocation invocation, Map<String, String> extraParamMap) {
+        QueryFieldParser queryFieldParser = new QueryFieldParser();
+        ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(getFieldExpr(invocation), invocation.getQueryAs());
+
+        AtomQuery atomQuery = null;
+        if (queryField.getQueryFieldType() == QueryFieldType.RootDocField || queryField.getQueryFieldType() == QueryFieldType.InnerDocField) {
+            QueryBuilder originalQuery = buildQuery(invocation, queryField.getQueryFieldFullName(), extraParamMap);
+            atomQuery = new AtomQuery(originalQuery);
+        }
+
+        if (queryField.getQueryFieldType() == QueryFieldType.NestedDocField) {
+            QueryBuilder originalQuery = buildQuery(invocation, queryField.getQueryFieldFullName(), extraParamMap);
+            atomQuery = new AtomQuery(originalQuery, queryField.getNestedDocContextPath());
+        }
+
+        if (atomQuery == null) {
+            throw new ElasticSql2DslException(String.format("[syntax error] query condition field can not support type[%s]", queryField.getQueryFieldType()));
+        }
+
+        onAtomMethodQueryConditionParse(queryField, invocation.getSqlArgs());
+
+        return atomQuery;
+    }
+
+
+    private void onAtomMethodQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters) {
+        try {
+            parseActionListener.onAtomMethodQueryConditionParse(paramName, parameters);
+        }
+        catch (Exception ex) {
+            try {
+                parseActionListener.onFailure(ex);
+            }
+            catch (Exception exp) {
+                //ignore;
+            }
+        }
+    }
+}

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/query/method/AbstractFieldSpecifiedMethodQueryParser.java

@@ -1,104 +0,0 @@
-//package org.elasticsearch.dsl.parser.query.method;
-//
-//import com.alibaba.druid.sql.ast.SQLExpr;
-//import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
-//import com.google.common.collect.Maps;
-//import org.elasticsearch.dsl.bean.AtomQuery;
-//import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
-//import org.elasticsearch.dsl.enums.QueryFieldType;
-//import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-//import org.elasticsearch.dsl.listener.ParseActionListener;
-//import org.elasticsearch.dsl.parser.sql.QueryFieldParser;
-//import org.elasticsearch.index.query.QueryBuilder;
-//
-//import java.util.Map;
-//
-//public abstract class AbstractFieldSpecifiedMethodQueryParser extends CheckableMethodQueryParser {
-//
-//    protected static final String COMMA = ",";
-//
-//    protected static final String COLON = ":";
-//
-//    protected ParseActionListener parseActionListener;
-//
-//    public AbstractFieldSpecifiedMethodQueryParser(ParseActionListener parseActionListener) {
-//        this.parseActionListener = parseActionListener;
-//    }
-//
-//    protected abstract void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
-//
-//    protected abstract AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
-//
-//    protected interface IConditionMethodQueryBuilder {
-//        QueryBuilder buildQuery(String queryFieldName, Object[] parameters);
-//    }
-//
-//
-//    public final AtomQuery parseAtomMethodQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-//        checkQueryMethod(methodQueryExpr, queryAs, sqlArgs);
-//
-//        return parseMethodQueryExpr(methodQueryExpr, queryAs, sqlArgs);
-//    }
-//
-//    protected AtomQuery parseCondition(SQLExpr queryFieldExpr, Object[] parameters, String queryAs, IConditionMethodQueryBuilder queryBuilder) {
-//        QueryFieldParser queryFieldParser = new QueryFieldParser();
-//        ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(queryFieldExpr, queryAs);
-//
-//        AtomQuery atomQuery = null;
-//        if (queryField.getQueryFieldType() == QueryFieldType.RootDocField || queryField.getQueryFieldType() == QueryFieldType.InnerDocField) {
-//            QueryBuilder originalQuery = queryBuilder.buildQuery(queryField.getQueryFieldFullName(), parameters);
-//            atomQuery = new AtomQuery(originalQuery);
-//        }
-//
-//        if (queryField.getQueryFieldType() == QueryFieldType.NestedDocField) {
-//            QueryBuilder originalQuery = queryBuilder.buildQuery(queryField.getQueryFieldFullName(), parameters);
-//            atomQuery = new AtomQuery(originalQuery, queryField.getNestedDocContextPath());
-//        }
-//
-//        if (atomQuery == null) {
-//            throw new ElasticSql2DslException(String.format("[syntax error] query condition field can not support type[%s]", queryField.getQueryFieldType()));
-//        }
-//
-//        onAtomMethodQueryConditionParse(queryField, parameters);
-//
-//        return atomQuery;
-//    }
-//
-//    private void onAtomMethodQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters) {
-//        try {
-//            parseActionListener.onAtomMethodQueryConditionParse(paramName, parameters);
-//        }
-//        catch (Exception ex) {
-//            try {
-//                parseActionListener.onFailure(ex);
-//            }
-//            catch (Exception exp) {
-//                //ignore;
-//            }
-//        }
-//    }
-//
-//    protected Map<String, String> buildExtraMethodQueryParamsMap(String strMatchQueryParams) {
-//        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());
-//            }
-//            else {
-//                throw new ElasticSql2DslException("Failed to parse query method params!");
-//            }
-//        }
-//        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;
-//    }
-//}

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/query/method/CheckableMethodQueryParser.java

@@ -1,18 +1,17 @@
 package org.elasticsearch.dsl.parser.query.method;
 
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import org.elasticsearch.dsl.bean.AtomQuery;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 
 public abstract class CheckableMethodQueryParser implements MethodQueryParser {
 
-    abstract void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
+    protected abstract void checkQueryMethod(MethodInvocation invocation) throws ElasticSql2DslException;
 
-    abstract AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
+    protected abstract AtomQuery parseMethodQueryWithCheck(MethodInvocation invocation) throws ElasticSql2DslException;
 
     @Override
-    public AtomQuery parseAtomMethodQuery(SQLMethodInvokeExpr methodExpr, String queryAs, Object[] sqlArgs) throws ElasticSql2DslException {
-        checkQueryMethod(methodExpr, queryAs, sqlArgs);
-        return parseMethodQueryExpr(methodExpr, queryAs, sqlArgs);
+    public AtomQuery parseAtomMethodQuery(MethodInvocation invocation) throws ElasticSql2DslException {
+        checkQueryMethod(invocation);
+        return parseMethodQueryWithCheck(invocation);
     }
 }

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/query/method/MethodInvocation.java

@@ -0,0 +1,27 @@
+package org.elasticsearch.dsl.parser.query.method;
+
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+
+public class MethodInvocation {
+    private SQLMethodInvokeExpr matchQueryExpr;
+    private String queryAs;
+    private Object[] sqlArgs;
+
+    public MethodInvocation(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        this.matchQueryExpr = matchQueryExpr;
+        this.queryAs = queryAs;
+        this.sqlArgs = sqlArgs;
+    }
+
+    public SQLMethodInvokeExpr getMatchQueryExpr() {
+        return matchQueryExpr;
+    }
+
+    public String getQueryAs() {
+        return queryAs;
+    }
+
+    public Object[] getSqlArgs() {
+        return sqlArgs;
+    }
+}

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/query/method/MethodQueryParser.java

@@ -1,12 +1,10 @@
 package org.elasticsearch.dsl.parser.query.method;
 
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import org.elasticsearch.dsl.bean.AtomQuery;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 
 public interface MethodQueryParser {
+    boolean isMatchMethodInvocation(MethodInvocation invocation);
 
-    boolean isMethodOf(SQLMethodInvokeExpr methodExpr);
-
-    AtomQuery parseAtomMethodQuery(SQLMethodInvokeExpr methodExpr, String queryAs, Object[] sqlArgs) throws ElasticSql2DslException;
+    AtomQuery parseAtomMethodQuery(MethodInvocation invocation) throws ElasticSql2DslException;
 }

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/query/method/ParameterizedMethodQueryParser.java

@@ -0,0 +1,57 @@
+package org.elasticsearch.dsl.parser.query.method;
+
+import com.google.common.collect.Maps;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+
+import java.util.Collections;
+import java.util.Map;
+
+public abstract class ParameterizedMethodQueryParser extends CheckableMethodQueryParser {
+
+    private static final String COMMA = ",";
+
+    private static final String COLON = ":";
+
+    protected abstract String getExtraParamString(MethodInvocation invocation);
+
+    protected abstract AtomQuery parseMethodQueryWithExtraParams(
+            MethodInvocation invocation, Map<String, String> extraParamMap) throws ElasticSql2DslException;
+
+    @Override
+    protected AtomQuery parseMethodQueryWithCheck(MethodInvocation invocation) {
+        Map<String, String> extraParamMap = buildExtraParamMap(invocation);
+        return parseMethodQueryWithExtraParams(invocation, extraParamMap);
+    }
+
+    private Map<String, String> buildExtraParamMap(MethodInvocation invocation) {
+        String extraParamString = getExtraParamString(invocation);
+
+        if (StringUtils.isBlank(extraParamString)) {
+            return Collections.emptyMap();
+        }
+
+        Map<String, String> extraParamMap = Maps.newHashMap();
+        for (String paramPair : extraParamString.split(COMMA)) {
+            String[] paramPairArr = paramPair.split(COLON);
+            if (paramPairArr.length == 2) {
+                extraParamMap.put(paramPairArr[0].trim(), paramPairArr[1].trim());
+            }
+            else {
+                throw new ElasticSql2DslException("Failed to parse query method extra param string!");
+            }
+        }
+        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;
+    }
+}

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

@@ -5,6 +5,7 @@ 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;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 
 public class FullTextAtomQueryParser {
 
@@ -14,14 +15,15 @@ public class FullTextAtomQueryParser {
         this.parseActionListener = parseActionListener;
     }
 
-    public static Boolean isFulltextAtomQuery(SQLMethodInvokeExpr methodQueryExpr) {
+    public Boolean isFulltextAtomQuery(SQLMethodInvokeExpr methodQueryExpr) {
         return MatchAtomQueryParser.isMatchQuery(methodQueryExpr) || MultiMatchAtomQueryParser.isMultiMatch(methodQueryExpr) ||
                 QueryStringAtomQueryParser.isQueryStringQuery(methodQueryExpr) || SimpleQueryStringAtomQueryParser.isSimpleQueryStringQuery(methodQueryExpr);
     }
 
     public AtomQuery parseFullTextAtomQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
         AbstractAtomMethodQueryParser matchAtomQueryParser = getQueryParser(methodQueryExpr);
-        return matchAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
+        MethodInvocation methodInvocation = new MethodInvocation(methodQueryExpr, queryAs, sqlArgs);
+        return matchAtomQueryParser.parseAtomMethodQuery(methodInvocation);
     }
 
     private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr methodQueryExpr) {

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

@@ -12,6 +12,7 @@ import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
@@ -32,6 +33,11 @@ public class MatchAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return false;
+    }
+
+    @Override
     protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
         if (Boolean.FALSE == isMatchQuery(methodQueryExpr)) {
             throw new ElasticSql2DslException(String.format("[syntax error] Expected match query method name is [match],but get [%s]", methodQueryExpr.getMethodName()));

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

@@ -12,6 +12,7 @@ import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.MultiMatchQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
@@ -32,6 +33,11 @@ public class MultiMatchAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return false;
+    }
+
+    @Override
     protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
         if (Boolean.FALSE == isMultiMatch(methodQueryExpr)) {
             throw new ElasticSql2DslException(String.format("[syntax error] Expected multiMatch query method name is [multiMatch],but get [%s]", methodQueryExpr.getMethodName()));

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

@@ -12,6 +12,7 @@ import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.QueryStringQueryBuilder;
 
@@ -32,6 +33,11 @@ public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return false;
+    }
+
+    @Override
     protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
         if (Boolean.FALSE == isQueryStringQuery(methodQueryExpr)) {
             throw new ElasticSql2DslException(String.format("[syntax error] Expected queryString query method name is [queryString],but get [%s]", methodQueryExpr.getMethodName()));

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

@@ -12,6 +12,7 @@ import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.SimpleQueryStringBuilder;
 import org.elasticsearch.index.query.SimpleQueryStringFlag;
@@ -33,6 +34,11 @@ public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryPar
     }
 
     @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return false;
+    }
+
+    @Override
     protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
         if (Boolean.FALSE == isSimpleQueryStringQuery(methodQueryExpr)) {
             throw new ElasticSql2DslException(String.format("[syntax error] Expected simpleQueryString query method name is [simpleQueryString],but get [%s]", methodQueryExpr.getMethodName()));

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/query/method/script/ScriptAtomQueryParser.java

@@ -12,6 +12,7 @@ import org.elasticsearch.dsl.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.script.ScriptService;
@@ -27,13 +28,14 @@ public class ScriptAtomQueryParser extends AbstractAtomMethodQueryParser {
         super(parseActionListener);
     }
 
-    public static Boolean isScriptAtomQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return ElasticSqlMethodInvokeHelper.isMethodOf(SCRIPT_METHOD, methodQueryExpr.getMethodName());
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(SCRIPT_METHOD, invocation.getMatchQueryExpr().getMethodName());
     }
 
     @Override
     protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == isScriptAtomQuery(methodQueryExpr)) {
+        if (Boolean.FALSE == isMatchMethodInvocation(new MethodInvocation(methodQueryExpr, queryAs, sqlArgs))) {
             throw new ElasticSql2DslException(String.format("[syntax error] Expected script query method name is [script],but get [%s]", methodQueryExpr.getMethodName()));
         }
 

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

@@ -6,12 +6,12 @@ import com.google.common.collect.ImmutableList;
 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.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
@@ -19,7 +19,7 @@ import org.elasticsearch.index.query.QueryBuilders;
 import java.util.List;
 import java.util.Map;
 
-public class FuzzyAtomQueryParser extends AbstractAtomMethodQueryParser {
+public class FuzzyAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
 
     private static List<String> FUZZY_QUERY_METHOD = ImmutableList.of("fuzzy", "fuzzy_query", "fuzzyQuery");
 
@@ -27,16 +27,22 @@ public class FuzzyAtomQueryParser extends AbstractAtomMethodQueryParser {
         super(parseActionListener);
     }
 
-    public static Boolean isFuzzyQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return ElasticSqlMethodInvokeHelper.isMethodOf(FUZZY_QUERY_METHOD, methodQueryExpr.getMethodName());
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(FUZZY_QUERY_METHOD, invocation.getMatchQueryExpr().getMethodName());
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == isFuzzyQuery(methodQueryExpr)) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected fuzzy query method name is [fuzzy],but get [%s]", methodQueryExpr.getMethodName()));
+    protected void checkQueryMethod(MethodInvocation invocation) {
+
+        if (Boolean.FALSE == isMatchMethodInvocation(invocation)) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] Expected fuzzy query method name is [fuzzy],but get [%s]",
+                            invocation.getMatchQueryExpr().getMethodName()));
         }
 
+        SQLMethodInvokeExpr methodQueryExpr = invocation.getMatchQueryExpr();
+
         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));
@@ -44,41 +50,38 @@ public class FuzzyAtomQueryParser extends AbstractAtomMethodQueryParser {
 
         SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
-        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), 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);
+    protected String getExtraParamString(MethodInvocation invocation) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
+        if (methodInvokeExpr.getParameters().size() == 3) {
+            SQLExpr extraParamExpr = methodInvokeExpr.getParameters().get(2);
+            Object[] sqlArgs = invocation.getSqlArgs();
+            return ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
         }
+        return StringUtils.EMPTY;
+    }
 
-        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+    @Override
+    protected QueryBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
 
-        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());
+        SQLExpr textExpr = methodInvokeExpr.getParameters().get(1);
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false);
 
-                if (parameters.length == 2 && parameters[1] != null) {
-                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
-                    setExtraMatchQueryParam(fuzzyQuery, tExtraParamMap);
-                }
+        FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery(fieldName, text);
+        setExtraMatchQueryParam(fuzzyQuery, extraParams);
+        return fuzzyQuery;
+    }
 
-                return fuzzyQuery;
-            }
-        });
+    @Override
+    protected SQLExpr getFieldExpr(MethodInvocation invocation) {
+        return invocation.getMatchQueryExpr().getParameters().get(0);
     }
 
     private void setExtraMatchQueryParam(FuzzyQueryBuilder fuzzyQuery, Map<String, String> extraParamMap) {

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

@@ -5,12 +5,12 @@ import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.google.common.collect.ImmutableList;
 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.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
@@ -18,7 +18,7 @@ import org.elasticsearch.index.query.QueryBuilders;
 import java.util.List;
 import java.util.Map;
 
-public class PrefixAtomQueryParser extends AbstractAtomMethodQueryParser {
+public class PrefixAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
 
     private static List<String> PREFIX_QUERY_METHOD = ImmutableList.of("prefix", "prefix_query", "prefixQuery");
 
@@ -26,58 +26,61 @@ public class PrefixAtomQueryParser extends AbstractAtomMethodQueryParser {
         super(parseActionListener);
     }
 
-    public static Boolean isPrefixQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return ElasticSqlMethodInvokeHelper.isMethodOf(PREFIX_QUERY_METHOD, methodQueryExpr.getMethodName());
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(PREFIX_QUERY_METHOD, invocation.getMatchQueryExpr().getMethodName());
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == isPrefixQuery(methodQueryExpr)) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected prefix query method name is [prefix],but get [%s]", methodQueryExpr.getMethodName()));
+    protected String getExtraParamString(MethodInvocation invocation) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
+        if (methodInvokeExpr.getParameters().size() == 3) {
+            SQLExpr extraParamExpr = methodInvokeExpr.getParameters().get(2);
+            Object[] sqlArgs = invocation.getSqlArgs();
+            return ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
         }
+        return StringUtils.EMPTY;
+    }
 
-        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));
-        }
+    @Override
+    protected QueryBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
 
-        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+        SQLExpr textExpr = methodInvokeExpr.getParameters().get(1);
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false);
 
-        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
-        if (StringUtils.isEmpty(text)) {
-            throw new ElasticSql2DslException("[syntax error] Prefix text can not be blank!");
-        }
+        PrefixQueryBuilder prefixQuery = QueryBuilders.prefixQuery(fieldName, text.toString());
+
+        setExtraMatchQueryParam(prefixQuery, extraParams);
+        return prefixQuery;
     }
 
     @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();
+    protected SQLExpr getFieldExpr(MethodInvocation invocation) {
+        return invocation.getMatchQueryExpr().getParameters().get(0);
+    }
 
-            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+    @Override
+    protected void checkQueryMethod(MethodInvocation invocation) {
+        if (Boolean.FALSE == isMatchMethodInvocation(invocation)) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] Expected prefix query method name is [prefix],but get [%s]",
+                            invocation.getMatchQueryExpr().getMethodName()));
         }
 
-        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+        SQLMethodInvokeExpr methodQueryExpr = invocation.getMatchQueryExpr();
 
-        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());
+        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));
+        }
 
-                if (parameters.length == 2 && parameters[1] != null) {
-                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
-                    setExtraMatchQueryParam(prefixQuery, tExtraParamMap);
-                }
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
-                return prefixQuery;
-            }
-        });
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Prefix text can not be blank!");
+        }
     }
 
     private void setExtraMatchQueryParam(PrefixQueryBuilder prefixQuery, Map<String, String> extraParamMap) {

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

@@ -6,12 +6,12 @@ import com.google.common.collect.ImmutableList;
 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.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.RegexpFlag;
@@ -20,7 +20,7 @@ import org.elasticsearch.index.query.RegexpQueryBuilder;
 import java.util.List;
 import java.util.Map;
 
-public class RegexpAtomQueryParser extends AbstractAtomMethodQueryParser {
+public class RegexpAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
 
     private static List<String> REGEXP_QUERY_METHOD = ImmutableList.of("regexp", "regexp_query", "regexpQuery");
 
@@ -28,58 +28,60 @@ public class RegexpAtomQueryParser extends AbstractAtomMethodQueryParser {
         super(parseActionListener);
     }
 
-    public static Boolean isRegexpQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return ElasticSqlMethodInvokeHelper.isMethodOf(REGEXP_QUERY_METHOD, methodQueryExpr.getMethodName());
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(REGEXP_QUERY_METHOD, invocation.getMatchQueryExpr().getMethodName());
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == isRegexpQuery(methodQueryExpr)) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected regexp query method name is [regexp],but get [%s]", methodQueryExpr.getMethodName()));
+    protected String getExtraParamString(MethodInvocation invocation) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
+        if (methodInvokeExpr.getParameters().size() == 3) {
+            SQLExpr extraParamExpr = methodInvokeExpr.getParameters().get(2);
+            Object[] sqlArgs = invocation.getSqlArgs();
+            return ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
         }
+        return StringUtils.EMPTY;
+    }
 
-        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));
-        }
+    @Override
+    protected QueryBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
 
-        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+        SQLExpr textExpr = methodInvokeExpr.getParameters().get(1);
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false);
 
-        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
-        if (StringUtils.isEmpty(text)) {
-            throw new ElasticSql2DslException("[syntax error] Regexp text can not be blank!");
-        }
+        RegexpQueryBuilder regexpQuery = QueryBuilders.regexpQuery(fieldName, text.toString());
+        setExtraMatchQueryParam(regexpQuery, extraParams);
+        return regexpQuery;
     }
 
     @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();
+    protected SQLExpr getFieldExpr(MethodInvocation invocation) {
+        return invocation.getMatchQueryExpr().getParameters().get(0);
+    }
 
-            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+    @Override
+    protected void checkQueryMethod(MethodInvocation invocation) throws ElasticSql2DslException {
+        if (Boolean.FALSE == isMatchMethodInvocation(invocation)) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] Expected regexp query method name is [regexp],but get [%s]",
+                            invocation.getMatchQueryExpr().getMethodName()));
         }
 
-        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+        SQLMethodInvokeExpr methodQueryExpr = invocation.getMatchQueryExpr();
 
-        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());
+        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));
+        }
 
-                if (parameters.length == 2 && parameters[1] != null) {
-                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
-                    setExtraMatchQueryParam(regexpQuery, tExtraParamMap);
-                }
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
-                return regexpQuery;
-            }
-        });
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Regexp text can not be blank!");
+        }
     }
 
     private void setExtraMatchQueryParam(RegexpQueryBuilder regexpQuery, Map<String, String> extraParamMap) {

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

@@ -5,12 +5,12 @@ import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.google.common.collect.ImmutableList;
 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.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.TermQueryBuilder;
@@ -18,7 +18,7 @@ import org.elasticsearch.index.query.TermQueryBuilder;
 import java.util.List;
 import java.util.Map;
 
-public class TermAtomQueryParser extends AbstractAtomMethodQueryParser {
+public class TermAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
 
     private static List<String> TERM_QUERY_METHOD = ImmutableList.of("term", "term_query", "termQuery");
 
@@ -26,60 +26,64 @@ public class TermAtomQueryParser extends AbstractAtomMethodQueryParser {
         super(parseActionListener);
     }
 
-    public static Boolean isTermQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return ElasticSqlMethodInvokeHelper.isMethodOf(TERM_QUERY_METHOD, methodQueryExpr.getMethodName());
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(TERM_QUERY_METHOD, invocation.getMatchQueryExpr().getMethodName());
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == isTermQuery(methodQueryExpr)) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected term query method name is [term],but get [%s]", methodQueryExpr.getMethodName()));
+    protected String getExtraParamString(MethodInvocation invocation) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
+        if (methodInvokeExpr.getParameters().size() == 3) {
+            SQLExpr extraParamExpr = methodInvokeExpr.getParameters().get(2);
+            Object[] sqlArgs = invocation.getSqlArgs();
+            return ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
         }
+        return StringUtils.EMPTY;
+    }
 
-        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));
-        }
+    @Override
+    protected QueryBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
 
-        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+        SQLExpr textExpr = methodInvokeExpr.getParameters().get(1);
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false);
 
-        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
-        if (StringUtils.isEmpty(text)) {
-            throw new ElasticSql2DslException("[syntax error] Term text can not be blank!");
-        }
+        TermQueryBuilder termQuery = QueryBuilders.termQuery(fieldName, text);
+        setExtraMatchQueryParam(termQuery, extraParams);
+
+        return termQuery;
     }
 
     @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();
+    protected SQLExpr getFieldExpr(MethodInvocation invocation) {
+        return invocation.getMatchQueryExpr().getParameters().get(0);
+    }
 
-            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+    @Override
+    protected void checkQueryMethod(MethodInvocation invocation) throws ElasticSql2DslException {
+        if (!isMatchMethodInvocation(invocation)) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] Expected term query method name is [term],but get [%s]",
+                            invocation.getMatchQueryExpr().getMethodName()));
         }
 
-        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+        SQLMethodInvokeExpr methodCallExpr = invocation.getMatchQueryExpr();
 
-        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());
+        int paramCount = methodCallExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: term", paramCount));
+        }
 
-                if (parameters.length == 2 && parameters[1] != null) {
-                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
-                    setExtraMatchQueryParam(termQuery, tExtraParamMap);
-                }
+        SQLExpr textExpr = methodCallExpr.getParameters().get(1);
 
-                return termQuery;
-            }
-        });
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Term text can not be blank!");
+        }
     }
 
+
     private void setExtraMatchQueryParam(TermQueryBuilder termQuery, Map<String, String> extraParamMap) {
         if (MapUtils.isEmpty(extraParamMap)) {
             return;

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

@@ -1,49 +1,53 @@
 package org.elasticsearch.dsl.parser.query.method.term;
 
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import com.google.common.collect.ImmutableList;
 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;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
+import org.elasticsearch.dsl.parser.query.method.MethodQueryParser;
+
+import java.util.List;
 
 public class TermLevelAtomQueryParser {
 
-    protected ParseActionListener parseActionListener;
+    private final List<MethodQueryParser> methodQueryParsers;
 
     public TermLevelAtomQueryParser(ParseActionListener parseActionListener) {
-        this.parseActionListener = parseActionListener;
+        methodQueryParsers = ImmutableList.of(
+                new PrefixAtomQueryParser(parseActionListener),
+                new TermAtomQueryParser(parseActionListener),
+                new TermsAtomQueryParser(parseActionListener),
+                new WildcardAtomQueryParser(parseActionListener),
+                new RegexpAtomQueryParser(parseActionListener),
+                new FuzzyAtomQueryParser(parseActionListener)
+        );
     }
 
-    public static Boolean isTermLevelAtomQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return PrefixAtomQueryParser.isPrefixQuery(methodQueryExpr) || TermAtomQueryParser.isTermQuery(methodQueryExpr) ||
-                TermsAtomQueryParser.isTermsQuery(methodQueryExpr) || WildcardAtomQueryParser.isWildcardQuery(methodQueryExpr) ||
-                RegexpAtomQueryParser.isRegexpQuery(methodQueryExpr) || FuzzyAtomQueryParser.isFuzzyQuery(methodQueryExpr);
+    public Boolean isTermLevelAtomQuery(MethodInvocation invocation) {
+        for (MethodQueryParser methodQueryParserItem : methodQueryParsers) {
+            if (methodQueryParserItem.isMatchMethodInvocation(invocation)) {
+                return Boolean.TRUE;
+            }
+        }
+        return Boolean.TRUE;
     }
 
     public AtomQuery parseTermLevelAtomQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        AbstractAtomMethodQueryParser matchAtomQueryParser = getQueryParser(methodQueryExpr);
-        return matchAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
+        MethodInvocation methodInvocation = new MethodInvocation(methodQueryExpr, queryAs, sqlArgs);
+        MethodQueryParser matchAtomQueryParser = getQueryParser(methodInvocation);
+        return matchAtomQueryParser.parseAtomMethodQuery(methodInvocation);
     }
 
-    private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr methodQueryExpr) {
-        if (Boolean.TRUE == PrefixAtomQueryParser.isPrefixQuery(methodQueryExpr)) {
-            return new PrefixAtomQueryParser(parseActionListener);
-        }
-        if (Boolean.TRUE == TermAtomQueryParser.isTermQuery(methodQueryExpr)) {
-            return new TermAtomQueryParser(parseActionListener);
-        }
-        if (Boolean.TRUE == TermsAtomQueryParser.isTermsQuery(methodQueryExpr)) {
-            return new TermsAtomQueryParser(parseActionListener);
-        }
-        if (Boolean.TRUE == WildcardAtomQueryParser.isWildcardQuery(methodQueryExpr)) {
-            return new WildcardAtomQueryParser(parseActionListener);
-        }
-        if (Boolean.TRUE == RegexpAtomQueryParser.isRegexpQuery(methodQueryExpr)) {
-            return new RegexpAtomQueryParser(parseActionListener);
-        }
-        if (Boolean.TRUE == FuzzyAtomQueryParser.isFuzzyQuery(methodQueryExpr)) {
-            return new FuzzyAtomQueryParser(parseActionListener);
+    private MethodQueryParser getQueryParser(MethodInvocation methodInvocation) {
+        for (MethodQueryParser methodQueryParserItem : methodQueryParsers) {
+            if (methodQueryParserItem.isMatchMethodInvocation(methodInvocation)) {
+                return methodQueryParserItem;
+            }
         }
-        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", methodQueryExpr.getMethodName()));
+        throw new ElasticSql2DslException(
+                String.format("[syntax error] Can not support method query expr[%s] condition",
+                        methodInvocation.getMatchQueryExpr().getMethodName()));
     }
 }

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

@@ -6,12 +6,12 @@ import com.google.common.collect.ImmutableList;
 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.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.TermsQueryBuilder;
@@ -19,7 +19,7 @@ import org.elasticsearch.index.query.TermsQueryBuilder;
 import java.util.List;
 import java.util.Map;
 
-public class TermsAtomQueryParser extends AbstractAtomMethodQueryParser {
+public class TermsAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
 
     private static List<String> TERMS_QUERY_METHOD = ImmutableList.of("terms", "terms_query", "termsQuery");
 
@@ -27,17 +27,35 @@ public class TermsAtomQueryParser extends AbstractAtomMethodQueryParser {
         super(parseActionListener);
     }
 
-    public static Boolean isTermsQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return ElasticSqlMethodInvokeHelper.isMethodOf(TERMS_QUERY_METHOD, methodQueryExpr.getMethodName());
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(TERMS_QUERY_METHOD, invocation.getMatchQueryExpr().getMethodName());
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == isTermsQuery(methodQueryExpr)) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected terms query method name is [terms],but get [%s]", methodQueryExpr.getMethodName()));
+    protected String getExtraParamString(MethodInvocation invocation) {
+        int paramCount = invocation.getMatchQueryExpr().getParameters().size();
+        SQLExpr lastParam = invocation.getMatchQueryExpr().getParameters().get(paramCount - 1);
+
+        String extraParamString = ElasticSqlArgTransferHelper.transferSqlArg(lastParam, invocation.getSqlArgs(), false).toString();
+
+        if (isExtraParamsString(extraParamString)) {
+            return extraParamString;
         }
+        return StringUtils.EMPTY;
+    }
 
-        int paramCount = methodQueryExpr.getParameters().size();
+    @Override
+    protected void checkQueryMethod(MethodInvocation invocation) {
+        if (Boolean.FALSE == isMatchMethodInvocation(invocation)) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] Expected terms query method name is [terms],but get [%s]",
+                            invocation.getMatchQueryExpr().getMethodName()));
+        }
+
+        SQLMethodInvokeExpr methodQueryExpr = invocation.getMatchQueryExpr();
+
+        int paramCount = invocation.getMatchQueryExpr().getParameters().size();
         if (paramCount <= 1) {
             throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: term", paramCount));
         }
@@ -45,24 +63,19 @@ public class TermsAtomQueryParser extends AbstractAtomMethodQueryParser {
         for (int idx = 1; idx < paramCount - 1; idx++) {
             SQLExpr textExpr = methodQueryExpr.getParameters().get(idx);
 
-            String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+            String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), 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);
+    protected QueryBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+
+        SQLMethodInvokeExpr methodQueryExpr = invocation.getMatchQueryExpr();
+        Object[] sqlArgs = invocation.getSqlArgs();
+
         int paramCount = methodQueryExpr.getParameters().size();
 
         List<String> termTextList = Lists.newArrayList();
@@ -76,30 +89,18 @@ public class TermsAtomQueryParser extends AbstractAtomMethodQueryParser {
         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 {
+        if (Boolean.FALSE == isExtraParamsString(lastParamText)) {
             termTextList.add(lastParamText);
         }
 
+        TermsQueryBuilder termsQuery = QueryBuilders.termsQuery(fieldName, termTextList);
+        setExtraMatchQueryParam(termsQuery, extraParams);
+        return termsQuery;
+    }
 
-        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;
-            }
-        });
+    @Override
+    protected SQLExpr getFieldExpr(MethodInvocation invocation) {
+        return invocation.getMatchQueryExpr().getParameters().get(0);
     }
 
     private void setExtraMatchQueryParam(TermsQueryBuilder termsQuery, Map<String, String> extraParamMap) {

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

@@ -5,12 +5,12 @@ import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.google.common.collect.ImmutableList;
 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.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.listener.ParseActionListener;
-import org.elasticsearch.dsl.parser.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.elasticsearch.dsl.parser.query.method.MethodInvocation;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.WildcardQueryBuilder;
@@ -18,7 +18,7 @@ import org.elasticsearch.index.query.WildcardQueryBuilder;
 import java.util.List;
 import java.util.Map;
 
-public class WildcardAtomQueryParser extends AbstractAtomMethodQueryParser {
+public class WildcardAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
 
     private static List<String> WILDCARD_QUERY_METHOD = ImmutableList.of("wildcard", "wildcard_query", "wildcardQuery");
 
@@ -26,58 +26,61 @@ public class WildcardAtomQueryParser extends AbstractAtomMethodQueryParser {
         super(parseActionListener);
     }
 
-    public static Boolean isWildcardQuery(SQLMethodInvokeExpr methodQueryExpr) {
-        return ElasticSqlMethodInvokeHelper.isMethodOf(WILDCARD_QUERY_METHOD, methodQueryExpr.getMethodName());
+
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(WILDCARD_QUERY_METHOD, invocation.getMatchQueryExpr().getMethodName());
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == isWildcardQuery(methodQueryExpr)) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected wildcard query method name is [wildcard],but get [%s]", methodQueryExpr.getMethodName()));
+    protected String getExtraParamString(MethodInvocation invocation) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
+        if (methodInvokeExpr.getParameters().size() == 3) {
+            SQLExpr extraParamExpr = methodInvokeExpr.getParameters().get(2);
+            Object[] sqlArgs = invocation.getSqlArgs();
+            return ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
         }
+        return StringUtils.EMPTY;
+    }
 
-        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));
-        }
+    @Override
+    protected QueryBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        SQLMethodInvokeExpr methodInvokeExpr = invocation.getMatchQueryExpr();
 
-        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
+        SQLExpr textExpr = methodInvokeExpr.getParameters().get(1);
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false);
 
-        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
-        if (StringUtils.isEmpty(text)) {
-            throw new ElasticSql2DslException("[syntax error] Wildcard text can not be blank!");
-        }
+        WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery(fieldName, text.toString());
+        setExtraMatchQueryParam(wildcardQuery, extraParams);
+        return wildcardQuery;
     }
 
     @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();
+    protected SQLExpr getFieldExpr(MethodInvocation invocation) {
+        return invocation.getMatchQueryExpr().getParameters().get(0);
+    }
 
-            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
+    @Override
+    protected void checkQueryMethod(MethodInvocation invocation) throws ElasticSql2DslException {
+        if (Boolean.FALSE == isMatchMethodInvocation(invocation)) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] Expected wildcard query method name is [wildcard],but get [%s]",
+                            invocation.getMatchQueryExpr().getMethodName()));
         }
 
-        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+        SQLMethodInvokeExpr methodQueryExpr = invocation.getMatchQueryExpr();
 
-        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());
+        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));
+        }
 
-                if (parameters.length == 2 && parameters[1] != null) {
-                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
-                    setExtraMatchQueryParam(wildcardQuery, tExtraParamMap);
-                }
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
-                return wildcardQuery;
-            }
-        });
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, invocation.getSqlArgs(), false).toString();
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Wildcard text can not be blank!");
+        }
     }
 
     private void setExtraMatchQueryParam(WildcardQueryBuilder wildcardQuery, Map<String, String> extraParamMap) {

elasticsearch-query-core/src/main/java/org/elasticsearch/dsl/parser/sql/AbstractQueryConditionParser.java

@@ -14,9 +14,10 @@ import org.elasticsearch.dsl.listener.ParseActionListener;
 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.MethodInvocation;
 import org.elasticsearch.dsl.parser.query.method.fulltext.FullTextAtomQueryParser;
-import org.elasticsearch.dsl.parser.query.method.term.TermLevelAtomQueryParser;
 import org.elasticsearch.dsl.parser.query.method.script.ScriptAtomQueryParser;
+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;
@@ -25,10 +26,20 @@ import java.util.List;
 
 public abstract class AbstractQueryConditionParser implements QueryParser {
 
-    protected ParseActionListener parseActionListener;
+    private final TermLevelAtomQueryParser termLevelAtomQueryParser;
+    private final ScriptAtomQueryParser scriptAtomQueryParser;
+    private final FullTextAtomQueryParser fullTextAtomQueryParser;
+    private final BinaryAtomQueryParser binaryQueryParser;
+    private final InListAtomQueryParser inListQueryParser;
+    private final BetweenAndAtomQueryParser betweenAndQueryParser;
 
     public AbstractQueryConditionParser(ParseActionListener parseActionListener) {
-        this.parseActionListener = parseActionListener;
+        termLevelAtomQueryParser = new TermLevelAtomQueryParser(parseActionListener);
+        scriptAtomQueryParser = new ScriptAtomQueryParser(parseActionListener);
+        fullTextAtomQueryParser = new FullTextAtomQueryParser(parseActionListener);
+        binaryQueryParser = new BinaryAtomQueryParser(parseActionListener);
+        inListQueryParser = new InListAtomQueryParser(parseActionListener);
+        betweenAndQueryParser = new BetweenAndAtomQueryParser(parseActionListener);
     }
 
     protected BoolQueryBuilder parseQueryConditionExpr(SQLExpr conditionExpr, String queryAs, Object[] sqlArgs) {
@@ -80,31 +91,27 @@ public abstract class AbstractQueryConditionParser implements QueryParser {
         if (sqlConditionExpr instanceof SQLMethodInvokeExpr) {
             SQLMethodInvokeExpr methodQueryExpr = (SQLMethodInvokeExpr) sqlConditionExpr;
 
-            if(ScriptAtomQueryParser.isScriptAtomQuery(methodQueryExpr)) {
-                ScriptAtomQueryParser scriptAtomQueryParser = new ScriptAtomQueryParser(parseActionListener);
-                return scriptAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
+            MethodInvocation methodInvocation = new MethodInvocation(methodQueryExpr, queryAs, sqlArgs);
+
+            if (scriptAtomQueryParser.isMatchMethodInvocation(methodInvocation)) {
+                return scriptAtomQueryParser.parseAtomMethodQuery(methodInvocation);
             }
 
-            if (FullTextAtomQueryParser.isFulltextAtomQuery(methodQueryExpr)) {
-                FullTextAtomQueryParser fullTextAtomQueryParser = new FullTextAtomQueryParser(parseActionListener);
+            if (fullTextAtomQueryParser.isFulltextAtomQuery(methodQueryExpr)) {
                 return fullTextAtomQueryParser.parseFullTextAtomQuery(methodQueryExpr, queryAs, sqlArgs);
             }
 
-            if (TermLevelAtomQueryParser.isTermLevelAtomQuery(methodQueryExpr)) {
-                TermLevelAtomQueryParser termLevelAtomQueryParser = new TermLevelAtomQueryParser(parseActionListener);
+            if (termLevelAtomQueryParser.isTermLevelAtomQuery(methodInvocation)) {
                 return termLevelAtomQueryParser.parseTermLevelAtomQuery(methodQueryExpr, queryAs, sqlArgs);
             }
         }
         else if (sqlConditionExpr instanceof SQLBinaryOpExpr) {
-            BinaryAtomQueryParser binaryQueryParser = new BinaryAtomQueryParser(parseActionListener);
             return binaryQueryParser.parseBinaryQuery((SQLBinaryOpExpr) sqlConditionExpr, queryAs, sqlArgs);
         }
         else if (sqlConditionExpr instanceof SQLInListExpr) {
-            InListAtomQueryParser inListQueryParser = new InListAtomQueryParser(parseActionListener);
             return inListQueryParser.parseInListQuery((SQLInListExpr) sqlConditionExpr, queryAs, sqlArgs);
         }
         else if (sqlConditionExpr instanceof SQLBetweenExpr) {
-            BetweenAndAtomQueryParser betweenAndQueryParser = new BetweenAndAtomQueryParser(parseActionListener);
             return betweenAndQueryParser.parseBetweenAndQuery((SQLBetweenExpr) sqlConditionExpr, queryAs, sqlArgs);
         }
         throw new ElasticSql2DslException(String.format("[syntax error] Can not support query condition type[%s]", sqlConditionExpr.toString()));

elasticsearch-query-core/src/test/java/org/elasticsearch/query/SqlParserWhereConditionTest.java

@@ -15,6 +15,10 @@ import org.junit.Assert;
 import org.junit.Ignore;
 import org.junit.Test;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+
 
 public class SqlParserWhereConditionTest {
     @Test
@@ -257,4 +261,12 @@ public class SqlParserWhereConditionTest {
         f2 = parseResult.getWhereCondition();
         Assert.assertEquals(f1.toString(), f2.toString());
     }
+
+    @Test
+    public void testMatchQuery() throws Exception {
+        String sql = "select * from index query term(name, 'abc', 'boost:2.0f') and term(code, '123')";
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+        System.out.println(parseResult.toDsl());
+    }
 }

elasticsearch-query-core/target/surefire-reports/TEST-org.elasticsearch.query.SqlParserLimitTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="3" failures="0" name="org.elasticsearch.query.SqlParserLimitTest" time="1.457" errors="0" skipped="0">
+<testsuite tests="3" failures="0" name="org.elasticsearch.query.SqlParserLimitTest" time="1.181" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,7 +61,7 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.query.SqlParserLimitTest" name="testParseLimitExprWithArgs" time="1.24"/>
-  <testcase classname="org.elasticsearch.query.SqlParserLimitTest" name="testX" time="0.026"/>
-  <testcase classname="org.elasticsearch.query.SqlParserLimitTest" name="testParseLimitExpr" time="0.013"/>
+  <testcase classname="org.elasticsearch.query.SqlParserLimitTest" name="testParseLimitExprWithArgs" time="1.015"/>
+  <testcase classname="org.elasticsearch.query.SqlParserLimitTest" name="testX" time="0.009"/>
+  <testcase classname="org.elasticsearch.query.SqlParserLimitTest" name="testParseLimitExpr" time="0.002"/>
 </testsuite>

elasticsearch-query-core/target/surefire-reports/TEST-org.elasticsearch.query.SqlParserListenerTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="1" failures="0" name="org.elasticsearch.query.SqlParserListenerTest" time="0.01" errors="0" skipped="0">
+<testsuite tests="1" failures="0" name="org.elasticsearch.query.SqlParserListenerTest" time="0.067" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,5 +61,5 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.query.SqlParserListenerTest" name="testParseActionListener" time="0.009"/>
+  <testcase classname="org.elasticsearch.query.SqlParserListenerTest" name="testParseActionListener" time="0.065"/>
 </testsuite>

elasticsearch-query-core/target/surefire-reports/TEST-org.elasticsearch.query.SqlParserOrderByTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="1" failures="0" name="org.elasticsearch.query.SqlParserOrderByTest" time="0.033" errors="0" skipped="0">
+<testsuite tests="1" failures="0" name="org.elasticsearch.query.SqlParserOrderByTest" time="0.006" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,5 +61,5 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.query.SqlParserOrderByTest" name="testParseEqExpr" time="0.019"/>
+  <testcase classname="org.elasticsearch.query.SqlParserOrderByTest" name="testParseEqExpr" time="0.006"/>
 </testsuite>

elasticsearch-query-core/target/surefire-reports/TEST-org.elasticsearch.query.SqlParserQueryTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="10" failures="0" name="org.elasticsearch.query.SqlParserQueryTest" time="0.127" errors="0" skipped="0">
+<testsuite tests="10" failures="0" name="org.elasticsearch.query.SqlParserQueryTest" time="0.046" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,14 +61,14 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseTermsQueryExpr" time="0.046"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseTermsQueryExpr" time="0.005"/>
   <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseFuzzyQueryExpr" time="0.008"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseWildcardQueryExpr" time="0.003"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseMultiMatchQueryExpr" time="0.008"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseTermQueryExpr" time="0.003"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseSimpleQueryStringQueryExpr" time="0.018"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseQueryStringQueryExpr" time="0.001"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParsePrefixQueryExpr" time="0.004"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseRegexpQueryExpr" time="0.011"/>
-  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseMatchQueryExpr" time="0.022"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseWildcardQueryExpr" time="0.001"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseMultiMatchQueryExpr" time="0.002"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseTermQueryExpr" time="0.001"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseSimpleQueryStringQueryExpr" time="0.009"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseQueryStringQueryExpr" time="0.002"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParsePrefixQueryExpr" time="0.001"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseRegexpQueryExpr" time="0.007"/>
+  <testcase classname="org.elasticsearch.query.SqlParserQueryTest" name="testParseMatchQueryExpr" time="0.004"/>
 </testsuite>

elasticsearch-query-core/target/surefire-reports/TEST-org.elasticsearch.query.SqlParserRoutingTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="2" failures="0" name="org.elasticsearch.query.SqlParserRoutingTest" time="0.01" errors="0" skipped="0">
+<testsuite tests="2" failures="0" name="org.elasticsearch.query.SqlParserRoutingTest" time="0.002" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -62,5 +62,5 @@
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
   <testcase classname="org.elasticsearch.query.SqlParserRoutingTest" name="testParseRoutingExprWithArgs" time="0"/>
-  <testcase classname="org.elasticsearch.query.SqlParserRoutingTest" name="testParseRoutingExpr" time="0.008"/>
+  <testcase classname="org.elasticsearch.query.SqlParserRoutingTest" name="testParseRoutingExpr" time="0.001"/>
 </testsuite>

elasticsearch-query-core/target/surefire-reports/TEST-org.elasticsearch.query.SqlParserSelectFieldTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="6" failures="0" name="org.elasticsearch.query.SqlParserSelectFieldTest" time="0.028" errors="0" skipped="0">
+<testsuite tests="6" failures="0" name="org.elasticsearch.query.SqlParserSelectFieldTest" time="0.024" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,10 +61,10 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testParseDefaultLimit" time="0"/>
-  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testInnerDocField" time="0"/>
+  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testParseDefaultLimit" time="0.013"/>
+  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testInnerDocField" time="0.001"/>
   <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testParseFromSource" time="0"/>
   <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testParseOriSelectField" time="0"/>
-  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testNestedDocField" time="0.025"/>
-  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testSelectAllField" time="0"/>
+  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testNestedDocField" time="0.004"/>
+  <testcase classname="org.elasticsearch.query.SqlParserSelectFieldTest" name="testSelectAllField" time="0.002"/>
 </testsuite>

elasticsearch-query-core/target/surefire-reports/TEST-org.elasticsearch.query.SqlParserWhereConditionTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="7" failures="0" name="org.elasticsearch.query.SqlParserWhereConditionTest" time="0.058" errors="0" skipped="1">
+<testsuite tests="8" failures="0" name="org.elasticsearch.query.SqlParserWhereConditionTest" time="0.056" errors="0" skipped="1">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,13 +61,14 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testParseEqExpr" time="0.001"/>
-  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testParseGtExpr" time="0.02"/>
-  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testParseDateExpr" time="0.002"/>
-  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="test$Expr" time="0.001"/>
+  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testParseEqExpr" time="0.012"/>
+  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testParseGtExpr" time="0.015"/>
+  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testParseDateExpr" time="0.021"/>
+  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="test$Expr" time="0"/>
   <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testCreateSearchDsl" time="0"/>
-  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testNotExpr" time="0.006"/>
-  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testCreateAggDsl" time="0.006">
+  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testMatchQuery" time="0.001"/>
+  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testNotExpr" time="0.004"/>
+  <testcase classname="org.elasticsearch.query.SqlParserWhereConditionTest" name="testCreateAggDsl" time="0.004">
     <skipped/>
   </testcase>
 </testsuite>

elasticsearch-query-core/target/surefire-reports/org.elasticsearch.query.SqlParserLimitTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.query.SqlParserLimitTest
 -------------------------------------------------------------------------------
-Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.459 sec
+Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.182 sec

elasticsearch-query-core/target/surefire-reports/org.elasticsearch.query.SqlParserListenerTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.query.SqlParserListenerTest
 -------------------------------------------------------------------------------
-Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.01 sec
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.067 sec

elasticsearch-query-core/target/surefire-reports/org.elasticsearch.query.SqlParserOrderByTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.query.SqlParserOrderByTest
 -------------------------------------------------------------------------------
-Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.034 sec
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.007 sec

elasticsearch-query-core/target/surefire-reports/org.elasticsearch.query.SqlParserQueryTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.query.SqlParserQueryTest
 -------------------------------------------------------------------------------
-Tests run: 10, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.127 sec
+Tests run: 10, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.047 sec

elasticsearch-query-core/target/surefire-reports/org.elasticsearch.query.SqlParserRoutingTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.query.SqlParserRoutingTest
 -------------------------------------------------------------------------------
-Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.01 sec
+Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.002 sec

elasticsearch-query-core/target/surefire-reports/org.elasticsearch.query.SqlParserSelectFieldTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.query.SqlParserSelectFieldTest
 -------------------------------------------------------------------------------
-Tests run: 6, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.028 sec
+Tests run: 6, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.024 sec

elasticsearch-query-core/target/surefire-reports/org.elasticsearch.query.SqlParserWhereConditionTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.query.SqlParserWhereConditionTest
 -------------------------------------------------------------------------------
-Tests run: 7, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.059 sec
+Tests run: 8, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.056 sec

elasticsearch-query-jdbc/target/surefire-reports/TEST-org.elasticsearch.jdbc.ElasticDriverTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="5" failures="0" name="org.elasticsearch.jdbc.ElasticDriverTest" time="5.131" errors="0" skipped="0">
+<testsuite tests="5" failures="0" name="org.elasticsearch.jdbc.ElasticDriverTest" time="5.601" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,9 +61,9 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testLoadDriver" time="0.157"/>
-  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testQuery" time="4.668"/>
-  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testDataSource" time="0.002"/>
+  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testLoadDriver" time="0.133"/>
+  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testQuery" time="5.243"/>
+  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testDataSource" time="0.004"/>
   <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testGetConnection" time="0"/>
-  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testQuery2" time="0.045"/>
+  <testcase classname="org.elasticsearch.jdbc.ElasticDriverTest" name="testQuery2" time="0.043"/>
 </testsuite>

elasticsearch-query-jdbc/target/surefire-reports/TEST-org.elasticsearch.jdbc.GroupByTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="1" failures="0" name="org.elasticsearch.jdbc.GroupByTest" time="0.07" errors="0" skipped="0">
+<testsuite tests="1" failures="0" name="org.elasticsearch.jdbc.GroupByTest" time="0.05" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,5 +61,5 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.jdbc.GroupByTest" name="testGroupBy" time="0.068"/>
+  <testcase classname="org.elasticsearch.jdbc.GroupByTest" name="testGroupBy" time="0.049"/>
 </testsuite>

elasticsearch-query-jdbc/target/surefire-reports/TEST-org.elasticsearch.jdbc.MethodQueryTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="1" failures="0" name="org.elasticsearch.jdbc.MethodQueryTest" time="0.086" errors="0" skipped="0">
+<testsuite tests="1" failures="0" name="org.elasticsearch.jdbc.MethodQueryTest" time="0.034" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,5 +61,5 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.jdbc.MethodQueryTest" name="testPrefixAndNestedQuery" time="0.085"/>
+  <testcase classname="org.elasticsearch.jdbc.MethodQueryTest" name="testPrefixAndNestedQuery" time="0.033"/>
 </testsuite>

elasticsearch-query-jdbc/target/surefire-reports/TEST-org.elasticsearch.jdbc.ScriptQueryTest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite tests="1" failures="0" name="org.elasticsearch.jdbc.ScriptQueryTest" time="0.038" errors="0" skipped="0">
+<testsuite tests="1" failures="0" name="org.elasticsearch.jdbc.ScriptQueryTest" time="0.032" errors="0" skipped="0">
   <properties>
     <property name="java.runtime.name" value="Java(TM) SE Runtime Environment"/>
     <property name="sun.boot.library.path" value="E:\dev\Java\jdk1.8.0_66\jre\bin"/>
@@ -61,5 +61,5 @@
     <property name="sun.desktop" value="windows"/>
     <property name="sun.cpu.isalist" value="amd64"/>
   </properties>
-  <testcase classname="org.elasticsearch.jdbc.ScriptQueryTest" name="testScriptQuery" time="0.037"/>
+  <testcase classname="org.elasticsearch.jdbc.ScriptQueryTest" name="testScriptQuery" time="0.031"/>
 </testsuite>

elasticsearch-query-jdbc/target/surefire-reports/org.elasticsearch.jdbc.ElasticDriverTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.jdbc.ElasticDriverTest
 -------------------------------------------------------------------------------
-Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 5.132 sec
+Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 5.602 sec

elasticsearch-query-jdbc/target/surefire-reports/org.elasticsearch.jdbc.GroupByTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.jdbc.GroupByTest
 -------------------------------------------------------------------------------
-Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.071 sec
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.053 sec

elasticsearch-query-jdbc/target/surefire-reports/org.elasticsearch.jdbc.MethodQueryTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.jdbc.MethodQueryTest
 -------------------------------------------------------------------------------
-Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.087 sec
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.033 sec

elasticsearch-query-jdbc/target/surefire-reports/org.elasticsearch.jdbc.ScriptQueryTest.txt

@@ -1,4 +1,4 @@
 -------------------------------------------------------------------------------
 Test set: org.elasticsearch.jdbc.ScriptQueryTest
 -------------------------------------------------------------------------------
-Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.039 sec
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.031 sec