Merge branch '2.x'

src/main/java/org/elasticsearch/dsl/parser/listener/ParseActionListener.java

@@ -7,9 +7,9 @@ public interface ParseActionListener {
 
     void onSelectFieldParse(ElasticSqlQueryField field);
 
-    void onExactAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator);
+    void onAtomExactQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator);
 
-    void onMatchAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters);
+    void onAtomMethodQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters);
 
     void onFailure(Throwable t);
 }

src/main/java/org/elasticsearch/dsl/parser/listener/ParseActionListenerAdapter.java

@@ -11,12 +11,12 @@ public class ParseActionListenerAdapter implements ParseActionListener {
     }
 
     @Override
-    public void onExactAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
+    public void onAtomExactQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
 
     }
 
     @Override
-    public void onMatchAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters) {
+    public void onAtomMethodQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters) {
 
     }
 

src/main/java/org/elasticsearch/dsl/parser/syntax/query/exact/AbstractAtomExactQueryParser.java

@@ -44,7 +44,7 @@ public abstract class AbstractAtomExactQueryParser {
 
     private void onExactAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
         try {
-            parseActionListener.onExactAtomQueryConditionParse(paramName, paramValues, operator);
+            parseActionListener.onAtomExactQueryConditionParse(paramName, paramValues, operator);
         }
         catch (Exception ex) {
             try {

src/main/java/org/elasticsearch/dsl/parser/syntax/query/fulltext/AbstractFullTextQueryParser.java

@@ -1,26 +0,0 @@
-package org.elasticsearch.dsl.parser.syntax.query.fulltext;
-
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
-import org.elasticsearch.dsl.bean.AtomQuery;
-import org.elasticsearch.dsl.parser.listener.ParseActionListener;
-
-public abstract class AbstractFullTextQueryParser extends AbstractAtomFullTextQueryParser {
-
-    protected static final String COMMA = ",";
-
-    protected static final String COLON = ":";
-
-    public AbstractFullTextQueryParser(ParseActionListener parseActionListener) {
-        super(parseActionListener);
-    }
-
-    protected abstract void checkMatchQueryMethod(SQLMethodInvokeExpr matchQueryExpr);
-
-    protected abstract AtomQuery parseMatchQueryMethodExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
-
-    public final AtomQuery parseMatchAtomQuery(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        checkMatchQueryMethod(matchQueryExpr);
-
-        return parseMatchQueryMethodExpr(matchQueryExpr, queryAs, sqlArgs);
-    }
-}

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

@@ -1,34 +0,0 @@
-package org.elasticsearch.dsl.parser.syntax.query.fulltext;
-
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
-import org.elasticsearch.dsl.bean.AtomQuery;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.listener.ParseActionListener;
-
-public class FullTextAtomQueryParser extends AbstractAtomFullTextQueryParser {
-
-    public FullTextAtomQueryParser(ParseActionListener parseActionListener) {
-        super(parseActionListener);
-    }
-
-    public AtomQuery parseFullTextAtomQuery(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.TRUE == isMatchQuery(matchQueryExpr)) {
-            MatchAtomQueryParser matchAtomQueryParser = new MatchAtomQueryParser(parseActionListener);
-            return matchAtomQueryParser.parseMatchAtomQuery(matchQueryExpr, queryAs, sqlArgs);
-        }
-        else if (Boolean.TRUE == isMatchPrefixQuery(matchQueryExpr)) {
-            MatchPrefixAtomQueryParser matchPrefixAtomQueryParser = new MatchPrefixAtomQueryParser(parseActionListener);
-            return matchPrefixAtomQueryParser.parseMatchAtomQuery(matchQueryExpr, queryAs, sqlArgs);
-        }
-        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", matchQueryExpr.getMethodName()));
-    }
-
-
-    private Boolean isMatchQuery(SQLMethodInvokeExpr matchQueryExpr) {
-        return "match".equalsIgnoreCase(matchQueryExpr.getMethodName());
-    }
-
-    private Boolean isMatchPrefixQuery(SQLMethodInvokeExpr matchQueryExpr) {
-        return "matchPrefix".equalsIgnoreCase(matchQueryExpr.getMethodName());
-    }
-}

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

@@ -1,76 +0,0 @@
-package org.elasticsearch.dsl.parser.syntax.query.fulltext;
-
-import com.alibaba.druid.sql.ast.SQLExpr;
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
-import com.google.common.collect.Maps;
-import org.apache.commons.collections.MapUtils;
-import org.elasticsearch.dsl.bean.AtomQuery;
-import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
-import org.elasticsearch.dsl.parser.listener.ParseActionListener;
-import org.elasticsearch.index.query.MatchQueryBuilder;
-import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.index.query.QueryBuilders;
-
-import java.util.Map;
-
-public class MatchAtomQueryParser extends AbstractFullTextQueryParser {
-
-    public MatchAtomQueryParser(ParseActionListener parseActionListener) {
-        super(parseActionListener);
-    }
-
-    @Override
-    protected void checkMatchQueryMethod(SQLMethodInvokeExpr matchQueryExpr) {
-
-    }
-
-    @Override
-    protected AtomQuery parseMatchQueryMethodExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        SQLExpr queryField = matchQueryExpr.getParameters().get(0);
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
-
-        Map<String, String> extraParamMap = Maps.newHashMap();
-        if (matchQueryExpr.getParameters().size() == 3) {
-            SQLExpr ExtraParamExpr = matchQueryExpr.getParameters().get(2);
-            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
-
-            for (String paramPair : extraParam.split(COMMA)) {
-                String[] paramPairArr = paramPair.split(COLON);
-                extraParamMap.put(paramPairArr[0], paramPairArr[1]);
-            }
-        }
-
-        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
-
-        return parseCondition(queryField, new Object[]{text}, queryAs, new IConditionFullTextQueryBuilder() {
-            @Override
-            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
-                MatchQueryBuilder matchQuery = QueryBuilders.matchQuery(queryFieldName, parameters[0]);
-                if (MapUtils.isNotEmpty(extraParamMap)) {
-                    setExtraMatchQueryParam(matchQuery, extraParamMap);
-                }
-                return matchQuery;
-            }
-        });
-    }
-
-    private void setExtraMatchQueryParam(MatchQueryBuilder matchQuery, Map<String, String> extraParamMap) {
-        if (extraParamMap.containsKey("operator")) {
-            String val = extraParamMap.get("operator");
-
-            if ("and".equalsIgnoreCase(val)) {
-                matchQuery.operator(MatchQueryBuilder.Operator.AND);
-            }
-
-            if ("or".equalsIgnoreCase(val)) {
-                matchQuery.operator(MatchQueryBuilder.Operator.OR);
-            }
-        }
-
-        if (extraParamMap.containsKey("minimum_should_match")) {
-            String val = extraParamMap.get("minimum_should_match");
-
-            matchQuery.minimumShouldMatch(val);
-        }
-    }
-}

src/main/java/org/elasticsearch/dsl/parser/syntax/query/fulltext/MatchPrefixAtomQueryParser.java

@@ -1,22 +0,0 @@
-package org.elasticsearch.dsl.parser.syntax.query.fulltext;
-
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
-import org.elasticsearch.dsl.bean.AtomQuery;
-import org.elasticsearch.dsl.parser.listener.ParseActionListener;
-
-public class MatchPrefixAtomQueryParser extends AbstractFullTextQueryParser {
-
-    public MatchPrefixAtomQueryParser(ParseActionListener parseActionListener) {
-        super(parseActionListener);
-    }
-
-    @Override
-    protected void checkMatchQueryMethod(SQLMethodInvokeExpr matchQueryExpr) {
-
-    }
-
-    @Override
-    protected AtomQuery parseMatchQueryMethodExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        return null;
-    }
-}

src/main/java/org/elasticsearch/dsl/parser/syntax/query/fulltext/AbstractAtomFullTextQueryParser.java

@@ -1,6 +1,8 @@
-package org.elasticsearch.dsl.parser.syntax.query.fulltext;
+package org.elasticsearch.dsl.parser.syntax.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;
@@ -9,15 +11,32 @@ import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.syntax.sql.QueryFieldParser;
 import org.elasticsearch.index.query.QueryBuilder;
 
-public abstract class AbstractAtomFullTextQueryParser {
+import java.util.Map;
+
+public abstract class AbstractAtomMethodQueryParser {
+
+    protected static final String COMMA = ",";
+
+    protected static final String COLON = ":";
 
     protected ParseActionListener parseActionListener;
 
-    public AbstractAtomFullTextQueryParser(ParseActionListener parseActionListener) {
+    public AbstractAtomMethodQueryParser(ParseActionListener parseActionListener) {
         this.parseActionListener = parseActionListener;
     }
 
-    protected AtomQuery parseCondition(SQLExpr queryFieldExpr, Object[] parameters, String queryAs, IConditionFullTextQueryBuilder queryBuilder) {
+    protected abstract void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
+
+    protected abstract AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
+
+
+    public final AtomQuery parseAtomMethodQuery(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        checkQueryMethod(matchQueryExpr, queryAs, sqlArgs);
+
+        return parseMethodQueryExpr(matchQueryExpr, queryAs, sqlArgs);
+    }
+
+    protected AtomQuery parseCondition(SQLExpr queryFieldExpr, Object[] parameters, String queryAs, IConditionMethodQueryBuilder queryBuilder) {
         QueryFieldParser queryFieldParser = new QueryFieldParser();
         ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(queryFieldExpr, queryAs);
 
@@ -36,23 +55,35 @@ public abstract class AbstractAtomFullTextQueryParser {
             throw new ElasticSql2DslException(String.format("[syntax error] query condition field can not support type[%s]", queryField.getQueryFieldType()));
         }
 
-        onMatchAtomQueryConditionParse(queryField, parameters);
+        onAtomMethodQueryConditionParse(queryField, parameters);
 
         return atomQuery;
     }
 
-    private void onMatchAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters) {
+    private void onAtomMethodQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters) {
         try {
-            parseActionListener.onMatchAtomQueryConditionParse(paramName, parameters);
+            parseActionListener.onAtomMethodQueryConditionParse(paramName, parameters);
         }
         catch (Exception ex) {
             try {
                 parseActionListener.onFailure(ex);
-            }
-            catch (Exception exp) {
+            } catch (Exception exp) {
                 //ignore;
             }
         }
     }
 
+    protected Map<String, String> buildExtraMatchQueryParamsMap(String strMatchQueryParams) {
+        try {
+            Map<String, String> extraParamMap = Maps.newHashMap();
+            for (String paramPair : strMatchQueryParams.split(COMMA)) {
+                String[] paramPairArr = paramPair.split(COLON);
+                extraParamMap.put(paramPairArr[0], paramPairArr[1]);
+            }
+            return extraParamMap;
+        }
+        catch (Exception ex) {
+            throw new ElasticSql2DslException("[fulltext_query] Fulltext match query method param format error!");
+        }
+    }
 }

src/main/java/org/elasticsearch/dsl/parser/syntax/query/fulltext/IConditionFullTextQueryBuilder.java

@@ -1,8 +1,8 @@
-package org.elasticsearch.dsl.parser.syntax.query.fulltext;
+package org.elasticsearch.dsl.parser.syntax.query.method;
 
 import org.elasticsearch.index.query.QueryBuilder;
 
 @FunctionalInterface
-public interface IConditionFullTextQueryBuilder {
+public interface IConditionMethodQueryBuilder {
     QueryBuilder buildQuery(String queryFieldName, Object[] parameters);
 }

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

@@ -0,0 +1,53 @@
+package org.elasticsearch.dsl.parser.syntax.query.method.fulltext;
+
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.query.method.AbstractAtomMethodQueryParser;
+
+public class FullTextAtomQueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public FullTextAtomQueryParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    public AtomQuery parseFullTextAtomQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        AbstractAtomMethodQueryParser matchAtomQueryParser = getQueryParser(methodQueryExpr);
+        return matchAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
+    }
+
+    private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr matchQueryExpr) {
+        if (Boolean.TRUE == isMatchQuery(matchQueryExpr)) {
+            return new MatchAtomQueryParser(parseActionListener);
+        }
+        else if (Boolean.TRUE == isMatchPrefixQuery(matchQueryExpr)) {
+            return new MultiMatchAtomQueryParser(parseActionListener);
+        }
+        else if(Boolean.TRUE == isQueryStringQuery(matchQueryExpr)) {
+            return new QueryStringAtomQueryParser(parseActionListener);
+        }
+        else if(Boolean.TRUE == isSimpleQueryStringQuery(matchQueryExpr)) {
+            return new SimpleQueryStringAtomQueryParser(parseActionListener);
+        }
+        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", matchQueryExpr.getMethodName()));
+    }
+
+    private Boolean isMatchQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "match".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private Boolean isMatchPrefixQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "multiMatch".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private Boolean isQueryStringQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "queryString".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+
+    private Boolean isSimpleQueryStringQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "simpleQueryString".equalsIgnoreCase(methodQueryExpr.getMethodName());
+    }
+}

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

@@ -0,0 +1,183 @@
+package org.elasticsearch.dsl.parser.syntax.query.method.fulltext;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.common.unit.Fuzziness;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.dsl.parser.syntax.query.method.IConditionMethodQueryBuilder;
+import org.elasticsearch.index.query.MatchQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+import java.util.Map;
+
+public class MatchAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public MatchAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "match".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected match query method name is [match],but get [%s]", matchQueryExpr.getMethodName()));
+        }
+
+        int paramCount = matchQueryExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: match", paramCount));
+        }
+
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        if(StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Search text can not be blank!");
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryField = matchQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+
+        Map<String, String> extraParamMap = null;
+        if (matchQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = matchQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+        }
+
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+
+        return parseCondition(queryField, new Object[]{text, extraParamMap}, queryAs, new IConditionMethodQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, Object[] parameters) {
+                MatchQueryBuilder matchQuery = QueryBuilders.matchQuery(queryFieldName, parameters[0]);
+
+                if (parameters.length == 2 && parameters[1] != null) {
+                    Map<String, String> tExtraParamMap = (Map<String, String>) parameters[1];
+                    setExtraMatchQueryParam(matchQuery, tExtraParamMap);
+                }
+
+                return matchQuery;
+            }
+        });
+    }
+
+    private void setExtraMatchQueryParam(MatchQueryBuilder matchQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("type")) {
+            String val = extraParamMap.get("type");
+            if ("BOOLEAN".equalsIgnoreCase(val)) {
+                matchQuery.type(MatchQueryBuilder.Type.BOOLEAN);
+            }
+            if ("PHRASE".equalsIgnoreCase(val)) {
+                matchQuery.type(MatchQueryBuilder.Type.PHRASE);
+            }
+            if ("PHRASE_PREFIX".equalsIgnoreCase(val)) {
+                matchQuery.type(MatchQueryBuilder.Type.PHRASE_PREFIX);
+            }
+        }
+
+        if (extraParamMap.containsKey("operator")) {
+            String val = extraParamMap.get("operator");
+            if ("AND".equalsIgnoreCase(val)) {
+                matchQuery.operator(MatchQueryBuilder.Operator.AND);
+            }
+            if ("OR".equalsIgnoreCase(val)) {
+                matchQuery.operator(MatchQueryBuilder.Operator.OR);
+            }
+        }
+
+        if (extraParamMap.containsKey("minimum_should_match")) {
+            String val = extraParamMap.get("minimum_should_match");
+            matchQuery.minimumShouldMatch(val);
+        }
+
+        if (extraParamMap.containsKey("analyzer")) {
+            String val = extraParamMap.get("analyzer");
+            matchQuery.analyzer(val);
+        }
+
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            matchQuery.boost(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("slop")) {
+            String val = extraParamMap.get("slop");
+            matchQuery.slop(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("prefix_length")) {
+            String val = extraParamMap.get("prefix_length");
+            matchQuery.prefixLength(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("max_expansions")) {
+            String val = extraParamMap.get("max_expansions");
+
+            matchQuery.maxExpansions(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("fuzzy_rewrite")) {
+            String val = extraParamMap.get("fuzzy_rewrite");
+            matchQuery.fuzzyRewrite(val);
+        }
+
+        if (extraParamMap.containsKey("fuzzy_transpositions")) {
+            String val = extraParamMap.get("fuzzy_transpositions");
+            matchQuery.fuzzyTranspositions(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("lenient")) {
+            String val = extraParamMap.get("lenient");
+            matchQuery.setLenient(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("zero_terms_query")) {
+            String val = extraParamMap.get("zero_terms_query");
+            if ("NONE".equalsIgnoreCase(val)) {
+                matchQuery.zeroTermsQuery(MatchQueryBuilder.ZeroTermsQuery.NONE);
+            }
+            if ("ALL".equalsIgnoreCase(val)) {
+                matchQuery.zeroTermsQuery(MatchQueryBuilder.ZeroTermsQuery.ALL);
+            }
+        }
+
+        if (extraParamMap.containsKey("cutoff_Frequency")) {
+            String val = extraParamMap.get("cutoff_Frequency");
+            matchQuery.cutoffFrequency(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("fuzziness")) {
+            String val = extraParamMap.get("fuzziness");
+
+            if ("ZERO".equalsIgnoreCase(val)) {
+                matchQuery.fuzziness(Fuzziness.ZERO);
+            }
+            if ("ONE".equalsIgnoreCase(val)) {
+                matchQuery.fuzziness(Fuzziness.ONE);
+            }
+
+            if ("TWO".equalsIgnoreCase(val)) {
+                matchQuery.fuzziness(Fuzziness.TWO);
+            }
+
+            if ("AUTO".equalsIgnoreCase(val)) {
+                matchQuery.fuzziness(Fuzziness.AUTO);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,179 @@
+package org.elasticsearch.dsl.parser.syntax.query.method.fulltext;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.common.unit.Fuzziness;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.index.query.MatchQueryBuilder;
+import org.elasticsearch.index.query.MultiMatchQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+import java.util.Map;
+
+public class MultiMatchAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public MultiMatchAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "multiMatch".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected multiMatch query method name is [multiMatch],but get [%s]", matchQueryExpr.getMethodName()));
+        }
+
+        int paramCount = matchQueryExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: multiMatch", paramCount));
+        }
+
+        SQLExpr fieldsExpr = matchQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+
+        String strFields = ElasticSqlArgTransferHelper.transferSqlArg(fieldsExpr, sqlArgs, false).toString();
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+
+        if (StringUtils.isEmpty(strFields)) {
+            throw new ElasticSql2DslException("[syntax error] Search fields can not be empty!");
+        }
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Search text can not be blank!");
+        }
+    }
+
+    @Override
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryFields = matchQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+
+        Map<String, String> extraParamMap = null;
+        if (matchQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = matchQueryExpr.getParameters().get(2);
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
+
+            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+        }
+
+        String[] fields = ElasticSqlArgTransferHelper.transferSqlArg(queryFields, sqlArgs, false).toString().split(COMMA);
+        Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);
+
+        MultiMatchQueryBuilder multiMatchQuery = QueryBuilders.multiMatchQuery(text, fields);
+        setExtraMatchQueryParam(multiMatchQuery, extraParamMap);
+
+        return new AtomQuery(multiMatchQuery);
+    }
+
+    private void setExtraMatchQueryParam(MultiMatchQueryBuilder multiMatchQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+        if (extraParamMap.containsKey("type")) {
+            String val = extraParamMap.get("type");
+            if ("BOOLEAN".equalsIgnoreCase(val)) {
+                multiMatchQuery.type(MatchQueryBuilder.Type.BOOLEAN);
+            }
+            if ("PHRASE".equalsIgnoreCase(val)) {
+                multiMatchQuery.type(MatchQueryBuilder.Type.PHRASE);
+            }
+            if ("PHRASE_PREFIX".equalsIgnoreCase(val)) {
+                multiMatchQuery.type(MatchQueryBuilder.Type.PHRASE_PREFIX);
+            }
+        }
+
+        if (extraParamMap.containsKey("operator")) {
+            String val = extraParamMap.get("operator");
+            if ("AND".equalsIgnoreCase(val)) {
+                multiMatchQuery.operator(MatchQueryBuilder.Operator.AND);
+            }
+            if ("OR".equalsIgnoreCase(val)) {
+                multiMatchQuery.operator(MatchQueryBuilder.Operator.OR);
+            }
+        }
+
+        if (extraParamMap.containsKey("minimum_should_match")) {
+            String val = extraParamMap.get("minimum_should_match");
+            multiMatchQuery.minimumShouldMatch(val);
+        }
+
+        if (extraParamMap.containsKey("analyzer")) {
+            String val = extraParamMap.get("analyzer");
+            multiMatchQuery.analyzer(val);
+        }
+
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            multiMatchQuery.boost(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("slop")) {
+            String val = extraParamMap.get("slop");
+            multiMatchQuery.slop(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("prefix_length")) {
+            String val = extraParamMap.get("prefix_length");
+            multiMatchQuery.prefixLength(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("max_expansions")) {
+            String val = extraParamMap.get("max_expansions");
+
+            multiMatchQuery.maxExpansions(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("fuzzy_rewrite")) {
+            String val = extraParamMap.get("fuzzy_rewrite");
+            multiMatchQuery.fuzzyRewrite(val);
+        }
+
+        if (extraParamMap.containsKey("use_dis_max")) {
+            String val = extraParamMap.get("use_dis_max");
+            multiMatchQuery.useDisMax(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("tie_breaker")) {
+            String val = extraParamMap.get("tie_breaker");
+            multiMatchQuery.tieBreaker(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("zero_terms_query")) {
+            String val = extraParamMap.get("zero_terms_query");
+            if ("NONE".equalsIgnoreCase(val)) {
+                multiMatchQuery.zeroTermsQuery(MatchQueryBuilder.ZeroTermsQuery.NONE);
+            }
+            if ("ALL".equalsIgnoreCase(val)) {
+                multiMatchQuery.zeroTermsQuery(MatchQueryBuilder.ZeroTermsQuery.ALL);
+            }
+        }
+
+        if (extraParamMap.containsKey("cutoff_Frequency")) {
+            String val = extraParamMap.get("cutoff_Frequency");
+            multiMatchQuery.cutoffFrequency(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("fuzziness")) {
+            String val = extraParamMap.get("fuzziness");
+
+            if ("ZERO".equalsIgnoreCase(val)) {
+                multiMatchQuery.fuzziness(Fuzziness.ZERO);
+            }
+            if ("ONE".equalsIgnoreCase(val)) {
+                multiMatchQuery.fuzziness(Fuzziness.ONE);
+            }
+
+            if ("TWO".equalsIgnoreCase(val)) {
+                multiMatchQuery.fuzziness(Fuzziness.TWO);
+            }
+
+            if ("AUTO".equalsIgnoreCase(val)) {
+                multiMatchQuery.fuzziness(Fuzziness.AUTO);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,245 @@
+package org.elasticsearch.dsl.parser.syntax.query.method.fulltext;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.common.unit.Fuzziness;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.QueryStringQueryBuilder;
+
+import java.util.Locale;
+import java.util.Map;
+
+public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public QueryStringAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "queryString".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected queryString query method name is [queryString],but get [%s]", matchQueryExpr.getMethodName()));
+        }
+
+        int paramCount = matchQueryExpr.getParameters().size();
+        if (paramCount != 1 && paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: queryString", paramCount));
+        }
+
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Search text can not be blank!");
+        }
+
+        if (paramCount == 3) {
+            SQLExpr fieldsExpr = matchQueryExpr.getParameters().get(1);
+            String strFields = ElasticSqlArgTransferHelper.transferSqlArg(fieldsExpr, sqlArgs, false).toString();
+
+            if (StringUtils.isEmpty(text)) {
+                throw new ElasticSql2DslException("[syntax error] Search fields can not be empty!");
+            }
+            String[] tArr = strFields.split(COLON);
+
+            if (tArr.length != 2) {
+                throw new ElasticSql2DslException("[syntax error] queryString method args error");
+            }
+
+            if (Boolean.FALSE == "fields".equalsIgnoreCase(tArr[0]) && Boolean.FALSE == "default_field".equalsIgnoreCase(tArr[0])) {
+                throw new ElasticSql2DslException("[syntax error] Search fields name should one of [fields, default_field]");
+            }
+        }
+    }
+
+    @Override
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+
+        SQLExpr queryFields = null;
+        SQLExpr extraParamExpr = null;
+
+        if (matchQueryExpr.getParameters().size() == 2) {
+            extraParamExpr = matchQueryExpr.getParameters().get(1);
+        } else if (matchQueryExpr.getParameters().size() == 3) {
+            queryFields = matchQueryExpr.getParameters().get(1);
+            extraParamExpr = matchQueryExpr.getParameters().get(2);
+        }
+
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        QueryStringQueryBuilder queryStringQuery = QueryBuilders.queryStringQuery(text);
+
+        if (queryFields != null) {
+            String[] tArr = ElasticSqlArgTransferHelper.transferSqlArg(queryFields, sqlArgs, false).toString().split(COLON);
+            if ("fields".equalsIgnoreCase(tArr[0])) {
+                for (String fieldItem : tArr[1].split(COMMA)) {
+                    queryStringQuery.field(fieldItem);
+                }
+            }
+
+            if ("default_field".equalsIgnoreCase(tArr[0])) {
+                queryStringQuery.defaultField(tArr[1]);
+            }
+        }
+
+        Map<String, String> extraParamMap = null;
+        if (extraParamExpr != null) {
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
+            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+        }
+
+
+        setExtraMatchQueryParam(queryStringQuery, extraParamMap);
+
+        return new AtomQuery(queryStringQuery);
+    }
+
+    private void setExtraMatchQueryParam(QueryStringQueryBuilder queryStringQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+
+        if (extraParamMap.containsKey("minimum_should_match")) {
+            String val = extraParamMap.get("minimum_should_match");
+            queryStringQuery.minimumShouldMatch(val);
+        }
+
+        if (extraParamMap.containsKey("analyzer")) {
+            String val = extraParamMap.get("analyzer");
+            queryStringQuery.analyzer(val);
+        }
+
+        if (extraParamMap.containsKey("quote_analyzer")) {
+            String val = extraParamMap.get("quote_analyzer");
+            queryStringQuery.quoteAnalyzer(val);
+        }
+
+        if (extraParamMap.containsKey("auto_generate_phrase_queries")) {
+            String val = extraParamMap.get("auto_generate_phrase_queries");
+            queryStringQuery.autoGeneratePhraseQueries(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("max_determinized_states")) {
+            String val = extraParamMap.get("max_determinized_states");
+            queryStringQuery.maxDeterminizedStates(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("allow_leading_wildcard")) {
+            String val = extraParamMap.get("allow_leading_wildcard");
+            queryStringQuery.allowLeadingWildcard(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("lowercase_expanded_terms")) {
+            String val = extraParamMap.get("lowercase_expanded_terms");
+            queryStringQuery.lowercaseExpandedTerms(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("enable_position_increments")) {
+            String val = extraParamMap.get("enable_position_increments");
+            queryStringQuery.enablePositionIncrements(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("fuzzy_prefix_length")) {
+            String val = extraParamMap.get("fuzzy_prefix_length");
+            queryStringQuery.fuzzyPrefixLength(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("fuzzy_max_expansions")) {
+            String val = extraParamMap.get("fuzzy_max_expansions");
+            queryStringQuery.fuzzyMaxExpansions(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            queryStringQuery.boost(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("fuzzy_rewrite")) {
+            String val = extraParamMap.get("fuzzy_rewrite");
+            queryStringQuery.fuzzyRewrite(val);
+        }
+
+        if (extraParamMap.containsKey("rewrite")) {
+            String val = extraParamMap.get("rewrite");
+            queryStringQuery.rewrite(val);
+        }
+
+        if (extraParamMap.containsKey("phrase_slop")) {
+            String val = extraParamMap.get("phrase_slop");
+            queryStringQuery.phraseSlop(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("analyze_wildcard")) {
+            String val = extraParamMap.get("analyze_wildcard");
+            queryStringQuery.analyzeWildcard(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("quote_field_suffix")) {
+            String val = extraParamMap.get("quote_field_suffix");
+            queryStringQuery.quoteFieldSuffix(val);
+        }
+
+        if (extraParamMap.containsKey("use_dis_max")) {
+            String val = extraParamMap.get("use_dis_max");
+            queryStringQuery.useDisMax(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("tie_breaker")) {
+            String val = extraParamMap.get("tie_breaker");
+            queryStringQuery.tieBreaker(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("time_zone")) {
+            String val = extraParamMap.get("time_zone");
+            queryStringQuery.timeZone(val);
+        }
+
+        if (extraParamMap.containsKey("escape")) {
+            String val = extraParamMap.get("escape");
+            queryStringQuery.escape(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("locale")) {
+            String val = extraParamMap.get("locale");
+            queryStringQuery.locale(Locale.forLanguageTag(val));
+        }
+
+        if (extraParamMap.containsKey("default_operator")) {
+            String val = extraParamMap.get("default_operator");
+
+            if ("AND".equalsIgnoreCase(val)) {
+                queryStringQuery.defaultOperator(QueryStringQueryBuilder.Operator.AND);
+            }
+            if ("OR".equalsIgnoreCase(val)) {
+                queryStringQuery.defaultOperator(QueryStringQueryBuilder.Operator.OR);
+            }
+        }
+
+        if (extraParamMap.containsKey("fuzziness")) {
+            String val = extraParamMap.get("fuzziness");
+
+            if ("ZERO".equalsIgnoreCase(val)) {
+                queryStringQuery.fuzziness(Fuzziness.ZERO);
+            }
+            if ("ONE".equalsIgnoreCase(val)) {
+                queryStringQuery.fuzziness(Fuzziness.ONE);
+            }
+
+            if ("TWO".equalsIgnoreCase(val)) {
+                queryStringQuery.fuzziness(Fuzziness.TWO);
+            }
+
+            if ("AUTO".equalsIgnoreCase(val)) {
+                queryStringQuery.fuzziness(Fuzziness.AUTO);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,159 @@
+package org.elasticsearch.dsl.parser.syntax.query.method.fulltext;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import com.google.common.collect.Lists;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.query.method.AbstractAtomMethodQueryParser;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.SimpleQueryStringBuilder;
+import org.elasticsearch.index.query.SimpleQueryStringFlag;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public SimpleQueryStringAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "simpleQueryString".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected simpleQueryString query method name is [simpleQueryString],but get [%s]", matchQueryExpr.getMethodName()));
+        }
+
+        int paramCount = matchQueryExpr.getParameters().size();
+        if (paramCount != 1 && paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: queryString", paramCount));
+        }
+
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Search text can not be blank!");
+        }
+
+        if (paramCount == 3) {
+            SQLExpr fieldsExpr = matchQueryExpr.getParameters().get(1);
+            String strFields = ElasticSqlArgTransferHelper.transferSqlArg(fieldsExpr, sqlArgs, false).toString();
+
+            if (StringUtils.isEmpty(text)) {
+                throw new ElasticSql2DslException("[syntax error] Search fields can not be empty!");
+            }
+            String[] tArr = strFields.split(COLON);
+
+            if (tArr.length != 2) {
+                throw new ElasticSql2DslException("[syntax error] queryString method args error");
+            }
+
+            if (Boolean.FALSE == "fields".equalsIgnoreCase(tArr[0])) {
+                throw new ElasticSql2DslException("[syntax error] Search fields name should one of [fields]");
+            }
+        }
+    }
+
+    @Override
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+
+        SQLExpr queryFields = null;
+        SQLExpr extraParamExpr = null;
+
+        if (matchQueryExpr.getParameters().size() == 2) {
+            extraParamExpr = matchQueryExpr.getParameters().get(1);
+        } else if (matchQueryExpr.getParameters().size() == 3) {
+            queryFields = matchQueryExpr.getParameters().get(1);
+            extraParamExpr = matchQueryExpr.getParameters().get(2);
+        }
+
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        SimpleQueryStringBuilder simpleQueryString = QueryBuilders.simpleQueryStringQuery(text);
+
+        if (queryFields != null) {
+            String[] tArr = ElasticSqlArgTransferHelper.transferSqlArg(queryFields, sqlArgs, false).toString().split(COLON);
+            if ("fields".equalsIgnoreCase(tArr[0])) {
+                for (String fieldItem : tArr[1].split(COMMA)) {
+                    simpleQueryString.field(fieldItem);
+                }
+            }
+        }
+
+        Map<String, String> extraParamMap = null;
+        if (extraParamExpr != null) {
+            String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
+            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+        }
+
+
+        setExtraMatchQueryParam(simpleQueryString, extraParamMap);
+
+        return new AtomQuery(simpleQueryString);
+    }
+
+    private void setExtraMatchQueryParam(SimpleQueryStringBuilder simpleStringQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+
+        if (extraParamMap.containsKey("minimum_should_match")) {
+            String val = extraParamMap.get("minimum_should_match");
+            simpleStringQuery.minimumShouldMatch(val);
+        }
+
+        if (extraParamMap.containsKey("analyzer")) {
+            String val = extraParamMap.get("analyzer");
+            simpleStringQuery.analyzer(val);
+        }
+
+        if (extraParamMap.containsKey("lowercase_expanded_terms")) {
+            String val = extraParamMap.get("lowercase_expanded_terms");
+            simpleStringQuery.lowercaseExpandedTerms(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("boost")) {
+            String val = extraParamMap.get("boost");
+            simpleStringQuery.boost(Float.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("analyze_wildcard")) {
+            String val = extraParamMap.get("analyze_wildcard");
+            simpleStringQuery.analyzeWildcard(Boolean.parseBoolean(val));
+        }
+
+        if (extraParamMap.containsKey("locale")) {
+            String val = extraParamMap.get("locale");
+            simpleStringQuery.locale(Locale.forLanguageTag(val));
+        }
+
+        if (extraParamMap.containsKey("flags")) {
+            String[] flags = extraParamMap.get("flags").split("\\|");
+            List<SimpleQueryStringFlag> flagList = Lists.newLinkedList();
+            for (String flag : flags) {
+                flagList.add(SimpleQueryStringFlag.valueOf(flag.toUpperCase()));
+            }
+            simpleStringQuery.flags(flagList.toArray(new SimpleQueryStringFlag[flagList.size()]));
+        }
+
+
+        if (extraParamMap.containsKey("default_operator")) {
+            String val = extraParamMap.get("default_operator");
+
+            if ("AND".equalsIgnoreCase(val)) {
+                simpleStringQuery.defaultOperator(SimpleQueryStringBuilder.Operator.AND);
+            }
+            if ("OR".equalsIgnoreCase(val)) {
+                simpleStringQuery.defaultOperator(SimpleQueryStringBuilder.Operator.OR);
+            }
+        }
+    }
+}

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

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

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

@@ -14,7 +14,7 @@ import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.syntax.query.exact.BetweenAndAtomQueryParser;
 import org.elasticsearch.dsl.parser.syntax.query.exact.BinaryAtomQueryParser;
 import org.elasticsearch.dsl.parser.syntax.query.exact.InListAtomQueryParser;
-import org.elasticsearch.dsl.parser.syntax.query.fulltext.FullTextAtomQueryParser;
+import org.elasticsearch.dsl.parser.syntax.query.method.fulltext.FullTextAtomQueryParser;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
@@ -57,6 +57,20 @@ public abstract class AbstractQueryConditionParser implements QueryParser {
                 return new SQLCondition(mergedQueryList, operator);
             }
         }
+        else if(conditionExpr instanceof SQLNotExpr) {
+            SQLCondition innerSqlCondition = recursiveParseQueryCondition(((SQLNotExpr) conditionExpr).getExpr(), queryAs, sqlArgs);
+
+            SQLBoolOperator operator = innerSqlCondition.getOperator();
+            if(SQLConditionType.Atom == innerSqlCondition.getSQLConditionType()) {
+                operator = SQLBoolOperator.AND;
+            }
+
+            BoolQueryBuilder boolQuery = mergeAtomQuery(innerSqlCondition.getQueryList(), operator);
+            boolQuery = QueryBuilders.boolQuery().mustNot(boolQuery);
+
+            return new SQLCondition(new AtomQuery(boolQuery), SQLConditionType.Atom);
+        }
+
         return new SQLCondition(parseAtomQueryCondition(conditionExpr, queryAs, sqlArgs), SQLConditionType.Atom);
     }
 

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

@@ -15,7 +15,7 @@ public class SqlParserListenerTest {
         ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
         ElasticSqlParseResult parseResult = sql2DslParser.parse(sql, new ParseActionListenerAdapter() {
             @Override
-            public void onExactAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
+            public void onAtomExactQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
                 if (SQLConditionOperator.Equality == operator) {
                     Assert.assertEquals("status", paramName.getQueryFieldFullName());
                 }

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

@@ -7,10 +7,48 @@ import org.junit.Test;
 
 public class SqlParserQueryTest {
     @Test
-    public void testParseQueryExpr() {
+    public void testParseMatchQueryExpr() {
 
         String sql = "select id,status from index.order t "
-                + "query match(t.productName, '皮鞋', 'minimum_should_match:75%') and match(t.productCode, '2700', 'operator:and')"
+                + "query match(t.productName, '皮鞋', 'minimum_should_match:75%,boost:2.0f') and match(t.productCode, '2700', 'operator:and')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseMultiMatchQueryExpr() {
+
+        String sql = "select id,status from index.order t "
+                + "query multiMatch('productName,productCode', '皮鞋', 'minimum_should_match:75%,boost:2.0f')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseQueryStringQueryExpr() {
+
+        String sql = "select id,status from index.order t "
+                + "query queryString('皮鞋', 'fields:productName,productCode', 'boost:2.0f')"
+                + "where t.price > 1000 limit 5,15";
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+    }
+
+    @Test
+    public void testParseSimpleQueryStringQueryExpr() {
+        String sql = "select id,status from index.order t "
+                + "query simpleQueryString('皮鞋', 'fields:productName,productCode^2', 'flags:OR|AND|PREFIX')"
                 + "where t.price > 1000 limit 5,15";
 
         ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();

src/test/java/org/elasticsearch/SqlParserWhereConditionTest.java

@@ -181,4 +181,78 @@ public class SqlParserWhereConditionTest {
         searchReq.addAggregation(topAgg);
 
     }
+
+    @Test
+    public void testNotExpr() {
+        String sql = "select *  from index.order where not(c = 0)";
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        QueryBuilder f1 = QueryBuilders.boolQuery().must(
+                QueryBuilders.boolQuery().mustNot(
+                        QueryBuilders.boolQuery().must(
+                                QueryBuilders.termQuery("c", 0)
+                        )
+                )
+        );
+        QueryBuilder f2 = parseResult.getWhereCondition();
+        Assert.assertEquals(f1.toString(), f2.toString());
+
+
+        sql = "select *  from index.order where a > 0 and not(c = 0)";
+        sql2DslParser = new ElasticSql2DslParser();
+        parseResult = sql2DslParser.parse(sql);
+
+        f1 = QueryBuilders.boolQuery().must(
+                QueryBuilders.rangeQuery("a").gt(0)).must(
+
+                QueryBuilders.boolQuery().mustNot(
+                        QueryBuilders.boolQuery().must(
+                                QueryBuilders.termQuery("c", 0)
+                        )
+                )
+        );
+        f2 = parseResult.getWhereCondition();
+        Assert.assertEquals(f1.toString(), f2.toString());
+
+
+        sql = "select *  from index.order where a > 0 and not(c = 0 or b = 1)";
+        sql2DslParser = new ElasticSql2DslParser();
+        parseResult = sql2DslParser.parse(sql);
+
+        f1 = QueryBuilders.boolQuery().must(
+                QueryBuilders.rangeQuery("a").gt(0)).must(
+
+                QueryBuilders.boolQuery().mustNot(
+                        QueryBuilders.boolQuery().should(
+                                QueryBuilders.termQuery("c", 0)).should(
+                                QueryBuilders.termQuery("b", 1)
+                        )
+                )
+        );
+        f2 = parseResult.getWhereCondition();
+        Assert.assertEquals(f1.toString(), f2.toString());
+
+
+        sql = "select *  from index.order where a > 0 and not(c = 0 or not(b = 1))";
+        sql2DslParser = new ElasticSql2DslParser();
+        parseResult = sql2DslParser.parse(sql);
+
+        f1 = QueryBuilders.boolQuery().must(
+                QueryBuilders.rangeQuery("a").gt(0)).must(
+
+                QueryBuilders.boolQuery().mustNot(
+                        QueryBuilders.boolQuery().should(
+                                QueryBuilders.termQuery("c", 0)).should(
+                                QueryBuilders.boolQuery().mustNot(
+                                        QueryBuilders.boolQuery().must(
+                                                QueryBuilders.termQuery("b", 1)
+                                        )
+                                )
+                        )
+                )
+        );
+        f2 = parseResult.getWhereCondition();
+        Assert.assertEquals(f1.toString(), f2.toString());
+    }
 }