sql

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

@@ -1,8 +0,0 @@
-package org.elasticsearch.dsl.parser;
-
-import org.elasticsearch.dsl.bean.ElasticDslContext;
-
-@FunctionalInterface
-public interface QueryParser {
-    void parse(ElasticDslContext dslContext);
-}

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

@@ -1,13 +0,0 @@
-package org.elasticsearch.dsl.parser.listener;
-
-import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
-import org.elasticsearch.dsl.enums.SQLConditionOperator;
-
-public interface ParseActionListener {
-
-    void onSelectFieldParse(ElasticSqlQueryField field);
-
-    void onAtomConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator);
-
-    void onFailure(Throwable t);
-}

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

@@ -1,22 +0,0 @@
-package org.elasticsearch.dsl.parser.listener;
-
-import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
-import org.elasticsearch.dsl.enums.SQLConditionOperator;
-
-public class ParseActionListenerAdapter implements ParseActionListener {
-
-    @Override
-    public void onSelectFieldParse(ElasticSqlQueryField field) {
-
-    }
-
-    @Override
-    public void onAtomConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
-
-    }
-
-    @Override
-    public void onFailure(Throwable t) {
-
-    }
-}

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.BoolFilterBuilder;
-import org.elasticsearch.index.query.FilterBuilder;
-import org.elasticsearch.index.query.FilterBuilders;
-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;
-            }
-
-            BoolFilterBuilder boolFilter = mergeAtomFilter(whereCondition.getFilterList(), operator);
-            dslContext.getParseResult().setWhereCondition(boolFilter);
-        }
-    }
-
-    private 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();
-                combineFilterBuilder(curFilterList, leftCondition, operator);
-                combineFilterBuilder(curFilterList, rightCondition, operator);
-
-
-                return new SQLCondition(curFilterList, operator);
-            }
-        }
-        return new SQLCondition(parseAtomFilterCondition(dslContext, sqlExpr), SQLConditionType.Atom);
-    }
-
-    private void combineFilterBuilder(List<AtomFilter> combiner, SQLCondition sqlCondition, SQLBoolOperator binOperator) {
-        if (SQLConditionType.Atom == sqlCondition.getSQLConditionType() || sqlCondition.getOperator() == binOperator) {
-            combiner.addAll(sqlCondition.getFilterList());
-        }
-        else {
-            //todo binOperator -> sqlCondition.getOperator()
-            BoolFilterBuilder boolFilter = mergeAtomFilter(sqlCondition.getFilterList(), sqlCondition.getOperator());
-            combiner.add(new AtomFilter(boolFilter));
-        }
-    }
-
-    private BoolFilterBuilder mergeAtomFilter(List<AtomFilter> atomFilterList, SQLBoolOperator operator) {
-        BoolFilterBuilder subBoolFilter = FilterBuilders.boolFilter();
-        ListMultimap<String, FilterBuilder> listMultiMap = ArrayListMultimap.create();
-
-        for (AtomFilter atomFilter : atomFilterList) {
-            if(Boolean.FALSE == atomFilter.getNestedFilter()) {
-                if (operator == SQLBoolOperator.AND) {
-                    subBoolFilter.must(atomFilter.getFilter());
-                }
-                if (operator == SQLBoolOperator.OR) {
-                    subBoolFilter.should(atomFilter.getFilter());
-                }
-            }
-            else {
-                String nestedDocPrefix = atomFilter.getNestedFilterPathContext();
-                listMultiMap.put(nestedDocPrefix, atomFilter.getFilter());
-            }
-        }
-
-        for (String nestedDocPrefix : listMultiMap.keySet()) {
-            List<FilterBuilder> nestedFilterList = listMultiMap.get(nestedDocPrefix);
-
-            if(nestedFilterList.size() == 1) {
-                if (operator == SQLBoolOperator.AND) {
-                    subBoolFilter.must(FilterBuilders.nestedFilter(nestedDocPrefix, nestedFilterList.get(0)));
-                }
-                if (operator == SQLBoolOperator.OR) {
-                    subBoolFilter.should(FilterBuilders.nestedFilter(nestedDocPrefix, nestedFilterList.get(0)));
-                }
-                continue;
-            }
-
-            BoolFilterBuilder boolNestedFilter = FilterBuilders.boolFilter();
-            for (FilterBuilder nestedFilterItem : nestedFilterList) {
-                if (operator == SQLBoolOperator.AND) {
-                    boolNestedFilter.must(nestedFilterItem);
-                }
-                if (operator == SQLBoolOperator.OR) {
-                    boolNestedFilter.should(nestedFilterItem);
-                }
-            }
-
-            if (operator == SQLBoolOperator.AND) {
-                subBoolFilter.must(FilterBuilders.nestedFilter(nestedDocPrefix, boolNestedFilter));
-            }
-            if (operator == SQLBoolOperator.OR) {
-                subBoolFilter.should(FilterBuilders.nestedFilter(nestedDocPrefix, boolNestedFilter));
-            }
-
-        }
-        return subBoolFilter;
-    }
-
-    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 ConditionFilterBuilder() {
-                        @Override
-                        public FilterBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                            FilterBuilder eqFilter = FilterBuilders.termFilter(leftIdfName, rightParamValues[0]);
-                            if (SQLConditionOperator.Equality == operator) {
-                                return eqFilter;
-                            } else {
-                                return FilterBuilders.notFilter(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 ConditionFilterBuilder() {
-                        @Override
-                        public FilterBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                            FilterBuilder rangeFilter = null;
-                            if (SQLConditionOperator.GreaterThan == operator) {
-                                rangeFilter = FilterBuilders.rangeFilter(leftIdfName).gt(rightParamValues[0]);
-                            } else if (SQLConditionOperator.GreaterThanOrEqual == operator) {
-                                rangeFilter = FilterBuilders.rangeFilter(leftIdfName).gte(rightParamValues[0]);
-                            } else if (SQLConditionOperator.LessThan == operator) {
-                                rangeFilter = FilterBuilders.rangeFilter(leftIdfName).lt(rightParamValues[0]);
-                            } else if (SQLConditionOperator.LessThanOrEqual == operator) {
-                                rangeFilter = FilterBuilders.rangeFilter(leftIdfName).lte(rightParamValues[0]);
-                            }
-                            return rangeFilter;
-                        }
-                    });
-                }
-
-                //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 ConditionFilterBuilder() {
-                        @Override
-                        public FilterBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                            FilterBuilder missingFilter = FilterBuilders.missingFilter(leftIdfName);
-                            if (SQLConditionOperator.IsNotNull == operator) {
-                                return FilterBuilders.notFilter(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 ConditionFilterBuilder() {
-                @Override
-                public FilterBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                    if (SQLConditionOperator.NotIn == operator) {
-                        return FilterBuilders.notFilter(FilterBuilders.inFilter(leftIdfName, rightParamValues));
-                    } else {
-                        return FilterBuilders.inFilter(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 ConditionFilterBuilder() {
-                @Override
-                public FilterBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues) {
-                    return FilterBuilders.rangeFilter(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, ConditionFilterBuilder filterBuilder) {
-        QueryFieldParser queryFieldParser = new QueryFieldParser();
-        ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(leftQueryFieldExpr, queryAs);
-
-        AtomFilter atomFilter = null;
-        if (queryField.getQueryFieldType() == QueryFieldType.RootDocField || queryField.getQueryFieldType() == QueryFieldType.InnerDocField) {
-            FilterBuilder originalFilter = filterBuilder.buildFilter(queryField.getQueryFieldFullName(), operator, rightParamValues);
-            atomFilter = new AtomFilter(originalFilter);
-        }
-
-        if (queryField.getQueryFieldType() == QueryFieldType.NestedDocField) {
-            FilterBuilder 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 ConditionFilterBuilder {
-        FilterBuilder 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/sql/ElasticSqlExprParser.java

@@ -1,4 +1,4 @@
-package org.elasticsearch.sql;
+package org.es.sql.druid;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.parser.Lexer;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.sql;
+package org.es.sql.druid;
 
 import com.alibaba.druid.sql.parser.Keywords;
 import com.alibaba.druid.sql.parser.Lexer;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.sql;
+package org.es.sql.druid;
 
 import com.alibaba.druid.sql.ast.SQLSetQuantifier;
 import com.alibaba.druid.sql.ast.statement.SQLExprTableSource;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.sql;
+package org.es.sql.druid;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLObject;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
 import org.elasticsearch.index.query.FilterBuilder;
 

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
 import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
@@ -9,7 +9,7 @@ import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilder;
 import org.elasticsearch.search.sort.SortBuilder;
-import org.elasticsearch.util.ElasticMockClient;
+import org.es.sql.util.ElasticMockClient;
 
 import java.util.List;
 
@@ -140,7 +140,8 @@ public class ElasticSqlParseResult {
 
         if (whereCondition != null && whereCondition.hasClauses()) {
             requestBuilder.setQuery(QueryBuilders.filteredQuery(null, whereCondition));
-        } else {
+        }
+        else {
             requestBuilder.setQuery(QueryBuilders.matchAllQuery());
         }
 
@@ -170,7 +171,8 @@ public class ElasticSqlParseResult {
                     preAgg = (AggregationBuilder) aggItem;
                 }
                 requestBuilder.addAggregation(groupBy.get(0));
-            } else {
+            }
+            else {
                 for (AbstractAggregationBuilder aggItem : groupBy) {
                     requestBuilder.addAggregation(aggItem);
                 }

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

@@ -1,6 +1,6 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
-import org.elasticsearch.dsl.enums.QueryFieldType;
+import org.es.sql.dsl.enums.QueryFieldType;
 
 public class ElasticSqlQueryField {
     /*[内嵌文档]的上下文路径*/

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

@@ -1,6 +1,6 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
-import org.elasticsearch.dsl.enums.QueryFieldType;
+import org.es.sql.dsl.enums.QueryFieldType;
 
 public class ElasticSqlQueryFields {
     private ElasticSqlQueryFields() {

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
 public class QueryFieldReferenceNode {
 

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
 
 public class RangeSegment {
     private Object from;

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

@@ -1,8 +1,9 @@
-package org.elasticsearch.dsl.bean;
+package org.es.sql.dsl.bean;
+
 
 import com.google.common.collect.Lists;
-import org.elasticsearch.dsl.enums.SQLBoolOperator;
-import org.elasticsearch.dsl.enums.SQLConditionType;
+import org.es.sql.dsl.enums.SQLBoolOperator;
+import org.es.sql.dsl.enums.SQLConditionType;
 
 import java.util.List;
 

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.enums;
+package org.es.sql.dsl.enums;
 
 public enum QueryFieldType {
     MatchAllField,

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.enums;
+package org.es.sql.dsl.enums;
 
 public enum SQLBoolOperator {
     AND, OR

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.enums;
+package org.es.sql.dsl.enums;
 
 public enum SQLConditionOperator {
     Equality,

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.enums;
+package org.es.sql.dsl.enums;
 
 
 public enum SQLConditionType {

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.enums;
+package org.es.sql.dsl.enums;
 
 public enum SortOption {
     SUM {

src/main/java/org/elasticsearch/dsl/exception/ElasticSql2DslException.java

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.exception;
+package org.es.sql.dsl.exception;
 
 import com.alibaba.druid.sql.parser.ParserException;
 

src/main/java/org/elasticsearch/dsl/parser/helper/ElasticSqlArgTransferHelper.java

@@ -1,8 +1,8 @@
-package org.elasticsearch.dsl.parser.helper;
+package org.es.sql.dsl.helper;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.*;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
 
 import java.util.List;
 
@@ -29,30 +29,36 @@ public class ElasticSqlArgTransferHelper {
             if (varRefExpr.getIndex() >= sqlArgs.length) {
                 throw new ElasticSql2DslException("[syntax error] Sql args out of index: " + varRefExpr.getIndex());
             }
-            //解析date类型
+            //parse date
             if (recognizeDateArg && ElasticSqlDateParseHelper.isDateArgObjectValue(sqlArgs[varRefExpr.getIndex()])) {
                 return ElasticSqlDateParseHelper.formatDefaultEsDateObjectValue(sqlArgs[varRefExpr.getIndex()]);
             }
             return sqlArgs[varRefExpr.getIndex()];
         }
+
+        //numbers
         if (expr instanceof SQLIntegerExpr) {
             return ((SQLIntegerExpr) expr).getNumber().longValue();
         }
         if (expr instanceof SQLNumberExpr) {
             return ((SQLNumberExpr) expr).getNumber().doubleValue();
         }
+
+        //string
         if (expr instanceof SQLCharExpr) {
             Object textObject = ((SQLCharExpr) expr).getValue();
-            //解析date类型
+            //parse date
             if (recognizeDateArg && (textObject instanceof String) && ElasticSqlDateParseHelper.isDateArgStringValue((String) textObject)) {
                 return ElasticSqlDateParseHelper.formatDefaultEsDateStringValue((String) textObject);
             }
             return textObject;
         }
+
+        //method call
         if (expr instanceof SQLMethodInvokeExpr) {
             SQLMethodInvokeExpr methodExpr = (SQLMethodInvokeExpr) expr;
 
-            //解析date函数
+            //parse date method
             if (ElasticSqlDateParseHelper.isDateMethod(methodExpr)) {
                 ElasticSqlMethodInvokeHelper.checkDateMethod(methodExpr);
                 String patternArg = (String) ElasticSqlArgTransferHelper.transferSqlArg(methodExpr.getParameters().get(0), sqlArgs, false);

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

@@ -1,7 +1,8 @@
-package org.elasticsearch.dsl.parser.helper;
+package org.es.sql.dsl.helper;
 
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.util.Constants;
 
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
@@ -9,54 +10,13 @@ import java.util.Date;
 import java.util.regex.Pattern;
 
 public class ElasticSqlDateParseHelper {
-    public static final String DEFAULT_ES_DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
 
     public static final Pattern SQL_DATE_REGEX_PATTERN_01 = Pattern.compile("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}");
     public static final Pattern SQL_DATE_REGEX_PATTERN_02 = Pattern.compile("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}");
     public static final Pattern SQL_DATE_REGEX_PATTERN_03 = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
 
-    private enum SqlDateRegex {
-        DATE_REGEX_01 {
-            @Override
-            Pattern getPattern() {
-                return SQL_DATE_REGEX_PATTERN_01;
-            }
-
-            @Override
-            String getPatternString() {
-                return "yyyy-MM-dd HH:mm:ss";
-            }
-        },
-        DATE_REGEX_02 {
-            @Override
-            Pattern getPattern() {
-                return SQL_DATE_REGEX_PATTERN_02;
-            }
-
-            @Override
-            String getPatternString() {
-                return "yyyy-MM-dd HH:mm";
-            }
-        },
-        DATE_REGEX_03 {
-            @Override
-            Pattern getPattern() {
-                return SQL_DATE_REGEX_PATTERN_03;
-            }
-
-            @Override
-            String getPatternString() {
-                return "yyyy-MM-dd";
-            }
-        };
-
-        abstract Pattern getPattern();
-
-        abstract String getPatternString();
-    }
-
     public static boolean isDateMethod(SQLMethodInvokeExpr dateMethodExpr) {
-        return ElasticSqlMethodInvokeHelper.DATE_METHOD.equalsIgnoreCase(dateMethodExpr.getMethodName());
+        return ElasticSqlMethodInvokeHelper.isMethodOf(ElasticSqlMethodInvokeHelper.DATE_METHOD, dateMethodExpr.getMethodName());
     }
 
     public static boolean isDateArgStringValue(String date) {
@@ -66,10 +26,7 @@ public class ElasticSqlDateParseHelper {
     }
 
     public static boolean isDateArgObjectValue(Object date) {
-        if (date instanceof Date) {
-            return true;
-        }
-        return false;
+        return date instanceof Date;
     }
 
     public static String formatDefaultEsDateStringValue(String date) {
@@ -87,7 +44,7 @@ public class ElasticSqlDateParseHelper {
 
     public static String formatDefaultEsDateObjectValue(Object date) {
         if (date instanceof Date) {
-            SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_ES_DATE_FORMAT);
+            SimpleDateFormat dateFormat = new SimpleDateFormat(Constants.DEFAULT_ES_DATE_FORMAT);
             return dateFormat.format(date);
         }
         throw new ElasticSql2DslException("[syntax error] Sql cannot support such date type: " + date.getClass());
@@ -98,10 +55,51 @@ public class ElasticSqlDateParseHelper {
             SimpleDateFormat dateFormat = new SimpleDateFormat(patternArg);
             Date date = dateFormat.parse(timeValArg);
 
-            dateFormat = new SimpleDateFormat(DEFAULT_ES_DATE_FORMAT);
+            dateFormat = new SimpleDateFormat(Constants.DEFAULT_ES_DATE_FORMAT);
             return dateFormat.format(date);
-        } catch (ParseException pex) {
+        }
+        catch (ParseException pex) {
             throw new ElasticSql2DslException("[syntax error] Parse time arg error: " + timeValArg);
         }
     }
+
+    private enum SqlDateRegex {
+        DATE_REGEX_01 {
+            @Override
+            Pattern getPattern() {
+                return SQL_DATE_REGEX_PATTERN_01;
+            }
+
+            @Override
+            String getPatternString() {
+                return "yyyy-MM-dd HH:mm:ss";
+            }
+        },
+        DATE_REGEX_02 {
+            @Override
+            Pattern getPattern() {
+                return SQL_DATE_REGEX_PATTERN_02;
+            }
+
+            @Override
+            String getPatternString() {
+                return "yyyy-MM-dd HH:mm";
+            }
+        },
+        DATE_REGEX_03 {
+            @Override
+            Pattern getPattern() {
+                return SQL_DATE_REGEX_PATTERN_03;
+            }
+
+            @Override
+            String getPatternString() {
+                return "yyyy-MM-dd";
+            }
+        };
+
+        abstract Pattern getPattern();
+
+        abstract String getPatternString();
+    }
 }

src/main/java/org/elasticsearch/dsl/parser/helper/ElasticSqlMethodInvokeHelper.java

@@ -1,40 +1,61 @@
-package org.elasticsearch.dsl.parser.helper;
+package org.es.sql.dsl.helper;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.*;
+import com.google.common.collect.ImmutableList;
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.dsl.enums.SortOption;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.apache.commons.lang.StringUtils;
+import org.es.sql.dsl.enums.SortOption;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
 
-public class ElasticSqlMethodInvokeHelper {
+import java.util.List;
 
-    public static final String DATE_METHOD = "date";
-    public static final String NVL_METHOD = "nvl";
+public class ElasticSqlMethodInvokeHelper {
+    public static final List<String> DATE_METHOD = ImmutableList.of("date", "to_date", "toDate");
+    public static final List<String> NVL_METHOD = ImmutableList.of("nvl", "is_null", "isnull");
 
-    public static final String AGG_TERMS_METHOD = "terms";
-    public static final String AGG_RANGE_METHOD = "range";
-    public static final String AGG_RANGE_SEGMENT_METHOD = "segment";
+    public static final List<String> AGG_TERMS_METHOD = ImmutableList.of("terms", "terms_agg");
+    public static final List<String> AGG_RANGE_METHOD = ImmutableList.of("range", "range_agg");
+    public static final List<String> AGG_RANGE_SEGMENT_METHOD = ImmutableList.of("segment", "segment_agg");
 
     public static final String AGG_MIN_METHOD = "min";
     public static final String AGG_MAX_METHOD = "max";
     public static final String AGG_AVG_METHOD = "avg";
     public static final String AGG_SUM_METHOD = "sum";
 
+    public static Boolean isMethodOf(List<String> methodAlias, String method) {
+        if (CollectionUtils.isEmpty(methodAlias)) {
+            return Boolean.FALSE;
+        }
+        for (String alias : methodAlias) {
+            if (alias.equalsIgnoreCase(method)) {
+                return Boolean.TRUE;
+            }
+        }
+        return Boolean.FALSE;
+    }
+
+    public static Boolean isMethodOf(String methodAlias, String method) {
+        if (StringUtils.isBlank(methodAlias)) {
+            return Boolean.FALSE;
+        }
+        return methodAlias.equalsIgnoreCase(method);
+    }
 
     public static void checkTermsAggMethod(SQLMethodInvokeExpr aggInvokeExpr) {
-        if (!AGG_TERMS_METHOD.equalsIgnoreCase(aggInvokeExpr.getMethodName())) {
+        if (!isMethodOf(AGG_TERMS_METHOD, aggInvokeExpr.getMethodName())) {
             throw new ElasticSql2DslException("[syntax error] Sql not support method:" + aggInvokeExpr.getMethodName());
         }
     }
 
     public static void checkRangeAggMethod(SQLMethodInvokeExpr aggInvokeExpr) {
-        if (!AGG_RANGE_METHOD.equalsIgnoreCase(aggInvokeExpr.getMethodName())) {
+        if (!isMethodOf(AGG_RANGE_METHOD, aggInvokeExpr.getMethodName())) {
             throw new ElasticSql2DslException("[syntax error] Sql not support method:" + aggInvokeExpr.getMethodName());
         }
     }
 
     public static void checkRangeItemAggMethod(SQLMethodInvokeExpr aggInvokeExpr) {
-        if (!AGG_RANGE_SEGMENT_METHOD.equalsIgnoreCase(aggInvokeExpr.getMethodName())) {
+        if (!isMethodOf(AGG_RANGE_SEGMENT_METHOD, aggInvokeExpr.getMethodName())) {
             throw new ElasticSql2DslException("[syntax error] Sql not support method:" + aggInvokeExpr.getMethodName());
         }
     }
@@ -49,7 +70,7 @@ public class ElasticSqlMethodInvokeHelper {
     }
 
     public static void checkDateMethod(SQLMethodInvokeExpr dateInvokeExpr) {
-        if (!DATE_METHOD.equalsIgnoreCase(dateInvokeExpr.getMethodName())) {
+        if (!isMethodOf(DATE_METHOD, dateInvokeExpr.getMethodName())) {
             throw new ElasticSql2DslException("[syntax error] Sql not support method:" + dateInvokeExpr.getMethodName());
         }
 
@@ -71,7 +92,7 @@ public class ElasticSqlMethodInvokeHelper {
     }
 
     public static void checkNvlMethod(SQLMethodInvokeExpr nvlInvokeExpr) {
-        if (!NVL_METHOD.equalsIgnoreCase(nvlInvokeExpr.getMethodName())) {
+        if (!isMethodOf(NVL_METHOD, nvlInvokeExpr.getMethodName())) {
             throw new ElasticSql2DslException("[syntax error] Sql sort condition only support nvl method invoke");
         }
 

src/main/java/org/es/sql/dsl/listener/ParseActionListener.java

@@ -0,0 +1,13 @@
+package org.es.sql.dsl.listener;
+
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.enums.SQLConditionOperator;
+
+public interface ParseActionListener {
+
+    void onSelectFieldParse(ElasticSqlQueryField field);
+
+    void onAtomFilterConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator);
+
+    void onFailure(Throwable t);
+}

src/main/java/org/es/sql/dsl/listener/ParseActionListenerAdapter.java

@@ -0,0 +1,22 @@
+package org.es.sql.dsl.listener;
+
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.enums.SQLConditionOperator;
+
+public class ParseActionListenerAdapter implements ParseActionListener {
+
+    @Override
+    public void onSelectFieldParse(ElasticSqlQueryField field) {
+
+    }
+
+    @Override
+    public void onAtomFilterConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
+
+    }
+
+    @Override
+    public void onFailure(Throwable t) {
+
+    }
+}

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

@@ -1,18 +1,19 @@
-package org.elasticsearch.dsl.parser;
+package org.es.sql.dsl.parser;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 import com.alibaba.druid.sql.parser.ParserException;
 import com.alibaba.druid.sql.parser.Token;
 import com.google.common.collect.ImmutableList;
-import org.elasticsearch.dsl.bean.ElasticDslContext;
-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.sql.ElasticSqlExprParser;
-import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
+import org.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.bean.ElasticSqlParseResult;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.parser.sql.QueryParser;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.listener.ParseActionListenerAdapter;
+import org.es.sql.dsl.parser.sql.*;
+import org.es.sql.druid.ElasticSqlExprParser;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
 
 import java.lang.reflect.Array;
 import java.util.Collection;

src/main/java/org/es/sql/dsl/parser/query/exact/AbstractAtomExactQueryParser.java

@@ -0,0 +1,60 @@
+package org.es.sql.dsl.parser.query.exact;
+
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.enums.QueryFieldType;
+import org.es.sql.dsl.enums.SQLConditionOperator;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.sql.QueryFieldParser;
+
+public abstract class AbstractAtomExactQueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public AbstractAtomExactQueryParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    protected AtomFilter parseCondition(SQLExpr queryFieldExpr, SQLConditionOperator operator, Object[] rightParamValues, String queryAs, IConditionExactQueryBuilder queryBuilder) {
+        QueryFieldParser queryFieldParser = new QueryFieldParser();
+        ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(queryFieldExpr, queryAs);
+
+        AtomFilter atomQuery = null;
+        if (queryField.getQueryFieldType() == QueryFieldType.RootDocField || queryField.getQueryFieldType() == QueryFieldType.InnerDocField) {
+            FilterBuilder originalQuery = queryBuilder.buildQuery(queryField.getQueryFieldFullName(), operator, rightParamValues);
+            atomQuery = new AtomFilter(originalQuery);
+        }
+
+        if (queryField.getQueryFieldType() == QueryFieldType.NestedDocField) {
+            FilterBuilder originalQuery = queryBuilder.buildQuery(queryField.getQueryFieldFullName(), operator, rightParamValues);
+            atomQuery = new AtomFilter(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.onAtomFilterConditionParse(paramName, paramValues, operator);
+        }
+        catch (Exception ex) {
+            try {
+                parseActionListener.onFailure(ex);
+            }
+            catch (Exception exp) {
+                //ignore;
+            }
+        }
+    }
+
+}

src/main/java/org/es/sql/dsl/parser/query/exact/BetweenAndAtomQueryParser.java

@@ -0,0 +1,33 @@
+package org.es.sql.dsl.parser.query.exact;
+
+import com.alibaba.druid.sql.ast.expr.SQLBetweenExpr;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.enums.SQLConditionOperator;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
+
+public class BetweenAndAtomQueryParser extends AbstractAtomExactQueryParser {
+
+    public BetweenAndAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    public AtomFilter 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 FilterBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                return FilterBuilders.rangeFilter(queryFieldName).gte(rightParamValues[0]).lte(rightParamValues[1]);
+            }
+        });
+    }
+}

src/main/java/org/es/sql/dsl/parser/query/exact/BinaryAtomQueryParser.java

@@ -0,0 +1,104 @@
+package org.es.sql.dsl.parser.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.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.enums.SQLConditionOperator;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
+
+public class BinaryAtomQueryParser extends AbstractAtomExactQueryParser {
+
+    public BinaryAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    public AtomFilter 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 FilterBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                    FilterBuilder eqQuery = FilterBuilders.termFilter(queryFieldName, rightParamValues[0]);
+                    if (SQLConditionOperator.Equality == operator) {
+                        return eqQuery;
+                    }
+                    else {
+                        return FilterBuilders.boolFilter().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 FilterBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                    FilterBuilder rangeQuery = null;
+                    if (SQLConditionOperator.GreaterThan == operator) {
+                        rangeQuery = FilterBuilders.rangeFilter(queryFieldName).gt(rightParamValues[0]);
+                    }
+                    else if (SQLConditionOperator.GreaterThanOrEqual == operator) {
+                        rangeQuery = FilterBuilders.rangeFilter(queryFieldName).gte(rightParamValues[0]);
+                    }
+                    else if (SQLConditionOperator.LessThan == operator) {
+                        rangeQuery = FilterBuilders.rangeFilter(queryFieldName).lt(rightParamValues[0]);
+                    }
+                    else if (SQLConditionOperator.LessThanOrEqual == operator) {
+                        rangeQuery = FilterBuilders.rangeFilter(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 FilterBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                    ExistsFilterBuilder existsQuery = FilterBuilders.existsFilter(queryFieldName);
+                    if (SQLConditionOperator.IsNull == operator) {
+                        return FilterBuilders.boolFilter().mustNot(existsQuery);
+                    }
+                    return existsQuery;
+                }
+            });
+        }
+
+        throw new ElasticSql2DslException(String.format("[syntax error] Can not support binary query type[%s]", binQueryExpr.toString()));
+    }
+}

src/main/java/org/es/sql/dsl/parser/query/exact/IConditionExactQueryBuilder.java

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

src/main/java/org/es/sql/dsl/parser/query/exact/InListAtomQueryParser.java

@@ -0,0 +1,39 @@
+package org.es.sql.dsl.parser.query.exact;
+
+import com.alibaba.druid.sql.ast.expr.SQLInListExpr;
+import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.enums.SQLConditionOperator;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
+
+public class InListAtomQueryParser extends AbstractAtomExactQueryParser {
+
+    public InListAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    public AtomFilter 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 FilterBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) {
+                if (SQLConditionOperator.NotIn == operator) {
+                    return FilterBuilders.boolFilter().mustNot(FilterBuilders.termsFilter(queryFieldName, rightParamValues));
+                }
+                else {
+                    return FilterBuilders.termsFilter(queryFieldName, rightParamValues);
+                }
+            }
+        });
+    }
+}

src/main/java/org/es/sql/dsl/parser/query/method/AbstractFieldSpecificMethodQueryParser.java

@@ -0,0 +1,55 @@
+package org.es.sql.dsl.parser.query.method;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.enums.QueryFieldType;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.sql.QueryFieldParser;
+
+import java.util.Map;
+
+public abstract class AbstractFieldSpecificMethodQueryParser extends ParameterizedMethodQueryParser {
+
+    protected ParseActionListener parseActionListener;
+
+    public AbstractFieldSpecificMethodQueryParser(ParseActionListener parseActionListener) {
+        this.parseActionListener = parseActionListener;
+    }
+
+    protected abstract FilterBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams);
+
+    protected abstract SQLExpr defineFieldExpr(MethodInvocation invocation);
+
+    @Override
+    protected String defineExtraParamString(MethodInvocation invocation) {
+        //ignore extra params, subclass can override if necessary
+        return null;
+    }
+
+    @Override
+    protected AtomFilter parseMethodQueryWithExtraParams(MethodInvocation invocation, Map<String, String> extraParamMap) throws ElasticSql2DslException {
+        QueryFieldParser queryFieldParser = new QueryFieldParser();
+        ElasticSqlQueryField queryField = queryFieldParser.parseConditionQueryField(defineFieldExpr(invocation), invocation.getQueryAs());
+
+        AtomFilter atomQuery = null;
+        if (queryField.getQueryFieldType() == QueryFieldType.RootDocField || queryField.getQueryFieldType() == QueryFieldType.InnerDocField) {
+            FilterBuilder originalQuery = buildQuery(invocation, queryField.getQueryFieldFullName(), extraParamMap);
+            atomQuery = new AtomFilter(originalQuery);
+        }
+
+        if (queryField.getQueryFieldType() == QueryFieldType.NestedDocField) {
+            FilterBuilder originalQuery = buildQuery(invocation, queryField.getQueryFieldFullName(), extraParamMap);
+            atomQuery = new AtomFilter(originalQuery, queryField.getNestedDocContextPath());
+        }
+
+        if (atomQuery == null) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] query field can not support type[%s]", queryField.getQueryFieldType()));
+        }
+
+        return atomQuery;
+    }
+}

src/main/java/org/es/sql/dsl/parser/query/method/CheckableMethodQueryParser.java

@@ -0,0 +1,28 @@
+package org.es.sql.dsl.parser.query.method;
+
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.helper.ElasticSqlMethodInvokeHelper;
+
+public abstract class CheckableMethodQueryParser implements MethodQueryParser {
+
+    protected abstract void checkMethodInvokeArgs(MethodInvocation invocation) throws ElasticSql2DslException;
+
+    protected abstract AtomFilter parseMethodQueryWithCheck(MethodInvocation invocation) throws ElasticSql2DslException;
+
+    @Override
+    public boolean isMatchMethodInvocation(MethodInvocation invocation) {
+        return ElasticSqlMethodInvokeHelper.isMethodOf(defineMethodNames(), invocation.getMethodName());
+    }
+
+    @Override
+    public AtomFilter parseAtomMethodQuery(MethodInvocation invocation) throws ElasticSql2DslException {
+        if (!isMatchMethodInvocation(invocation)) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] Expected method name is one of [%s],but get [%s]",
+                            defineMethodNames(), invocation.getMethodName()));
+        }
+        checkMethodInvokeArgs(invocation);
+        return parseMethodQueryWithCheck(invocation);
+    }
+}

src/main/java/org/es/sql/dsl/parser/query/method/MethodInvocation.java

@@ -0,0 +1,77 @@
+package org.es.sql.dsl.parser.query.method;
+
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+
+import java.util.List;
+
+public class MethodInvocation {
+    private final SQLMethodInvokeExpr methodInvokeExpr;
+    private final String queryAs;
+    private final Object[] sqlArgs;
+
+    public MethodInvocation(SQLMethodInvokeExpr methodInvokeExpr, String queryAs, Object[] sqlArgs) {
+        if (methodInvokeExpr == null) {
+            throw new IllegalArgumentException("method invoke expression can not be null");
+        }
+        this.methodInvokeExpr = methodInvokeExpr;
+        this.queryAs = queryAs;
+        this.sqlArgs = sqlArgs;
+    }
+
+    public String getQueryAs() {
+        return queryAs;
+    }
+
+    public Object[] getSqlArgs() {
+        return sqlArgs;
+    }
+
+    public String getMethodName() {
+        return methodInvokeExpr.getMethodName();
+    }
+
+    public List<SQLExpr> getParameters() {
+        return methodInvokeExpr.getParameters();
+    }
+
+    public int getParameterCount() {
+        return methodInvokeExpr.getParameters().size();
+    }
+
+    public SQLExpr getFirstParameter(int index) {
+        return getParameter(0);
+    }
+
+    public SQLExpr getParameter(int index) {
+        return methodInvokeExpr.getParameters().get(index);
+    }
+
+    public Object getParameterAsObject(int index) {
+        SQLExpr paramExpr = methodInvokeExpr.getParameters().get(index);
+        return ElasticSqlArgTransferHelper.transferSqlArg(paramExpr, sqlArgs, false);
+    }
+
+    public String getParameterAsFormatDate(int index) {
+        SQLExpr paramExpr = methodInvokeExpr.getParameters().get(index);
+        return ElasticSqlArgTransferHelper.transferSqlArg(paramExpr, sqlArgs, true).toString();
+    }
+
+    public String getParameterAsString(int index) {
+        return getParameterAsObject(index).toString();
+    }
+
+    public String getLastParameterAsString() {
+        return getParameterAsObject(getParameterCount() - 1).toString();
+    }
+
+    public Double getParameterAsDouble(int index) {
+        return (Double) getParameterAsObject(index);
+    }
+
+    public Long getParameterAsLong(int index) {
+        return (Long) getParameterAsObject(index);
+    }
+}

src/main/java/org/es/sql/dsl/parser/query/method/MethodQueryParser.java

@@ -0,0 +1,15 @@
+package org.es.sql.dsl.parser.query.method;
+
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+
+import java.util.List;
+
+public interface MethodQueryParser {
+
+    List<String> defineMethodNames();
+
+    boolean isMatchMethodInvocation(MethodInvocation invocation);
+
+    AtomFilter parseAtomMethodQuery(MethodInvocation invocation) throws ElasticSql2DslException;
+}

src/main/java/org/es/sql/dsl/parser/query/method/ParameterizedMethodQueryParser.java

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

src/main/java/org/es/sql/dsl/parser/query/method/script/ScriptAtomQueryParser.java

@@ -0,0 +1,63 @@
+package org.es.sql.dsl.parser.query.method.script;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Maps;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.math.NumberUtils;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.parser.query.method.MethodInvocation;
+import org.es.sql.dsl.parser.query.method.ParameterizedMethodQueryParser;
+
+import java.util.List;
+import java.util.Map;
+
+public class ScriptAtomQueryParser extends ParameterizedMethodQueryParser {
+
+    private static List<String> SCRIPT_METHOD = ImmutableList.of("script_query", "scriptQuery");
+
+    @Override
+    public List<String> defineMethodNames() {
+        return SCRIPT_METHOD;
+    }
+
+    @Override
+    protected String defineExtraParamString(MethodInvocation invocation) {
+        int extraParamIdx = 1;
+
+        return (invocation.getParameterCount() == extraParamIdx + 1)
+                ? invocation.getParameterAsString(extraParamIdx) : StringUtils.EMPTY;
+    }
+
+    @Override
+    protected void checkMethodInvokeArgs(MethodInvocation invocation) throws ElasticSql2DslException {
+        if (invocation.getParameterCount() != 1 && invocation.getParameterCount() != 2) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] There's no %s args method named [%s].",
+                            invocation.getParameterCount(), invocation.getMethodName()));
+        }
+
+        String script = invocation.getParameterAsString(0);
+        if (StringUtils.isEmpty(script)) {
+            throw new ElasticSql2DslException("[syntax error] Script can not be blank!");
+        }
+    }
+
+    @Override
+    protected AtomFilter parseMethodQueryWithExtraParams(MethodInvocation invocation, Map<String, String> extraParamMap) throws ElasticSql2DslException {
+        String script = invocation.getParameterAsString(0);
+
+        if (MapUtils.isNotEmpty(extraParamMap)) {
+            Map<String, Object> scriptParamMap = Maps.transformEntries(extraParamMap, new Maps.EntryTransformer<String, String, Object>() {
+                @Override
+                public Object transformEntry(String key, String value) {
+                    return NumberUtils.isNumber(value) ? NumberUtils.createNumber(value) : value;
+                }
+            });
+            return new AtomFilter(FilterBuilders.scriptFilter(script).params(scriptParamMap));
+        }
+        return new AtomFilter(FilterBuilders.scriptFilter(script));
+    }
+}

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

@@ -0,0 +1,53 @@
+package org.es.sql.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.google.common.collect.ImmutableList;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.es.sql.dsl.parser.query.method.MethodInvocation;
+
+import java.util.List;
+import java.util.Map;
+
+public class PrefixAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
+
+    private static List<String> PREFIX_QUERY_METHOD = ImmutableList.of("prefix", "prefix_query", "prefixQuery");
+
+    public PrefixAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    public List<String> defineMethodNames() {
+        return PREFIX_QUERY_METHOD;
+    }
+
+    @Override
+    protected SQLExpr defineFieldExpr(MethodInvocation invocation) {
+        return invocation.getParameter(0);
+    }
+
+    @Override
+    protected void checkMethodInvokeArgs(MethodInvocation invocation) {
+        if (invocation.getParameterCount() != 2) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] There's no %s args method named [%s].",
+                            invocation.getParameterCount(), invocation.getMethodName()));
+        }
+
+        String text = invocation.getParameterAsString(1);
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Prefix search text can not be blank!");
+        }
+    }
+
+    @Override
+    protected FilterBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        String text = invocation.getParameterAsString(1);
+        return FilterBuilders.prefixFilter(fieldName, text);
+    }
+}

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

@@ -0,0 +1,105 @@
+package org.es.sql.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.elasticsearch.index.query.RegexpFilterBuilder;
+import org.elasticsearch.index.query.RegexpFlag;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.es.sql.dsl.parser.query.method.MethodInvocation;
+
+import java.util.List;
+import java.util.Map;
+
+public class RegexpAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
+
+    private static List<String> REGEXP_QUERY_METHOD = ImmutableList.of("regexp", "regexp_query", "regexpQuery");
+
+    public RegexpAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    public List<String> defineMethodNames() {
+        return REGEXP_QUERY_METHOD;
+    }
+
+    @Override
+    protected SQLExpr defineFieldExpr(MethodInvocation invocation) {
+        return invocation.getParameter(0);
+    }
+
+    @Override
+    protected String defineExtraParamString(MethodInvocation invocation) {
+        int extraParamIdx = 2;
+
+        return (invocation.getParameterCount() == extraParamIdx + 1)
+                ? invocation.getParameterAsString(extraParamIdx) : StringUtils.EMPTY;
+    }
+
+    @Override
+    protected void checkMethodInvokeArgs(MethodInvocation invocation) throws ElasticSql2DslException {
+        if (invocation.getParameterCount() != 2 && invocation.getParameterCount() != 3) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] There's no %s args method named [%s].",
+                            invocation.getParameterCount(), invocation.getMethodName()));
+        }
+
+        String text = invocation.getParameterAsString(1);
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Regexp search text can not be blank!");
+        }
+
+        if (invocation.getParameterCount() == 3) {
+            String extraParamString = defineExtraParamString(invocation);
+            if (StringUtils.isEmpty(extraParamString)) {
+                throw new ElasticSql2DslException("[syntax error] The extra param of regexp method can not be blank");
+            }
+        }
+    }
+
+    @Override
+    protected FilterBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        String text = invocation.getParameterAsString(1);
+        RegexpFilterBuilder regexpQuery = FilterBuilders.regexpFilter(fieldName, text);
+
+        setExtraMatchQueryParam(regexpQuery, extraParams);
+        return regexpQuery;
+    }
+
+
+    private void setExtraMatchQueryParam(RegexpFilterBuilder regexpQuery, Map<String, String> extraParamMap) {
+        if (MapUtils.isEmpty(extraParamMap)) {
+            return;
+        }
+
+        if (extraParamMap.containsKey("max_determinized_states")) {
+            String val = extraParamMap.get("max_determinized_states");
+            regexpQuery.maxDeterminizedStates(Integer.valueOf(val));
+        }
+
+        if (extraParamMap.containsKey("flags")) {
+            String[] flags = extraParamMap.get("flags").split("\\|");
+            List<RegexpFlag> flagList = Lists.newLinkedList();
+            for (String flag : flags) {
+                flagList.add(RegexpFlag.valueOf(flag.toUpperCase()));
+            }
+            regexpQuery.flags(flagList.toArray(new RegexpFlag[flagList.size()]));
+        }
+
+        if (extraParamMap.containsKey("flags_value")) {
+            String[] flags = extraParamMap.get("flags_value").split("\\|");
+            List<RegexpFlag> flagList = Lists.newLinkedList();
+            for (String flag : flags) {
+                flagList.add(RegexpFlag.valueOf(flag.toUpperCase()));
+            }
+            regexpQuery.flags(flagList.toArray(new RegexpFlag[flagList.size()]));
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+package org.es.sql.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.google.common.collect.ImmutableList;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.es.sql.dsl.parser.query.method.MethodInvocation;
+
+import java.util.List;
+import java.util.Map;
+
+public class TermAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
+
+    private static List<String> TERM_QUERY_METHOD = ImmutableList.of("term", "term_query", "termQuery");
+
+    public TermAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    public List<String> defineMethodNames() {
+        return TERM_QUERY_METHOD;
+    }
+
+    @Override
+    protected SQLExpr defineFieldExpr(MethodInvocation invocation) {
+        return invocation.getParameter(0);
+    }
+
+    @Override
+    protected void checkMethodInvokeArgs(MethodInvocation invocation) throws ElasticSql2DslException {
+        if (invocation.getParameterCount() != 2 && invocation.getParameterCount() != 3) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] There's no %s args method named [%s].",
+                            invocation.getParameterCount(), invocation.getMethodName()));
+        }
+
+        String text = invocation.getParameterAsString(1);
+        if (StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Term search text can not be blank!");
+        }
+
+        if (invocation.getParameterCount() == 3) {
+            String extraParamString = defineExtraParamString(invocation);
+            if (StringUtils.isEmpty(extraParamString)) {
+                throw new ElasticSql2DslException("[syntax error] The extra param of term method can not be blank");
+            }
+        }
+    }
+
+    @Override
+    protected FilterBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        String text = invocation.getParameterAsString(1);
+
+        return FilterBuilders.termFilter(fieldName, text);
+    }
+}

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

@@ -0,0 +1,51 @@
+package org.es.sql.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import com.google.common.collect.ImmutableList;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.query.method.MethodInvocation;
+import org.es.sql.dsl.parser.query.method.MethodQueryParser;
+
+import java.util.List;
+
+public class TermLevelAtomQueryParser {
+
+    private final List<MethodQueryParser> methodQueryParsers;
+
+    public TermLevelAtomQueryParser(ParseActionListener parseActionListener) {
+        methodQueryParsers = ImmutableList.of(
+                new PrefixAtomQueryParser(parseActionListener),
+                new TermAtomQueryParser(parseActionListener),
+                new TermsAtomQueryParser(parseActionListener),
+                new RegexpAtomQueryParser(parseActionListener)
+        );
+    }
+
+    public Boolean isTermLevelAtomQuery(MethodInvocation invocation) {
+        for (MethodQueryParser methodQueryParserItem : methodQueryParsers) {
+            if (methodQueryParserItem.isMatchMethodInvocation(invocation)) {
+                return Boolean.TRUE;
+            }
+        }
+        return Boolean.TRUE;
+    }
+
+    public AtomFilter parseTermLevelAtomQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        MethodInvocation methodInvocation = new MethodInvocation(methodQueryExpr, queryAs, sqlArgs);
+        MethodQueryParser matchAtomQueryParser = getQueryParser(methodInvocation);
+        return matchAtomQueryParser.parseAtomMethodQuery(methodInvocation);
+    }
+
+    private MethodQueryParser getQueryParser(MethodInvocation methodInvocation) {
+        for (MethodQueryParser methodQueryParserItem : methodQueryParsers) {
+            if (methodQueryParserItem.isMatchMethodInvocation(methodInvocation)) {
+                return methodQueryParserItem;
+            }
+        }
+        throw new ElasticSql2DslException(
+                String.format("[syntax error] Can not support method query expr[%s] condition",
+                        methodInvocation.getMethodName()));
+    }
+}

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

@@ -0,0 +1,79 @@
+package org.es.sql.dsl.parser.query.method.term;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.query.method.AbstractFieldSpecificMethodQueryParser;
+import org.es.sql.dsl.parser.query.method.MethodInvocation;
+
+import java.util.List;
+import java.util.Map;
+
+public class TermsAtomQueryParser extends AbstractFieldSpecificMethodQueryParser {
+
+    private static List<String> TERMS_QUERY_METHOD = ImmutableList.of("terms", "terms_query", "termsQuery");
+
+    public TermsAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    public List<String> defineMethodNames() {
+        return TERMS_QUERY_METHOD;
+    }
+
+    @Override
+    protected SQLExpr defineFieldExpr(MethodInvocation invocation) {
+        return invocation.getParameter(0);
+    }
+
+    @Override
+    protected String defineExtraParamString(MethodInvocation invocation) {
+        String extraParamString = invocation.getLastParameterAsString();
+        if (isExtraParamsString(extraParamString)) {
+            return extraParamString;
+        }
+        return StringUtils.EMPTY;
+    }
+
+    @Override
+    protected void checkMethodInvokeArgs(MethodInvocation invocation) {
+        if (invocation.getParameterCount() <= 1) {
+            throw new ElasticSql2DslException(
+                    String.format("[syntax error] There's no %s args method named [%s].",
+                            invocation.getParameterCount(), invocation.getMethodName()));
+        }
+
+        int paramCount = invocation.getParameterCount();
+
+        for (int idx = 1; idx < paramCount - 1; idx++) {
+            String text = invocation.getParameterAsString(idx);
+            if (StringUtils.isEmpty(text)) {
+                throw new ElasticSql2DslException("[syntax error] Terms text can not be blank!");
+            }
+        }
+    }
+
+    @Override
+    protected FilterBuilder buildQuery(MethodInvocation invocation, String fieldName, Map<String, String> extraParams) {
+        int paramCount = invocation.getParameterCount();
+
+        List<String> termTextList = Lists.newArrayList();
+        for (int idx = 1; idx < paramCount - 1; idx++) {
+            String text = invocation.getParameterAsString(idx);
+            termTextList.add(text);
+        }
+
+        String lastParamText = invocation.getLastParameterAsString();
+        if (!isExtraParamsString(lastParamText)) {
+            termTextList.add(lastParamText);
+        }
+
+        return FilterBuilders.termsFilter(fieldName, termTextList);
+    }
+}

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

@@ -0,0 +1,178 @@
+package org.es.sql.dsl.parser.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.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.es.sql.dsl.bean.AtomFilter;
+import org.es.sql.dsl.bean.SQLCondition;
+import org.es.sql.dsl.enums.SQLBoolOperator;
+import org.es.sql.dsl.enums.SQLConditionType;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.parser.query.exact.BetweenAndAtomQueryParser;
+import org.es.sql.dsl.parser.query.exact.BinaryAtomQueryParser;
+import org.es.sql.dsl.parser.query.exact.InListAtomQueryParser;
+import org.es.sql.dsl.parser.query.method.MethodInvocation;
+import org.es.sql.dsl.parser.query.method.script.ScriptAtomQueryParser;
+import org.es.sql.dsl.parser.query.method.term.TermLevelAtomQueryParser;
+
+import java.util.List;
+
+public abstract class AbstractQueryConditionParser implements QueryParser {
+
+    private final BinaryAtomQueryParser binaryQueryParser;
+    private final InListAtomQueryParser inListQueryParser;
+    private final BetweenAndAtomQueryParser betweenAndQueryParser;
+
+    private final ScriptAtomQueryParser scriptAtomQueryParser;
+    private final TermLevelAtomQueryParser termLevelAtomQueryParser;
+
+    public AbstractQueryConditionParser(ParseActionListener parseActionListener) {
+        binaryQueryParser = new BinaryAtomQueryParser(parseActionListener);
+        inListQueryParser = new InListAtomQueryParser(parseActionListener);
+        betweenAndQueryParser = new BetweenAndAtomQueryParser(parseActionListener);
+
+        scriptAtomQueryParser = new ScriptAtomQueryParser();
+
+        termLevelAtomQueryParser = new TermLevelAtomQueryParser(parseActionListener);
+    }
+
+    protected BoolFilterBuilder 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.getFilterList(), 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<AtomFilter> mergedQueryList = Lists.newArrayList();
+                combineQueryBuilder(mergedQueryList, leftCondition, operator);
+                combineQueryBuilder(mergedQueryList, rightCondition, operator);
+
+                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;
+            }
+
+            BoolFilterBuilder boolQuery = mergeAtomQuery(innerSqlCondition.getFilterList(), operator);
+            boolQuery = FilterBuilders.boolFilter().mustNot(boolQuery);
+
+            return new SQLCondition(new AtomFilter(boolQuery), SQLConditionType.Atom);
+        }
+
+        return new SQLCondition(parseAtomQueryCondition(conditionExpr, queryAs, sqlArgs), SQLConditionType.Atom);
+    }
+
+    private AtomFilter parseAtomQueryCondition(SQLExpr sqlConditionExpr, String queryAs, Object[] sqlArgs) {
+        if (sqlConditionExpr instanceof SQLMethodInvokeExpr) {
+            SQLMethodInvokeExpr methodQueryExpr = (SQLMethodInvokeExpr) sqlConditionExpr;
+
+            MethodInvocation methodInvocation = new MethodInvocation(methodQueryExpr, queryAs, sqlArgs);
+
+            if (scriptAtomQueryParser.isMatchMethodInvocation(methodInvocation)) {
+                return scriptAtomQueryParser.parseAtomMethodQuery(methodInvocation);
+            }
+
+            if (termLevelAtomQueryParser.isTermLevelAtomQuery(methodInvocation)) {
+                return termLevelAtomQueryParser.parseTermLevelAtomQuery(methodQueryExpr, queryAs, sqlArgs);
+            }
+        }
+        else if (sqlConditionExpr instanceof SQLBinaryOpExpr) {
+            return binaryQueryParser.parseBinaryQuery((SQLBinaryOpExpr) sqlConditionExpr, queryAs, sqlArgs);
+        }
+        else if (sqlConditionExpr instanceof SQLInListExpr) {
+            return inListQueryParser.parseInListQuery((SQLInListExpr) sqlConditionExpr, queryAs, sqlArgs);
+        }
+        else if (sqlConditionExpr instanceof SQLBetweenExpr) {
+            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<AtomFilter> combiner, SQLCondition sqlCondition, SQLBoolOperator binOperator) {
+        if (SQLConditionType.Atom == sqlCondition.getSQLConditionType() || sqlCondition.getOperator() == binOperator) {
+            combiner.addAll(sqlCondition.getFilterList());
+        }
+        else {
+            BoolFilterBuilder boolQuery = mergeAtomQuery(sqlCondition.getFilterList(), sqlCondition.getOperator());
+            combiner.add(new AtomFilter(boolQuery));
+        }
+    }
+
+    private BoolFilterBuilder mergeAtomQuery(List<AtomFilter> atomQueryList, SQLBoolOperator operator) {
+        BoolFilterBuilder subBoolQuery = FilterBuilders.boolFilter();
+        ListMultimap<String, FilterBuilder> listMultiMap = ArrayListMultimap.create();
+
+        for (AtomFilter atomQuery : atomQueryList) {
+            if (Boolean.FALSE == atomQuery.getNestedFilter()) {
+                if (operator == SQLBoolOperator.AND) {
+                    subBoolQuery.must(atomQuery.getFilter());
+                }
+                if (operator == SQLBoolOperator.OR) {
+                    subBoolQuery.should(atomQuery.getFilter());
+                }
+            }
+            else {
+                String nestedDocPrefix = atomQuery.getNestedFilterPathContext();
+                listMultiMap.put(nestedDocPrefix, atomQuery.getFilter());
+            }
+        }
+
+        for (String nestedDocPrefix : listMultiMap.keySet()) {
+            List<FilterBuilder> nestedQueryList = listMultiMap.get(nestedDocPrefix);
+
+            if (nestedQueryList.size() == 1) {
+                if (operator == SQLBoolOperator.AND) {
+                    subBoolQuery.must(FilterBuilders.nestedFilter(nestedDocPrefix, nestedQueryList.get(0)));
+                }
+                if (operator == SQLBoolOperator.OR) {
+                    subBoolQuery.should(FilterBuilders.nestedFilter(nestedDocPrefix, nestedQueryList.get(0)));
+                }
+                continue;
+            }
+
+            BoolFilterBuilder boolNestedQuery = FilterBuilders.boolFilter();
+            for (FilterBuilder nestedQueryItem : nestedQueryList) {
+                if (operator == SQLBoolOperator.AND) {
+                    boolNestedQuery.must(nestedQueryItem);
+                }
+                if (operator == SQLBoolOperator.OR) {
+                    boolNestedQuery.should(nestedQueryItem);
+                }
+            }
+
+            if (operator == SQLBoolOperator.AND) {
+                subBoolQuery.must(FilterBuilders.nestedFilter(nestedDocPrefix, boolNestedQuery));
+            }
+            if (operator == SQLBoolOperator.OR) {
+                subBoolQuery.should(FilterBuilders.nestedFilter(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.es.sql.dsl.parser.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLAllColumnExpr;
@@ -7,11 +7,11 @@ import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
-import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
-import org.elasticsearch.dsl.bean.ElasticSqlQueryFields;
-import org.elasticsearch.dsl.bean.QueryFieldReferenceNode;
-import org.elasticsearch.dsl.bean.QueryFieldReferencePath;
-import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.bean.ElasticSqlQueryFields;
+import org.es.sql.dsl.bean.QueryFieldReferenceNode;
+import org.es.sql.dsl.bean.QueryFieldReferencePath;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
 
 import java.util.Collections;
 import java.util.Iterator;

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

@@ -1,14 +1,13 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.es.sql.dsl.parser.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;
+import org.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
 
 public class QueryFromParser implements QueryParser {
 

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

@@ -1,19 +1,18 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.es.sql.dsl.parser.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.statement.SQLSelectGroupByClause;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.dsl.bean.ElasticDslContext;
-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;
+import org.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.bean.RangeSegment;
+import org.es.sql.dsl.enums.QueryFieldType;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+import org.es.sql.dsl.helper.ElasticSqlMethodInvokeHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
 import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilders;
@@ -22,7 +21,7 @@ import org.elasticsearch.search.aggregations.bucket.range.RangeBuilder;
 import org.elasticsearch.search.aggregations.bucket.range.date.DateRangeBuilder;
 import org.elasticsearch.search.aggregations.bucket.terms.Terms;
 import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder;
-import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
 import org.joda.time.DateTime;
 import org.joda.time.format.DateTimeFormat;
 import org.joda.time.format.DateTimeFormatter;
@@ -58,7 +57,7 @@ public class QueryGroupByParser implements QueryParser {
                 SQLMethodInvokeExpr aggMethodExpr = (SQLMethodInvokeExpr) groupByItem;
 
                 //Terms Aggregation
-                if (ElasticSqlMethodInvokeHelper.AGG_TERMS_METHOD.equalsIgnoreCase(aggMethodExpr.getMethodName())) {
+                if (ElasticSqlMethodInvokeHelper.isMethodOf(ElasticSqlMethodInvokeHelper.AGG_TERMS_METHOD, aggMethodExpr.getMethodName())) {
                     ElasticSqlMethodInvokeHelper.checkTermsAggMethod(aggMethodExpr);
 
                     SQLExpr termsFieldExpr = aggMethodExpr.getParameters().get(0);
@@ -69,7 +68,7 @@ public class QueryGroupByParser implements QueryParser {
 
 
                 //Range Aggregation
-                if (ElasticSqlMethodInvokeHelper.AGG_RANGE_METHOD.equalsIgnoreCase(aggMethodExpr.getMethodName())) {
+                if (ElasticSqlMethodInvokeHelper.isMethodOf(ElasticSqlMethodInvokeHelper.AGG_RANGE_METHOD, aggMethodExpr.getMethodName())) {
                     ElasticSqlMethodInvokeHelper.checkRangeAggMethod(aggMethodExpr);
 
                     List<RangeSegment> rangeSegments = parseRangeSegments(aggMethodExpr, dslContext.getSqlArgs());

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

@@ -1,14 +1,13 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.es.sql.dsl.parser.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
-import org.elasticsearch.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;
+import org.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
 
 public class QueryLimitSizeParser implements QueryParser {
 

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.es.sql.dsl.parser.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLOrderBy;
@@ -10,20 +10,19 @@ import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
 import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.dsl.bean.ElasticDslContext;
-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;
+import org.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.enums.QueryFieldType;
+import org.es.sql.dsl.enums.SortOption;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+import org.es.sql.dsl.helper.ElasticSqlMethodInvokeHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
 import org.elasticsearch.search.sort.FieldSortBuilder;
 import org.elasticsearch.search.sort.SortBuilder;
 import org.elasticsearch.search.sort.SortBuilders;
 import org.elasticsearch.search.sort.SortOrder;
-import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
 
@@ -67,7 +66,7 @@ public class QueryOrderConditionParser implements QueryParser {
         if (orderByItem.getExpr() instanceof SQLMethodInvokeExpr) {
             SQLMethodInvokeExpr methodInvokeExpr = (SQLMethodInvokeExpr) orderByItem.getExpr();
             //nvl method
-            if (ElasticSqlMethodInvokeHelper.NVL_METHOD.equalsIgnoreCase(methodInvokeExpr.getMethodName())) {
+            if (ElasticSqlMethodInvokeHelper.isMethodOf(ElasticSqlMethodInvokeHelper.NVL_METHOD, methodInvokeExpr.getMethodName())) {
                 ElasticSqlMethodInvokeHelper.checkNvlMethod(methodInvokeExpr);
                 Object valueArg = ElasticSqlArgTransferHelper.transferSqlArg(methodInvokeExpr.getParameters().get(1), sqlArgs);
                 return parseCondition(methodInvokeExpr.getParameters().get(0), queryAs, new ConditionSortBuilder() {

src/main/java/org/es/sql/dsl/parser/sql/QueryParser.java

@@ -0,0 +1,7 @@
+package org.es.sql.dsl.parser.sql;
+
+import org.es.sql.dsl.bean.ElasticDslContext;
+
+public interface QueryParser {
+    void parse(ElasticDslContext dslContext);
+}

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

@@ -1,16 +1,15 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.es.sql.dsl.parser.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.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;
+import org.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.helper.ElasticSqlArgTransferHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
 

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

@@ -1,21 +1,20 @@
-package org.elasticsearch.dsl.parser.syntax;
+package org.es.sql.dsl.parser.sql;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr;
 import com.alibaba.druid.sql.ast.statement.SQLSelectItem;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.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.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.bean.ElasticSqlQueryField;
+import org.es.sql.dsl.enums.QueryFieldType;
+import org.es.sql.dsl.exception.ElasticSql2DslException;
+import org.es.sql.dsl.helper.ElasticSqlMethodInvokeHelper;
+import org.es.sql.dsl.listener.ParseActionListener;
 import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilders;
-import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
 

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

@@ -0,0 +1,26 @@
+package org.es.sql.dsl.parser.sql;
+
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.es.sql.druid.ElasticSqlSelectQueryBlock;
+import org.es.sql.dsl.bean.ElasticDslContext;
+import org.es.sql.dsl.listener.ParseActionListener;
+
+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();
+
+            BoolFilterBuilder whereQuery = parseQueryConditionExpr(queryBlock.getWhere(), queryAs, dslContext.getSqlArgs());
+
+            dslContext.getParseResult().setWhereCondition(whereQuery);
+        }
+    }
+}

src/main/java/org/es/sql/util/Constants.java

@@ -0,0 +1,7 @@
+package org.es.sql.util;
+
+public class Constants {
+    public static final String COMMA = ",";
+    public static final String COLON = ":";
+    public static final String DEFAULT_ES_DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
+}

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.util;
+package org.es.sql.util;
 
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.action.*;

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

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

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

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

src/test/java/org/es/SqlParserMethodConditionTest.java

@@ -0,0 +1,21 @@
+package org.es;
+
+import org.es.sql.dsl.bean.ElasticSqlParseResult;
+import org.es.sql.dsl.parser.ElasticSql2DslParser;
+import org.junit.Test;
+
+
+public class SqlParserMethodConditionTest {
+    @Test
+    public void testScriptExpr() {
+
+        String script = "if(doc[\"advicePrice\"].empty) return false; if(my_var * doc[\"minPrice\"].value/doc[\"advicePrice\"].value > 0.363) return true; else return false;";
+        String sql = String.format("select * from index.product where script_query('%s', 'my_var:2.1f')", script);
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+
+        System.out.println(parseResult.toDsl());
+
+    }
+}

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

@@ -1,12 +1,12 @@
-package org.elasticsearch;
+package org.es;
 
 import org.elasticsearch.action.search.SearchRequestBuilder;
-import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.es.sql.dsl.bean.ElasticSqlParseResult;
+import org.es.sql.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.es.sql.util.ElasticMockClient;
 import org.junit.Assert;
 import org.junit.Test;
 

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

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

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

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

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

@@ -1,8 +1,8 @@
-package org.elasticsearch;
+package org.es;
 
 import org.elasticsearch.action.search.SearchRequestBuilder;
-import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
-import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
+import org.es.sql.dsl.parser.ElasticSql2DslParser;
+import org.es.sql.dsl.bean.ElasticSqlParseResult;
 import org.elasticsearch.index.query.FilterBuilder;
 import org.elasticsearch.index.query.FilterBuilders;
 import org.elasticsearch.index.query.NestedFilterBuilder;
@@ -10,7 +10,7 @@ import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
 import org.elasticsearch.search.aggregations.AggregationBuilders;
 import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder;
-import org.elasticsearch.util.ElasticMockClient;
+import org.es.sql.util.ElasticMockClient;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -109,7 +109,7 @@ public class SqlParserWhereConditionTest {
         Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
 
-        sql = "select id,status from index.order t where t.lastUpdateTime between date('yyyy/MM/dd hh-mm', '2017/01/25 13-32') and '2018-10-25'";
+        sql = "select id,status from index.order t where t.lastUpdateTime between to_date('yyyy/MM/dd hh-mm', '2017/01/25 13-32') and '2018-10-25'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(
                 FilterBuilders.rangeFilter("lastUpdateTime")