query support

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

@@ -1,32 +0,0 @@
-package org.elasticsearch.dsl.bean;
-
-import org.elasticsearch.index.query.QueryBuilder;
-
-public class AtomFilter {
-    private QueryBuilder filter;
-    private Boolean isNestedFilter;
-    private String nestedQueryPathContext;
-
-    public AtomFilter(QueryBuilder filter) {
-        this.filter = filter;
-        this.isNestedFilter = Boolean.FALSE;
-    }
-
-    public AtomFilter(QueryBuilder filter, String nestedQueryPathContext) {
-        this.filter = filter;
-        this.isNestedFilter = Boolean.TRUE;
-        this.nestedQueryPathContext = nestedQueryPathContext;
-    }
-
-    public QueryBuilder getFilter() {
-        return filter;
-    }
-
-    public Boolean getNestedFilter() {
-        return isNestedFilter;
-    }
-
-    public String getNestedFilterPathContext() {
-        return nestedQueryPathContext;
-    }
-}

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

@@ -0,0 +1,32 @@
+package org.elasticsearch.dsl.bean;
+
+import org.elasticsearch.index.query.QueryBuilder;
+
+public class AtomQuery {
+    private QueryBuilder query;
+    private Boolean isNestedQuery;
+    private String nestedQueryPathContext;
+
+    public AtomQuery(QueryBuilder query) {
+        this.query = query;
+        this.isNestedQuery = Boolean.FALSE;
+    }
+
+    public AtomQuery(QueryBuilder query, String nestedQueryPathContext) {
+        this.query = query;
+        this.isNestedQuery = Boolean.TRUE;
+        this.nestedQueryPathContext = nestedQueryPathContext;
+    }
+
+    public QueryBuilder getQuery() {
+        return query;
+    }
+
+    public Boolean getNestedQuery() {
+        return isNestedQuery;
+    }
+
+    public String getNestedQueryPathContext() {
+        return nestedQueryPathContext;
+    }
+}

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

@@ -12,20 +12,19 @@ public class SQLCondition {
     //运算符
     private SQLBoolOperator operator;
     //条件集合
-    private List<AtomFilter> filterList;
+    private List<AtomQuery> queryList;
 
-    public SQLCondition(AtomFilter atomFilter) {
-        this.filterList = Lists.newArrayList(atomFilter);
-        this.conditionType = SQLConditionType.Atom;
+    public SQLCondition(AtomQuery atomQuery) {
+        this(atomQuery, SQLConditionType.Atom);
     }
 
-    public SQLCondition(AtomFilter atomFilter, SQLConditionType SQLConditionType) {
-        this.filterList = Lists.newArrayList(atomFilter);
+    public SQLCondition(AtomQuery atomQuery, SQLConditionType SQLConditionType) {
+        this.queryList = Lists.newArrayList(atomQuery);
         this.conditionType = SQLConditionType;
     }
 
-    public SQLCondition(List<AtomFilter> filterList, SQLBoolOperator operator) {
-        this.filterList = filterList;
+    public SQLCondition(List<AtomQuery> queryList, SQLBoolOperator operator) {
+        this.queryList = queryList;
         this.operator = operator;
         this.conditionType = SQLConditionType.Combine;
     }
@@ -39,7 +38,7 @@ public class SQLCondition {
         return operator;
     }
 
-    public List<AtomFilter> getFilterList() {
-        return filterList;
+    public List<AtomQuery> getQueryList() {
+        return queryList;
     }
 }

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

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

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

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

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
@@ -10,7 +10,7 @@ import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.listener.ParseActionListenerAdapter;
-import org.elasticsearch.dsl.parser.syntax.*;
+import org.elasticsearch.dsl.parser.syntax.sql.*;
 import org.elasticsearch.sql.ElasticSqlExprParser;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
 
@@ -78,7 +78,7 @@ public class ElasticSql2DslParser {
                 //解析SQL指定的索引和文档类型
                 new QueryFromParser(parseActionListener),
                 //解析SQL查询指定的match条件
-                new MatchQueryConditionParser(parseActionListener),
+                new QueryMatchConditionParser(parseActionListener),
                 //解析SQL查询指定的where条件
                 new QueryWhereConditionParser(parseActionListener),
                 //解析SQL排序条件

src/main/java/org/elasticsearch/dsl/parser/syntax/MatchQueryConditionParser.java

@@ -1,33 +0,0 @@
-package org.elasticsearch.dsl.parser.syntax;
-
-import org.elasticsearch.dsl.bean.ElasticDslContext;
-import org.elasticsearch.dsl.bean.SQLCondition;
-import org.elasticsearch.dsl.enums.SQLBoolOperator;
-import org.elasticsearch.dsl.enums.SQLConditionType;
-import org.elasticsearch.dsl.parser.listener.ParseActionListener;
-import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
-
-public class MatchQueryConditionParser extends QueryWhereConditionParser {
-
-    public MatchQueryConditionParser(ParseActionListener parseActionListener) {
-        super(parseActionListener);
-    }
-
-    @Override
-    public void parse(ElasticDslContext dslContext) {
-        ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
-
-        if (queryBlock.getMatchQuery() != null) {
-            SQLCondition matchQueryCondition = parseFilterCondition(dslContext, queryBlock.getMatchQuery());
-
-            SQLBoolOperator operator = matchQueryCondition.getOperator();
-            if(SQLConditionType.Atom == matchQueryCondition.getSQLConditionType()) {
-                operator = SQLBoolOperator.AND;
-            }
-
-            BoolQueryBuilder boolQuery = mergeAtomFilter(matchQueryCondition.getFilterList(), operator);
-            dslContext.getParseResult().setMatchCondition(boolQuery);
-        }
-    }
-}

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

@@ -1,304 +0,0 @@
-package org.elasticsearch.dsl.parser.syntax;
-
-import com.alibaba.druid.sql.ast.SQLExpr;
-import com.alibaba.druid.sql.ast.expr.*;
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.ListMultimap;
-import com.google.common.collect.Lists;
-import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.dsl.bean.AtomFilter;
-import org.elasticsearch.dsl.bean.ElasticDslContext;
-import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
-import org.elasticsearch.dsl.bean.SQLCondition;
-import org.elasticsearch.dsl.enums.QueryFieldType;
-import org.elasticsearch.dsl.enums.SQLBoolOperator;
-import org.elasticsearch.dsl.enums.SQLConditionOperator;
-import org.elasticsearch.dsl.enums.SQLConditionType;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.QueryParser;
-import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
-import org.elasticsearch.dsl.parser.listener.ParseActionListener;
-import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.index.query.QueryBuilders;
-import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
-
-import java.util.List;
-
-public class QueryWhereConditionParser implements QueryParser {
-
-    private ParseActionListener parseActionListener;
-
-    public QueryWhereConditionParser(ParseActionListener parseActionListener) {
-        this.parseActionListener = parseActionListener;
-    }
-
-    @Override
-    public void parse(ElasticDslContext dslContext) {
-        ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
-
-        if (queryBlock.getWhere() != null) {
-            SQLCondition whereCondition = parseFilterCondition(dslContext, queryBlock.getWhere());
-
-            SQLBoolOperator operator = whereCondition.getOperator();
-            if(SQLConditionType.Atom == whereCondition.getSQLConditionType()) {
-                operator = SQLBoolOperator.AND;
-            }
-
-            BoolQueryBuilder boolQuery = mergeAtomFilter(whereCondition.getFilterList(), operator);
-            dslContext.getParseResult().setWhereCondition(boolQuery);
-        }
-    }
-
-    protected SQLCondition parseFilterCondition(ElasticDslContext dslContext, SQLExpr sqlExpr) {
-        if (sqlExpr instanceof SQLBinaryOpExpr) {
-            SQLBinaryOpExpr sqlBinOpExpr = (SQLBinaryOpExpr) sqlExpr;
-            SQLBinaryOperator binaryOperator = sqlBinOpExpr.getOperator();
-            if (SQLBinaryOperator.BooleanAnd == binaryOperator || SQLBinaryOperator.BooleanOr == binaryOperator) {
-
-                SQLBoolOperator operator = SQLBinaryOperator.BooleanAnd == binaryOperator ? SQLBoolOperator.AND : SQLBoolOperator.OR;
-
-                SQLCondition leftCondition = parseFilterCondition(dslContext, sqlBinOpExpr.getLeft());
-                SQLCondition rightCondition = parseFilterCondition(dslContext, sqlBinOpExpr.getRight());
-
-                List<AtomFilter> curFilterList = Lists.newArrayList();
-                combineQueryBuilder(curFilterList, leftCondition, operator);
-                combineQueryBuilder(curFilterList, rightCondition, operator);
-
-
-                return new SQLCondition(curFilterList, operator);
-            }
-        }
-        return new SQLCondition(parseAtomFilterCondition(dslContext, sqlExpr), SQLConditionType.Atom);
-    }
-
-    private void combineQueryBuilder(List<AtomFilter> combiner, SQLCondition sqlCondition, SQLBoolOperator binOperator) {
-        if (SQLConditionType.Atom == sqlCondition.getSQLConditionType() || sqlCondition.getOperator() == binOperator) {
-            combiner.addAll(sqlCondition.getFilterList());
-        }
-        else {
-            //todo binOperator -> sqlCondition.getOperator()
-            BoolQueryBuilder boolQuery = mergeAtomFilter(sqlCondition.getFilterList(), sqlCondition.getOperator());
-            combiner.add(new AtomFilter(boolQuery));
-        }
-    }
-
-    protected BoolQueryBuilder mergeAtomFilter(List<AtomFilter> atomFilterList, SQLBoolOperator operator) {
-        BoolQueryBuilder subboolQuery = QueryBuilders.boolQuery();
-        ListMultimap<String, QueryBuilder> listMultiMap = ArrayListMultimap.create();
-
-        for (AtomFilter atomFilter : atomFilterList) {
-            if(Boolean.FALSE == atomFilter.getNestedFilter()) {
-                if (operator == SQLBoolOperator.AND) {
-                    subboolQuery.must(atomFilter.getFilter());
-                }
-                if (operator == SQLBoolOperator.OR) {
-                    subboolQuery.should(atomFilter.getFilter());
-                }
-            }
-            else {
-                String nestedDocPrefix = atomFilter.getNestedFilterPathContext();
-                listMultiMap.put(nestedDocPrefix, atomFilter.getFilter());
-            }
-        }
-
-        for (String nestedDocPrefix : listMultiMap.keySet()) {
-            List<QueryBuilder> nestedQueryList = listMultiMap.get(nestedDocPrefix);
-
-            if(nestedQueryList.size() == 1) {
-                if (operator == SQLBoolOperator.AND) {
-                    subboolQuery.must(QueryBuilders.nestedQuery(nestedDocPrefix, nestedQueryList.get(0)));
-                }
-                if (operator == SQLBoolOperator.OR) {
-                    subboolQuery.should(QueryBuilders.nestedQuery(nestedDocPrefix, nestedQueryList.get(0)));
-                }
-                continue;
-            }
-
-            BoolQueryBuilder boolNestedFilter = QueryBuilders.boolQuery();
-            for (QueryBuilder nestedQueryItem : nestedQueryList) {
-                if (operator == SQLBoolOperator.AND) {
-                    boolNestedFilter.must(nestedQueryItem);
-                }
-                if (operator == SQLBoolOperator.OR) {
-                    boolNestedFilter.should(nestedQueryItem);
-                }
-            }
-
-            if (operator == SQLBoolOperator.AND) {
-                subboolQuery.must(QueryBuilders.nestedQuery(nestedDocPrefix, boolNestedFilter));
-            }
-            if (operator == SQLBoolOperator.OR) {
-                subboolQuery.should(QueryBuilders.nestedQuery(nestedDocPrefix, boolNestedFilter));
-            }
-
-        }
-        return subboolQuery;
-    }
-
-    private AtomFilter parseAtomFilterCondition(ElasticDslContext dslContext, SQLExpr sqlExpr) {
-        if (sqlExpr instanceof SQLBinaryOpExpr) {
-            SQLBinaryOpExpr sqlBinOpExpr = (SQLBinaryOpExpr) sqlExpr;
-            final SQLBinaryOperator binaryOperator = sqlBinOpExpr.getOperator();
-
-            if (isValidBinOperator(binaryOperator)) {
-                //EQ NEQ
-                if (SQLBinaryOperator.Equality == binaryOperator || SQLBinaryOperator.LessThanOrGreater == binaryOperator || SQLBinaryOperator.NotEqual == binaryOperator) {
-                    Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(sqlBinOpExpr.getRight(), dslContext.getSqlArgs());
-
-                    SQLConditionOperator operator = SQLBinaryOperator.Equality == binaryOperator ? SQLConditionOperator.Equality : SQLConditionOperator.NotEqual;
-                    return parseCondition(sqlBinOpExpr.getLeft(), operator, new Object[]{targetVal}, dslContext.getParseResult().getQueryAs(), new ConditionQueryBuilder() {
-                        @Override
-                        public QueryBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                            QueryBuilder eqFilter = QueryBuilders.termQuery(leftIdfName, rightParamValues[0]);
-                            if (SQLConditionOperator.Equality == operator) {
-                                return eqFilter;
-                            } else {
-                                return QueryBuilders.boolQuery().mustNot(eqFilter);
-                            }
-                        }
-                    });
-                }
-
-                //GT GTE LT LTE
-                if (SQLBinaryOperator.GreaterThan == binaryOperator || SQLBinaryOperator.GreaterThanOrEqual == binaryOperator
-                        || SQLBinaryOperator.LessThan == binaryOperator || SQLBinaryOperator.LessThanOrEqual == binaryOperator) {
-
-                    SQLConditionOperator operator = null;
-                    if (SQLBinaryOperator.GreaterThan == binaryOperator) {
-                        operator = SQLConditionOperator.GreaterThan;
-                    } else if (SQLBinaryOperator.GreaterThanOrEqual == binaryOperator) {
-                        operator = SQLConditionOperator.GreaterThanOrEqual;
-                    } else if (SQLBinaryOperator.LessThan == binaryOperator) {
-                        operator = SQLConditionOperator.LessThan;
-                    } else if (SQLBinaryOperator.LessThanOrEqual == binaryOperator) {
-                        operator = SQLConditionOperator.LessThanOrEqual;
-                    }
-
-                    Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(sqlBinOpExpr.getRight(), dslContext.getSqlArgs());
-                    return parseCondition(sqlBinOpExpr.getLeft(), operator, new Object[]{targetVal}, dslContext.getParseResult().getQueryAs(), new ConditionQueryBuilder() {
-                        @Override
-                        public QueryBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                            QueryBuilder rangeQuery = null;
-                            if (SQLConditionOperator.GreaterThan == operator) {
-                                rangeQuery = QueryBuilders.rangeQuery(leftIdfName).gt(rightParamValues[0]);
-                            } else if (SQLConditionOperator.GreaterThanOrEqual == operator) {
-                                rangeQuery = QueryBuilders.rangeQuery(leftIdfName).gte(rightParamValues[0]);
-                            } else if (SQLConditionOperator.LessThan == operator) {
-                                rangeQuery = QueryBuilders.rangeQuery(leftIdfName).lt(rightParamValues[0]);
-                            } else if (SQLConditionOperator.LessThanOrEqual == operator) {
-                                rangeQuery = QueryBuilders.rangeQuery(leftIdfName).lte(rightParamValues[0]);
-                            }
-                            return rangeQuery;
-                        }
-                    });
-                }
-
-                //IS / IS NOT
-                if (SQLBinaryOperator.Is == binaryOperator || SQLBinaryOperator.IsNot == binaryOperator) {
-                    if (!(sqlBinOpExpr.getRight() instanceof SQLNullExpr)) {
-                        throw new ElasticSql2DslException("[syntax error] Is/IsNot expr right part should be null");
-                    }
-                    SQLConditionOperator operator = SQLBinaryOperator.Is == binaryOperator ? SQLConditionOperator.IsNull : SQLConditionOperator.IsNotNull;
-                    return parseCondition(sqlBinOpExpr.getLeft(), operator, null, dslContext.getParseResult().getQueryAs(), new ConditionQueryBuilder() {
-                        @Override
-                        public QueryBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                            QueryBuilder missingFilter = QueryBuilders.missingQuery(leftIdfName);
-                            if (SQLConditionOperator.IsNotNull == operator) {
-                                return QueryBuilders.boolQuery().mustNot(missingFilter);
-                            }
-                            return missingFilter;
-                        }
-                    });
-                }
-            }
-        } else if (sqlExpr instanceof SQLInListExpr) {
-            SQLInListExpr inListExpr = (SQLInListExpr) sqlExpr;
-            if (CollectionUtils.isEmpty(inListExpr.getTargetList())) {
-                throw new ElasticSql2DslException("[syntax error] In list expr target list cannot be blank");
-            }
-            Object[] targetInList = ElasticSqlArgTransferHelper.transferSqlArgs(inListExpr.getTargetList(), dslContext.getSqlArgs());
-            SQLConditionOperator operator = inListExpr.isNot() ? SQLConditionOperator.NotIn : SQLConditionOperator.In;
-            return parseCondition(inListExpr.getExpr(), operator, targetInList, dslContext.getParseResult().getQueryAs(), new ConditionQueryBuilder() {
-                @Override
-                public QueryBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                    if (SQLConditionOperator.NotIn == operator) {
-                        return QueryBuilders.boolQuery().mustNot(QueryBuilders.termsQuery(leftIdfName, rightParamValues));
-                    } else {
-                        return QueryBuilders.termsQuery(leftIdfName, rightParamValues);
-                    }
-                }
-            });
-        } else if (sqlExpr instanceof SQLBetweenExpr) {
-            SQLBetweenExpr betweenExpr = (SQLBetweenExpr) sqlExpr;
-
-            Object from = ElasticSqlArgTransferHelper.transferSqlArg(betweenExpr.getBeginExpr(), dslContext.getSqlArgs());
-            Object to = ElasticSqlArgTransferHelper.transferSqlArg(betweenExpr.getEndExpr(), dslContext.getSqlArgs());
-
-            if (from == null || to == null) {
-                throw new ElasticSql2DslException("[syntax error] Between Expr only support one of [number,date] arg type");
-            }
-
-            return parseCondition(betweenExpr.getTestExpr(), SQLConditionOperator.BetweenAnd, new Object[]{from, to}, dslContext.getParseResult().getQueryAs(), new ConditionQueryBuilder() {
-                @Override
-                public QueryBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                    return QueryBuilders.rangeQuery(leftIdfName).gte(rightParamValues[0]).lte(rightParamValues[1]);
-                }
-            });
-        }
-        throw new ElasticSql2DslException("[syntax error] Can not support syntax type: " + sqlExpr.toString());
-    }
-
-    private AtomFilter parseCondition(SQLExpr leftQueryFieldExpr, SQLConditionOperator operator, Object[] rightParamValues, String queryAs, ConditionQueryBuilder filterBuilder) {
-        QueryFieldParser queryFieldParser = new QueryFieldParser();
-        ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(leftQueryFieldExpr, queryAs);
-
-        AtomFilter atomFilter = null;
-        if (queryField.getQueryFieldType() == QueryFieldType.RootDocField || queryField.getQueryFieldType() == QueryFieldType.InnerDocField) {
-            QueryBuilder originalFilter = filterBuilder.buildFilter(queryField.getQueryFieldFullName(), operator, rightParamValues);
-            atomFilter = new AtomFilter(originalFilter);
-        }
-
-        if (queryField.getQueryFieldType() == QueryFieldType.NestedDocField) {
-            QueryBuilder originalFilter = filterBuilder.buildFilter(queryField.getQueryFieldFullName(), operator, rightParamValues);
-            atomFilter = new AtomFilter(originalFilter, queryField.getNestedDocContextPath());
-        }
-
-        if (atomFilter == null) {
-            throw new ElasticSql2DslException(String.format("[syntax error] where condition field can not support type[%s]", queryField.getQueryFieldType()));
-        }
-
-        onAtomConditionParse(queryField, rightParamValues, operator);
-
-        return atomFilter;
-    }
-
-    private void onAtomConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
-        try {
-            parseActionListener.onAtomConditionParse(paramName, paramValues, operator);
-        } catch (Exception ex) {
-            try {
-                parseActionListener.onFailure(ex);
-            } catch (Exception exp) {
-                //ignore;
-            }
-        }
-    }
-
-    @FunctionalInterface
-    private interface ConditionQueryBuilder {
-        QueryBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues);
-    }
-
-    public boolean isValidBinOperator(SQLBinaryOperator binaryOperator) {
-        return binaryOperator == SQLBinaryOperator.Equality
-                || binaryOperator == SQLBinaryOperator.NotEqual
-                || binaryOperator == SQLBinaryOperator.LessThanOrGreater
-                || binaryOperator == SQLBinaryOperator.GreaterThan
-                || binaryOperator == SQLBinaryOperator.GreaterThanOrEqual
-                || binaryOperator == SQLBinaryOperator.LessThan
-                || binaryOperator == SQLBinaryOperator.LessThanOrEqual
-                || binaryOperator == SQLBinaryOperator.Is
-                || binaryOperator == SQLBinaryOperator.IsNot;
-    }
-}

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

@@ -0,0 +1,59 @@
+package org.elasticsearch.dsl.parser.syntax.query.exact;
+
+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.enums.SQLConditionOperator;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.sql.QueryFieldParser;
+import org.elasticsearch.index.query.QueryBuilder;
+
+public abstract class AbstractAtomExactQueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public AbstractAtomExactQueryParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    protected AtomQuery parseCondition(SQLExpr queryFieldExpr, SQLConditionOperator operator, Object[] rightParamValues, String queryAs, IConditionExactQueryBuilder 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(), operator, rightParamValues);
+            atomQuery = new AtomQuery(originalQuery);
+        }
+
+        if (queryField.getQueryFieldType() == QueryFieldType.NestedDocField) {
+            QueryBuilder originalQuery = queryBuilder.buildQuery(queryField.getQueryFieldFullName(), operator, rightParamValues);
+            atomQuery = new AtomQuery(originalQuery, queryField.getNestedDocContextPath());
+        }
+
+        if (atomQuery == null) {
+            throw new ElasticSql2DslException(String.format("[syntax error] where condition field can not support type[%s]", queryField.getQueryFieldType()));
+        }
+
+        onExactAtomQueryConditionParse(queryField, rightParamValues, operator);
+
+        return atomQuery;
+    }
+
+    private void onExactAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
+        try {
+            parseActionListener.onExactAtomQueryConditionParse(paramName, paramValues, operator);
+        }
+        catch (Exception ex) {
+            try {
+                parseActionListener.onFailure(ex);
+            }
+            catch (Exception exp) {
+                //ignore;
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,33 @@
+package org.elasticsearch.dsl.parser.syntax.query.exact;
+
+import com.alibaba.druid.sql.ast.expr.SQLBetweenExpr;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.enums.SQLConditionOperator;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+public class BetweenAndAtomQueryParser extends AbstractAtomExactQueryParser {
+
+    public BetweenAndAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    public AtomQuery parseBetweenAndQuery(SQLBetweenExpr betweenAndExpr, String queryAs, Object[] sqlArgs) {
+        Object from = ElasticSqlArgTransferHelper.transferSqlArg(betweenAndExpr.getBeginExpr(), sqlArgs);
+        Object to = ElasticSqlArgTransferHelper.transferSqlArg(betweenAndExpr.getEndExpr(), sqlArgs);
+
+        if (from == null || to == null) {
+            throw new ElasticSql2DslException("[syntax error] Between Expr only support one of [number,date] arg type");
+        }
+
+        return parseCondition(betweenAndExpr.getTestExpr(), SQLConditionOperator.BetweenAnd, new Object[]{from, to}, queryAs, new IConditionExactQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                return QueryBuilders.rangeQuery(queryFieldName).gte(rightParamValues[0]).lte(rightParamValues[1]);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,104 @@
+package org.elasticsearch.dsl.parser.syntax.query.exact;
+
+import com.alibaba.druid.sql.ast.expr.SQLBinaryOpExpr;
+import com.alibaba.druid.sql.ast.expr.SQLBinaryOperator;
+import com.alibaba.druid.sql.ast.expr.SQLNullExpr;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.enums.SQLConditionOperator;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+public class BinaryAtomQueryParser extends AbstractAtomExactQueryParser {
+
+    public BinaryAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    public AtomQuery parseBinaryQuery(SQLBinaryOpExpr binQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLBinaryOperator binaryOperator = binQueryExpr.getOperator();
+
+        //EQ NEQ
+        if (SQLBinaryOperator.Equality == binaryOperator || SQLBinaryOperator.LessThanOrGreater == binaryOperator || SQLBinaryOperator.NotEqual == binaryOperator) {
+            Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(binQueryExpr.getRight(), sqlArgs);
+
+            SQLConditionOperator operator = SQLBinaryOperator.Equality == binaryOperator ? SQLConditionOperator.Equality : SQLConditionOperator.NotEqual;
+
+            return parseCondition(binQueryExpr.getLeft(), operator, new Object[]{targetVal}, queryAs, new IConditionExactQueryBuilder() {
+                @Override
+                public QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                    QueryBuilder eqQuery = QueryBuilders.termQuery(queryFieldName, rightParamValues[0]);
+                    if (SQLConditionOperator.Equality == operator) {
+                        return eqQuery;
+                    }
+                    else {
+                        return QueryBuilders.boolQuery().mustNot(eqQuery);
+                    }
+                }
+            });
+        }
+
+        //GT GTE LT LTE
+        if (SQLBinaryOperator.GreaterThan == binaryOperator || SQLBinaryOperator.GreaterThanOrEqual == binaryOperator
+                || SQLBinaryOperator.LessThan == binaryOperator || SQLBinaryOperator.LessThanOrEqual == binaryOperator) {
+
+            SQLConditionOperator operator = null;
+            if (SQLBinaryOperator.GreaterThan == binaryOperator) {
+                operator = SQLConditionOperator.GreaterThan;
+            }
+            else if (SQLBinaryOperator.GreaterThanOrEqual == binaryOperator) {
+                operator = SQLConditionOperator.GreaterThanOrEqual;
+            }
+            else if (SQLBinaryOperator.LessThan == binaryOperator) {
+                operator = SQLConditionOperator.LessThan;
+            }
+            else if (SQLBinaryOperator.LessThanOrEqual == binaryOperator) {
+                operator = SQLConditionOperator.LessThanOrEqual;
+            }
+
+            Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(binQueryExpr.getRight(), sqlArgs);
+            return parseCondition(binQueryExpr.getLeft(), operator, new Object[]{targetVal}, queryAs, new IConditionExactQueryBuilder() {
+                @Override
+                public QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                    QueryBuilder rangeQuery = null;
+                    if (SQLConditionOperator.GreaterThan == operator) {
+                        rangeQuery = QueryBuilders.rangeQuery(queryFieldName).gt(rightParamValues[0]);
+                    }
+                    else if (SQLConditionOperator.GreaterThanOrEqual == operator) {
+                        rangeQuery = QueryBuilders.rangeQuery(queryFieldName).gte(rightParamValues[0]);
+                    }
+                    else if (SQLConditionOperator.LessThan == operator) {
+                        rangeQuery = QueryBuilders.rangeQuery(queryFieldName).lt(rightParamValues[0]);
+                    }
+                    else if (SQLConditionOperator.LessThanOrEqual == operator) {
+                        rangeQuery = QueryBuilders.rangeQuery(queryFieldName).lte(rightParamValues[0]);
+                    }
+                    return rangeQuery;
+                }
+            });
+        }
+
+        //IS / IS NOT
+        if (SQLBinaryOperator.Is == binaryOperator || SQLBinaryOperator.IsNot == binaryOperator) {
+            if (!(binQueryExpr.getRight() instanceof SQLNullExpr)) {
+                throw new ElasticSql2DslException("[syntax error] Is/IsNot expr right part should be null");
+            }
+            SQLConditionOperator operator = SQLBinaryOperator.Is == binaryOperator ? SQLConditionOperator.IsNull : SQLConditionOperator.IsNotNull;
+            return parseCondition(binQueryExpr.getLeft(), operator, null, queryAs, new IConditionExactQueryBuilder() {
+                @Override
+                public QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                    ExistsQueryBuilder existsQuery = QueryBuilders.existsQuery(queryFieldName);
+                    if (SQLConditionOperator.IsNull == operator) {
+                        return QueryBuilders.boolQuery().mustNot(existsQuery);
+                    }
+                    return existsQuery;
+                }
+            });
+        }
+
+        throw new ElasticSql2DslException(String.format("[syntax error] Can not support binary query type[%s]", binQueryExpr.toString()));
+    }
+}

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

@@ -0,0 +1,9 @@
+package org.elasticsearch.dsl.parser.syntax.query.exact;
+
+import org.elasticsearch.dsl.enums.SQLConditionOperator;
+import org.elasticsearch.index.query.QueryBuilder;
+
+@FunctionalInterface
+public interface IConditionExactQueryBuilder {
+    QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues);
+}

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

@@ -0,0 +1,37 @@
+package org.elasticsearch.dsl.parser.syntax.query.exact;
+
+import com.alibaba.druid.sql.ast.expr.SQLInListExpr;
+import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.enums.SQLConditionOperator;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+public class InListAtomQueryParser extends AbstractAtomExactQueryParser {
+
+    public InListAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    public AtomQuery parseInListQuery(SQLInListExpr inListQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (CollectionUtils.isEmpty(inListQueryExpr.getTargetList())) {
+            throw new ElasticSql2DslException("[syntax error] In list expr target list cannot be blank");
+        }
+        Object[] targetInList = ElasticSqlArgTransferHelper.transferSqlArgs(inListQueryExpr.getTargetList(), sqlArgs);
+        SQLConditionOperator operator = inListQueryExpr.isNot() ? SQLConditionOperator.NotIn : SQLConditionOperator.In;
+        return parseCondition(inListQueryExpr.getExpr(), operator, targetInList, queryAs, new IConditionExactQueryBuilder() {
+            @Override
+            public QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                if (SQLConditionOperator.NotIn == operator) {
+                    return QueryBuilders.boolQuery().mustNot(QueryBuilders.termsQuery(queryFieldName, rightParamValues));
+                }
+                else {
+                    return QueryBuilders.termsQuery(queryFieldName, rightParamValues);
+                }
+            }
+        });
+    }
+}

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

@@ -0,0 +1,58 @@
+package org.elasticsearch.dsl.parser.syntax.query.fulltext;
+
+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.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.sql.QueryFieldParser;
+import org.elasticsearch.index.query.QueryBuilder;
+
+public abstract class AbstractAtomFullTextQueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public AbstractAtomFullTextQueryParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    protected AtomQuery parseCondition(SQLExpr queryFieldExpr, Object[] parameters, String queryAs, IConditionFullTextQueryBuilder 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()));
+        }
+
+        onMatchAtomQueryConditionParse(queryField, parameters);
+
+        return atomQuery;
+    }
+
+    private void onMatchAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] parameters) {
+        try {
+            parseActionListener.onMatchAtomQueryConditionParse(paramName, parameters);
+        }
+        catch (Exception ex) {
+            try {
+                parseActionListener.onFailure(ex);
+            }
+            catch (Exception exp) {
+                //ignore;
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,34 @@
+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/IConditionFullTextQueryBuilder.java

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

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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,22 @@
+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/sql/AbstractQueryConditionParser.java

@@ -0,0 +1,147 @@
+package org.elasticsearch.dsl.parser.syntax.sql;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.*;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Lists;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.bean.SQLCondition;
+import org.elasticsearch.dsl.enums.SQLBoolOperator;
+import org.elasticsearch.dsl.enums.SQLConditionType;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+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.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+
+import java.util.List;
+
+public abstract class AbstractQueryConditionParser implements QueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public AbstractQueryConditionParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    protected BoolQueryBuilder parseQueryConditionExpr(SQLExpr conditionExpr, String queryAs, Object[] sqlArgs) {
+        SQLCondition sqlCondition = recursiveParseQueryCondition(conditionExpr, queryAs, sqlArgs);
+        SQLBoolOperator operator = sqlCondition.getOperator();
+
+        if (SQLConditionType.Atom == sqlCondition.getSQLConditionType()) {
+            operator = SQLBoolOperator.AND;
+        }
+        return mergeAtomQuery(sqlCondition.getQueryList(), operator);
+    }
+
+    private SQLCondition recursiveParseQueryCondition(SQLExpr conditionExpr, String queryAs, Object[] sqlArgs) {
+        if (conditionExpr instanceof SQLBinaryOpExpr) {
+            SQLBinaryOpExpr binOpExpr = (SQLBinaryOpExpr) conditionExpr;
+            SQLBinaryOperator binOperator = binOpExpr.getOperator();
+
+            if (SQLBinaryOperator.BooleanAnd == binOperator || SQLBinaryOperator.BooleanOr == binOperator) {
+                SQLBoolOperator operator = SQLBinaryOperator.BooleanAnd == binOperator ? SQLBoolOperator.AND : SQLBoolOperator.OR;
+
+                SQLCondition leftCondition = recursiveParseQueryCondition(binOpExpr.getLeft(), queryAs, sqlArgs);
+                SQLCondition rightCondition = recursiveParseQueryCondition(binOpExpr.getRight(), queryAs, sqlArgs);
+
+                List<AtomQuery> mergedQueryList = Lists.newArrayList();
+                combineQueryBuilder(mergedQueryList, leftCondition, operator);
+                combineQueryBuilder(mergedQueryList, rightCondition, operator);
+
+                return new SQLCondition(mergedQueryList, operator);
+            }
+        }
+        return new SQLCondition(parseAtomQueryCondition(conditionExpr, queryAs, sqlArgs), SQLConditionType.Atom);
+    }
+
+    private AtomQuery parseAtomQueryCondition(SQLExpr sqlConditionExpr, String queryAs, Object[] sqlArgs) {
+        if (sqlConditionExpr instanceof SQLMethodInvokeExpr) {
+            FullTextAtomQueryParser fullTextAtomQueryParser = new FullTextAtomQueryParser(parseActionListener);
+            return fullTextAtomQueryParser.parseFullTextAtomQuery((SQLMethodInvokeExpr) sqlConditionExpr, queryAs, sqlArgs);
+        }
+        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()));
+    }
+
+    private void combineQueryBuilder(List<AtomQuery> combiner, SQLCondition sqlCondition, SQLBoolOperator binOperator) {
+        if (SQLConditionType.Atom == sqlCondition.getSQLConditionType() || sqlCondition.getOperator() == binOperator) {
+            combiner.addAll(sqlCondition.getQueryList());
+        }
+        else {
+            BoolQueryBuilder boolQuery = mergeAtomQuery(sqlCondition.getQueryList(), sqlCondition.getOperator());
+            combiner.add(new AtomQuery(boolQuery));
+        }
+    }
+
+    private BoolQueryBuilder mergeAtomQuery(List<AtomQuery> atomQueryList, SQLBoolOperator operator) {
+        BoolQueryBuilder subBoolQuery = QueryBuilders.boolQuery();
+        ListMultimap<String, QueryBuilder> listMultiMap = ArrayListMultimap.create();
+
+        for (AtomQuery atomQuery : atomQueryList) {
+            if (Boolean.FALSE == atomQuery.getNestedQuery()) {
+                if (operator == SQLBoolOperator.AND) {
+                    subBoolQuery.must(atomQuery.getQuery());
+                }
+                if (operator == SQLBoolOperator.OR) {
+                    subBoolQuery.should(atomQuery.getQuery());
+                }
+            }
+            else {
+                String nestedDocPrefix = atomQuery.getNestedQueryPathContext();
+                listMultiMap.put(nestedDocPrefix, atomQuery.getQuery());
+            }
+        }
+
+        for (String nestedDocPrefix : listMultiMap.keySet()) {
+            List<QueryBuilder> nestedQueryList = listMultiMap.get(nestedDocPrefix);
+
+            if (nestedQueryList.size() == 1) {
+                if (operator == SQLBoolOperator.AND) {
+                    subBoolQuery.must(QueryBuilders.nestedQuery(nestedDocPrefix, nestedQueryList.get(0)));
+                }
+                if (operator == SQLBoolOperator.OR) {
+                    subBoolQuery.should(QueryBuilders.nestedQuery(nestedDocPrefix, nestedQueryList.get(0)));
+                }
+                continue;
+            }
+
+            BoolQueryBuilder boolNestedQuery = QueryBuilders.boolQuery();
+            for (QueryBuilder nestedQueryItem : nestedQueryList) {
+                if (operator == SQLBoolOperator.AND) {
+                    boolNestedQuery.must(nestedQueryItem);
+                }
+                if (operator == SQLBoolOperator.OR) {
+                    boolNestedQuery.should(nestedQueryItem);
+                }
+            }
+
+            if (operator == SQLBoolOperator.AND) {
+                subBoolQuery.must(QueryBuilders.nestedQuery(nestedDocPrefix, boolNestedQuery));
+            }
+            if (operator == SQLBoolOperator.OR) {
+                subBoolQuery.should(QueryBuilders.nestedQuery(nestedDocPrefix, boolNestedQuery));
+            }
+
+        }
+        return subBoolQuery;
+    }
+
+
+}

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLAllColumnExpr;

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

@@ -1,11 +1,10 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
 import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
 import com.alibaba.druid.sql.ast.statement.SQLExprTableSource;
 import com.google.common.collect.Lists;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
-import org.elasticsearch.dsl.parser.QueryParser;
 import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
@@ -10,7 +10,6 @@ import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.bean.RangeSegment;
 import org.elasticsearch.dsl.enums.QueryFieldType;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.QueryParser;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.parser.listener.ParseActionListener;

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

@@ -1,11 +1,10 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
-import org.elasticsearch.dsl.parser.QueryParser;
 import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;

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

@@ -0,0 +1,26 @@
+package org.elasticsearch.dsl.parser.syntax.sql;
+
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
+
+public class QueryMatchConditionParser extends AbstractQueryConditionParser {
+
+    public QueryMatchConditionParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    public void parse(ElasticDslContext dslContext) {
+        ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
+
+        if (queryBlock.getMatchQuery() != null) {
+            String queryAs = dslContext.getParseResult().getQueryAs();
+
+            BoolQueryBuilder matchQuery = parseQueryConditionExpr(queryBlock.getMatchQuery(), queryAs, dslContext.getSqlArgs());
+
+            dslContext.getParseResult().setMatchCondition(matchQuery);
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLOrderBy;
@@ -15,7 +15,6 @@ import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.enums.QueryFieldType;
 import org.elasticsearch.dsl.enums.SortOption;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.QueryParser;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.parser.listener.ParseActionListener;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
@@ -7,7 +7,6 @@ import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
 import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
-import org.elasticsearch.dsl.parser.QueryParser;
 import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.elasticsearch.dsl.parser.syntax.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr;
@@ -9,7 +9,6 @@ import org.elasticsearch.dsl.bean.ElasticDslContext;
 import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.enums.QueryFieldType;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.QueryParser;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlMethodInvokeHelper;
 import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;

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

@@ -0,0 +1,26 @@
+package org.elasticsearch.dsl.parser.syntax.sql;
+
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
+
+public class QueryWhereConditionParser extends AbstractQueryConditionParser {
+
+    public QueryWhereConditionParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    public void parse(ElasticDslContext dslContext) {
+        ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
+
+        if (queryBlock.getWhere() != null) {
+            String queryAs = dslContext.getParseResult().getQueryAs();
+
+            BoolQueryBuilder whereQuery = parseQueryConditionExpr(queryBlock.getWhere(), queryAs, dslContext.getSqlArgs());
+
+            dslContext.getParseResult().setWhereCondition(whereQuery);
+        }
+    }
+}

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

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

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

@@ -3,7 +3,7 @@ package org.elasticsearch;
 import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
 import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
 import org.elasticsearch.dsl.enums.SQLConditionOperator;
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.elasticsearch.dsl.parser.syntax.ElasticSql2DslParser;
 import org.elasticsearch.dsl.parser.listener.ParseActionListenerAdapter;
 import org.junit.Assert;
 import org.junit.Test;
@@ -15,7 +15,7 @@ public class SqlParserListenerTest {
         ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
         ElasticSqlParseResult parseResult = sql2DslParser.parse(sql, new ParseActionListenerAdapter() {
             @Override
-            public void onAtomConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
+            public void onExactAtomQueryConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
                 if (SQLConditionOperator.Equality == operator) {
                     Assert.assertEquals("status", paramName.getQueryFieldFullName());
                 }

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

@@ -1,14 +1,7 @@
 package org.elasticsearch;
 
-import org.elasticsearch.action.search.SearchRequestBuilder;
-import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
-import org.elasticsearch.search.sort.SortBuilder;
-import org.elasticsearch.search.sort.SortBuilders;
-import org.elasticsearch.search.sort.SortOrder;
-import org.elasticsearch.util.ElasticMockClient;
-import org.junit.Assert;
+import org.elasticsearch.dsl.parser.syntax.ElasticSql2DslParser;
 import org.junit.Test;
 
 

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

@@ -0,0 +1,21 @@
+package org.elasticsearch;
+
+import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.syntax.ElasticSql2DslParser;
+import org.junit.Test;
+
+
+public class SqlParserQueryTest {
+    @Test
+    public void testParseQueryExpr() {
+
+        String sql = "select id,status from index.order t "
+                + "query match(t.productName, '皮鞋', 'minimum_should_match:75%') 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());
+    }
+}

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

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

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

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

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

@@ -3,7 +3,7 @@ package org.elasticsearch;
 import org.elasticsearch.action.search.SearchAction;
 import org.elasticsearch.action.search.SearchRequestBuilder;
 import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.elasticsearch.dsl.parser.syntax.ElasticSql2DslParser;
 import org.elasticsearch.index.query.NestedQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;