x

src/main/java/org/elasticsearch/dsl/ElasticSqlIdentifier.java

@@ -1,41 +0,0 @@
-package org.elasticsearch.dsl;
-
-public class ElasticSqlIdentifier {
-
-    private String pathName;
-    private String propertyName;
-    private IdentifierType identifierType;
-
-    public ElasticSqlIdentifier(String propertyName) {
-        this.propertyName = propertyName;
-        this.identifierType = IdentifierType.Property;
-    }
-
-    public ElasticSqlIdentifier(String pathName, String propertyName, IdentifierType identifierType) {
-        if (identifierType != IdentifierType.InnerDocProperty && identifierType != IdentifierType.NestedDocProperty && identifierType != IdentifierType.MatchAllField) {
-            throw new IllegalArgumentException("identifierType must one of [InnerDocProperty, NestedDocProperty]");
-        }
-        this.pathName = pathName;
-        this.propertyName = propertyName;
-        this.identifierType = identifierType;
-    }
-
-    public String getPathName() {
-        return pathName;
-    }
-
-    public String getPropertyName() {
-        return propertyName;
-    }
-
-    public IdentifierType getIdentifierType() {
-        return identifierType;
-    }
-
-    public static enum IdentifierType {
-        MatchAllField,
-        Property,
-        InnerDocProperty,
-        NestedDocProperty,
-    }
-}

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

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

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

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

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl;
+package org.elasticsearch.dsl.bean;
 
 import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang.StringUtils;

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

@@ -0,0 +1,37 @@
+package org.elasticsearch.dsl.bean;
+
+import org.elasticsearch.dsl.enums.QueryFieldType;
+
+public class ElasticSqlQueryField {
+    /*[内嵌文档]的上下文路径*/
+    private String nestedDocContextPath;
+    /*字段名(不包含前缀)*/
+    private String simpleQueryFieldName;
+    /*字段名(包含全限定名)*/
+    private String queryFieldFullName;
+    /*字段类型*/
+    private QueryFieldType queryFieldType;
+
+    public ElasticSqlQueryField(String nestedDocContextPath, String simpleQueryFieldName, String queryFieldFullName, QueryFieldType queryFieldType) {
+        this.nestedDocContextPath = nestedDocContextPath;
+        this.simpleQueryFieldName = simpleQueryFieldName;
+        this.queryFieldFullName = queryFieldFullName;
+        this.queryFieldType = queryFieldType;
+    }
+
+    public String getNestedDocContextPath() {
+        return nestedDocContextPath;
+    }
+
+    public String getSimpleQueryFieldName() {
+        return simpleQueryFieldName;
+    }
+
+    public String getQueryFieldFullName() {
+        return queryFieldFullName;
+    }
+
+    public QueryFieldType getQueryFieldType() {
+        return queryFieldType;
+    }
+}

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

@@ -0,0 +1,31 @@
+package org.elasticsearch.dsl.bean;
+
+import org.elasticsearch.dsl.enums.QueryFieldType;
+
+public class ElasticSqlQueryFields {
+    private ElasticSqlQueryFields() {
+        // private constructor
+    }
+
+    public static ElasticSqlQueryField newMatchAllField(String prefixPath) {
+        String matchAllField = String.format("%s.%s", prefixPath, "*");
+        return new ElasticSqlQueryField(null, matchAllField, matchAllField, QueryFieldType.MatchAllField);
+    }
+
+    public static ElasticSqlQueryField newRootDocQueryField(String rootDocFieldName) {
+        return new ElasticSqlQueryField(null, rootDocFieldName, rootDocFieldName, QueryFieldType.RootDocField);
+    }
+
+    public static ElasticSqlQueryField newInnerDocQueryField(String innerDocQueryFieldFullName) {
+        return new ElasticSqlQueryField(null, innerDocQueryFieldFullName, innerDocQueryFieldFullName, QueryFieldType.InnerDocField);
+    }
+
+    public static ElasticSqlQueryField newInnerDocQueryField(String innerDocFieldPrefix, String innerDocFieldName) {
+        String innerDocQueryFieldFullName = String.format("%s.%s", innerDocFieldPrefix, innerDocFieldName);
+        return newInnerDocQueryField(innerDocQueryFieldFullName);
+    }
+
+    public static ElasticSqlQueryField newNestedDocQueryField(String nestedDocContextPath, String simpleQueryFieldName) {
+        return new ElasticSqlQueryField(nestedDocContextPath, simpleQueryFieldName, String.format("%s.%s", nestedDocContextPath, simpleQueryFieldName), QueryFieldType.NestedDocField);
+    }
+}

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

@@ -0,0 +1,39 @@
+package org.elasticsearch.dsl.bean;
+
+import com.alibaba.druid.sql.ast.expr.SQLBinaryOperator;
+import com.google.common.collect.Lists;
+import org.elasticsearch.index.query.FilterBuilder;
+
+import java.util.List;
+
+public class SqlCondition {
+    //是否AND/OR运算
+    private boolean isAndOr = false;
+    //运算符
+    private SQLBinaryOperator operator;
+    //条件集合
+    private List<FilterBuilder> filterList;
+
+    public SqlCondition(FilterBuilder atomFilter) {
+        filterList = Lists.newArrayList(atomFilter);
+        isAndOr = false;
+    }
+
+    public SqlCondition(List<FilterBuilder> filterList, SQLBinaryOperator operator) {
+        this.filterList = filterList;
+        isAndOr = true;
+        this.operator = operator;
+    }
+
+    public boolean isAndOr() {
+        return isAndOr;
+    }
+
+    public SQLBinaryOperator getOperator() {
+        return operator;
+    }
+
+    public List<FilterBuilder> getFilterList() {
+        return filterList;
+    }
+}

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

@@ -0,0 +1,8 @@
+package org.elasticsearch.dsl.enums;
+
+public enum QueryFieldType {
+    MatchAllField,
+    RootDocField,
+    InnerDocField,
+    NestedDocField,
+}

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl;
+package org.elasticsearch.dsl.parser;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
@@ -6,7 +6,11 @@ import com.alibaba.druid.sql.parser.ParserException;
 import com.alibaba.druid.sql.parser.Token;
 import com.google.common.collect.ImmutableList;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.*;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
+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;
 
@@ -60,7 +64,7 @@ public class ElasticSql2DslParser {
         }
 
         if (!(sqlQueryExpr instanceof SQLQueryExpr)) {
-            throw new ElasticSql2DslException("[syntax error] Sql is not select sql");
+            throw new ElasticSql2DslException("[syntax error] Sql is not select syntax");
         }
 
         if (sqlArgs != null && sqlArgs.length > 0) {

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

@@ -1,6 +1,6 @@
 package org.elasticsearch.dsl.parser;
 
-import org.elasticsearch.dsl.ElasticDslContext;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
 
 @FunctionalInterface
 public interface QueryParser {

src/main/java/org/elasticsearch/dsl/ElasticSqlParseUtil.java

@@ -1,14 +1,12 @@
-package org.elasticsearch.dsl;
+package org.elasticsearch.dsl.parser.helper;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.*;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.helper.ElasticSqlDateParseHelper;
-import org.elasticsearch.dsl.parser.helper.ElasticSqlMethodInvokeHelper;
 
 import java.util.List;
 
-public class ElasticSqlParseUtil {
+public class ElasticSqlArgTransferHelper {
 
     public static Object[] transferSqlArgs(List<SQLExpr> exprList, Object[] sqlArgs) {
         Object[] values = new Object[exprList.size()];
@@ -53,23 +51,11 @@ public class ElasticSqlParseUtil {
             //解析date函数
             if (ElasticSqlDateParseHelper.isDateMethod(methodExpr)) {
                 ElasticSqlMethodInvokeHelper.checkDateMethod(methodExpr);
-                String patternArg = (String) ElasticSqlParseUtil.transferSqlArg(methodExpr.getParameters().get(0), sqlArgs);
-                String timeValArg = (String) ElasticSqlParseUtil.transferSqlArg(methodExpr.getParameters().get(1), sqlArgs);
+                String patternArg = (String) ElasticSqlArgTransferHelper.transferSqlArg(methodExpr.getParameters().get(0), sqlArgs);
+                String timeValArg = (String) ElasticSqlArgTransferHelper.transferSqlArg(methodExpr.getParameters().get(1), sqlArgs);
                 return ElasticSqlDateParseHelper.formatDefaultEsDate(patternArg, timeValArg);
             }
         }
         throw new ElasticSql2DslException("[syntax error] Can not support arg type: " + expr.toString());
     }
-
-    public static boolean isValidBinOperator(SQLBinaryOperator binaryOperator) {
-        return binaryOperator == SQLBinaryOperator.Equality
-                || binaryOperator == SQLBinaryOperator.NotEqual
-                || binaryOperator == SQLBinaryOperator.LessThanOrGreater
-                || binaryOperator == SQLBinaryOperator.GreaterThan
-                || binaryOperator == SQLBinaryOperator.GreaterThanOrEqual
-                || binaryOperator == SQLBinaryOperator.LessThan
-                || binaryOperator == SQLBinaryOperator.LessThanOrEqual
-                || binaryOperator == SQLBinaryOperator.Is
-                || binaryOperator == SQLBinaryOperator.IsNot;
-    }
 }

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

@@ -8,67 +8,77 @@ 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.ElasticSqlIdentifier;
+import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
+import org.elasticsearch.dsl.bean.ElasticSqlQueryFields;
+import org.elasticsearch.dsl.enums.QueryFieldType;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 
 import java.util.List;
 
 public class ElasticSqlIdentifierHelper {
 
+    public static ElasticSqlQueryField parseSqlQueryField(SQLExpr queryFieldExpr, String queryAs,
+                                                          SQLFlatFieldFunc flatFieldFunc, SQLNestedFieldFunc nestedFieldFunc) {
+
+        return null;
+    }
+
     /**
      * 字段标识符处理
      *
-     * @param propertyNameExpr   待处理字段表达式
-     * @param queryAsAlias       文档类型别名
-     * @param singlePropertyFunc 非内嵌类型处理策略(inner/property)
-     * @param pathPropertyFunc   内嵌类型处理逻辑(nested)
+     * @param propertyNameExpr 待处理字段表达式
+     * @param queryAsAlias     文档类型别名
+     * @param flatFieldFunc    非内嵌类型处理策略(inner/property)
+     * @param nestedFieldFunc  内嵌类型处理逻辑(nested)
      * @return 标识符类型
      */
-    public static ElasticSqlIdentifier parseSqlIdentifier(final SQLExpr propertyNameExpr, final String queryAsAlias,
-                                                          final ElasticSqlSinglePropertyFunc singlePropertyFunc,
-                                                          final ElasticSqlPathPropertyFunc pathPropertyFunc) {
-        final StringBuilder propertyPathBuilder = new StringBuilder();
-        final StringBuilder propertyNameBuilder = new StringBuilder();
+    public static ElasticSqlQueryField parseSqlIdentifier(SQLExpr propertyNameExpr, String queryAsAlias,
+                                                          SQLFlatFieldFunc flatFieldFunc,
+                                                          SQLNestedFieldFunc nestedFieldFunc) {
+        StringBuilder propertyPathBuilder = new StringBuilder();
+        StringBuilder propertyNameBuilder = new StringBuilder();
         if (propertyNameExpr instanceof SQLMethodInvokeExpr) {
             //如果指定是inner doc类型
             SQLMethodInvokeExpr innerObjExpr = (SQLMethodInvokeExpr) propertyNameExpr;
             if (ElasticSqlMethodInvokeHelper.INNER_DOC_METHOD.equalsIgnoreCase(innerObjExpr.getMethodName())) {
                 ElasticSqlMethodInvokeHelper.checkInnerDocMethod(innerObjExpr);
 
-                ElasticSqlIdentifierHelper.parseSqlIdf(innerObjExpr.getParameters().get(0), queryAsAlias, new ElasticSqlSinglePropertyFunc() {
+                ElasticSqlIdentifierHelper.parseSqlIdf(innerObjExpr.getParameters().get(0), queryAsAlias, new SQLFlatFieldFunc() {
                     @Override
-                    public void parse(String propertyName) {
+                    public void parse(String flatFieldName) {
                         throw new ElasticSql2DslException("[syntax error] The arg of method inner_doc must contain property reference path");
                     }
-                }, new ElasticSqlPathPropertyFunc() {
+                }, new SQLNestedFieldFunc() {
                     @Override
-                    public void parse(String propertyPath, String propertyName) {
-                        propertyPathBuilder.append(propertyPath);
-                        propertyNameBuilder.append(propertyName);
-                        singlePropertyFunc.parse(String.format("%s.%s", propertyPath, propertyName));
+                    public void parse(String nestedDocPath, String fieldName) {
+                        propertyPathBuilder.append(nestedDocPath);
+                        propertyNameBuilder.append(fieldName);
+                        flatFieldFunc.parse(String.format("%s.%s", nestedDocPath, fieldName));
                     }
                 });
-                return new ElasticSqlIdentifier(propertyPathBuilder.toString(), propertyNameBuilder.toString(), ElasticSqlIdentifier.IdentifierType.InnerDocProperty);
+                //return new ElasticSqlQueryField(propertyPathBuilder.toString(), propertyNameBuilder.toString(), QueryFieldType.InnerDocField);
+                return ElasticSqlQueryFields.newInnerDocQueryField(propertyPathBuilder.toString(), propertyNameBuilder.toString());
             }
 
             //如果执行是nested doc类型
             if (ElasticSqlMethodInvokeHelper.NESTED_DOC_METHOD.equalsIgnoreCase(innerObjExpr.getMethodName())) {
                 ElasticSqlMethodInvokeHelper.checkNestedDocMethod(innerObjExpr);
 
-                ElasticSqlIdentifierHelper.parseSqlIdf(innerObjExpr.getParameters().get(0), queryAsAlias, new ElasticSqlSinglePropertyFunc() {
+                ElasticSqlIdentifierHelper.parseSqlIdf(innerObjExpr.getParameters().get(0), queryAsAlias, new SQLFlatFieldFunc() {
                     @Override
-                    public void parse(String propertyName) {
+                    public void parse(String flatFieldName) {
                         throw new ElasticSql2DslException("[syntax error] The arg of method nested_doc must contain property reference path");
                     }
-                }, new ElasticSqlPathPropertyFunc() {
+                }, new SQLNestedFieldFunc() {
                     @Override
-                    public void parse(String propertyPath, String propertyName) {
-                        propertyPathBuilder.append(propertyPath);
-                        propertyNameBuilder.append(propertyName);
-                        pathPropertyFunc.parse(propertyPath, propertyName);
+                    public void parse(String nestedDocPath, String fieldName) {
+                        propertyPathBuilder.append(nestedDocPath);
+                        propertyNameBuilder.append(fieldName);
+                        nestedFieldFunc.parse(nestedDocPath, fieldName);
                     }
                 });
-                return new ElasticSqlIdentifier(propertyPathBuilder.toString(), propertyNameBuilder.toString(), ElasticSqlIdentifier.IdentifierType.NestedDocProperty);
+                //return new ElasticSqlQueryField(propertyPathBuilder.toString(), propertyNameBuilder.toString(), QueryFieldType.NestedDocField);
+                return ElasticSqlQueryFields.newNestedDocQueryField(propertyPathBuilder.toString(), propertyNameBuilder.toString());
             }
 
             throw new ElasticSql2DslException("[syntax error] Sql identifier method only support nested_doc and inner_doc");
@@ -76,33 +86,36 @@ public class ElasticSqlIdentifierHelper {
 
         //默认按照inner doc或者property name来处理
         final List<Boolean> isInnerDocProperty = Lists.newLinkedList();
-        ElasticSqlIdentifierHelper.parseSqlIdf(propertyNameExpr, queryAsAlias, new ElasticSqlSinglePropertyFunc() {
+        ElasticSqlIdentifierHelper.parseSqlIdf(propertyNameExpr, queryAsAlias, new SQLFlatFieldFunc() {
             @Override
-            public void parse(String propertyName) {
+            public void parse(String flatFieldName) {
                 isInnerDocProperty.add(Boolean.FALSE);
-                propertyNameBuilder.append(propertyName);
-                singlePropertyFunc.parse(propertyName);
+                propertyNameBuilder.append(flatFieldName);
+                flatFieldFunc.parse(flatFieldName);
             }
-        }, new ElasticSqlPathPropertyFunc() {
+        }, new SQLNestedFieldFunc() {
             @Override
-            public void parse(String propertyPath, String propertyName) {
+            public void parse(String nestedDocPath, String fieldName) {
                 isInnerDocProperty.add(Boolean.TRUE);
-                propertyPathBuilder.append(propertyPath);
-                propertyNameBuilder.append(propertyName);
-                singlePropertyFunc.parse(String.format("%s.%s", propertyPath, propertyName));
+                propertyPathBuilder.append(nestedDocPath);
+                propertyNameBuilder.append(fieldName);
+                flatFieldFunc.parse(String.format("%s.%s", nestedDocPath, fieldName));
             }
         });
         if (CollectionUtils.isNotEmpty(isInnerDocProperty)) {
             if (isInnerDocProperty.get(0)) {
-                return new ElasticSqlIdentifier(propertyPathBuilder.toString(), propertyNameBuilder.toString(), ElasticSqlIdentifier.IdentifierType.InnerDocProperty);
+                //return new ElasticSqlQueryField(propertyPathBuilder.toString(), propertyNameBuilder.toString(), QueryFieldType.InnerDocField);
+                return ElasticSqlQueryFields.newInnerDocQueryField(propertyPathBuilder.toString(), propertyNameBuilder.toString());
             }
-            return new ElasticSqlIdentifier(propertyNameBuilder.toString());
+            //return new ElasticSqlQueryField(propertyNameBuilder.toString());
+            return ElasticSqlQueryFields.newRootDocQueryField(propertyNameBuilder.toString());
         }
-        return new ElasticSqlIdentifier(propertyPathBuilder.toString(), propertyNameBuilder.toString(), ElasticSqlIdentifier.IdentifierType.MatchAllField);
+        //return new ElasticSqlQueryField(propertyPathBuilder.toString(), propertyNameBuilder.toString(), QueryFieldType.MatchAllField);
+        return ElasticSqlQueryFields.newMatchAllField(propertyPathBuilder.toString());
     }
 
     private static void parseSqlIdf(final SQLExpr propertyNameExpr, final String queryAsAlias,
-                                    final ElasticSqlSinglePropertyFunc singlePropertyFunc, final ElasticSqlPathPropertyFunc pathPropertyFunc) {
+                                    final SQLFlatFieldFunc singlePropertyFunc, final SQLNestedFieldFunc pathPropertyFunc) {
         //查询所有字段
         if (propertyNameExpr instanceof SQLAllColumnExpr) {
             return;
@@ -141,13 +154,13 @@ public class ElasticSqlIdentifierHelper {
 
 
     @FunctionalInterface
-    public interface ElasticSqlSinglePropertyFunc {
-        void parse(String propertyName);
+    public interface SQLFlatFieldFunc {
+        void parse(String flatFieldName);
     }
 
     @FunctionalInterface
-    public interface ElasticSqlPathPropertyFunc {
-        void parse(String propertyPath, String propertyName);
+    public interface SQLNestedFieldFunc {
+        void parse(String nestedDocPath, String fieldName);
     }
 
 }

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

@@ -4,7 +4,7 @@ import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.*;
 import org.apache.commons.collections.CollectionUtils;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
-import org.elasticsearch.dsl.parser.QueryOrderConditionParser;
+import org.elasticsearch.dsl.parser.syntax.QueryOrderConditionParser;
 
 public class ElasticSqlMethodInvokeHelper {
 

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

@@ -0,0 +1,13 @@
+package org.elasticsearch.dsl.parser.listener;
+
+import org.elasticsearch.dsl.enums.SQLConditionOperator;
+import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
+
+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/ParseActionListenerAdapter.java

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

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

@@ -1,10 +1,11 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax;
 
 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 org.elasticsearch.dsl.ElasticDslContext;
-import org.elasticsearch.dsl.ParseActionListener;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.parser.QueryParser;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
 

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

@@ -1,11 +1,12 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
-import org.elasticsearch.dsl.ElasticDslContext;
-import org.elasticsearch.dsl.ElasticSqlParseUtil;
-import org.elasticsearch.dsl.ParseActionListener;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.parser.QueryParser;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
 
@@ -37,7 +38,7 @@ public class QueryLimitSizeParser implements QueryParser {
             return ((SQLIntegerExpr) limitInt).getNumber().intValue();
         } else if (limitInt instanceof SQLVariantRefExpr) {
             SQLVariantRefExpr varLimitExpr = (SQLVariantRefExpr) limitInt;
-            final Object targetVal = ElasticSqlParseUtil.transferSqlArg(varLimitExpr, args);
+            final Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(varLimitExpr, args);
             if (!(targetVal instanceof Integer)) {
                 throw new ElasticSql2DslException("[syntax error] Sql limit expr should be a non-negative number");
             }

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

@@ -1,4 +1,4 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLOrderBy;
@@ -10,9 +10,10 @@ 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.ElasticDslContext;
-import org.elasticsearch.dsl.ElasticSqlParseUtil;
-import org.elasticsearch.dsl.ParseActionListener;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.parser.QueryParser;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlIdentifierHelper;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlMethodInvokeHelper;
@@ -66,7 +67,7 @@ public class QueryOrderConditionParser implements QueryParser {
             //nvl method
             if (ElasticSqlMethodInvokeHelper.NVL_METHOD.equalsIgnoreCase(methodInvokeExpr.getMethodName())) {
                 ElasticSqlMethodInvokeHelper.checkNvlMethod(methodInvokeExpr);
-                final Object valueArg = ElasticSqlParseUtil.transferSqlArg(methodInvokeExpr.getParameters().get(1), sqlArgs);
+                final Object valueArg = ElasticSqlArgTransferHelper.transferSqlArg(methodInvokeExpr.getParameters().get(1), sqlArgs);
                 return parseCondition(methodInvokeExpr.getParameters().get(0), queryAs, new ConditionSortBuilder() {
                     @Override
                     public FieldSortBuilder buildSort(String idfName) {
@@ -104,17 +105,17 @@ public class QueryOrderConditionParser implements QueryParser {
 
     private SortBuilder parseCondition(SQLExpr sqlExpr, String queryAs, final ConditionSortBuilder sortBuilder) {
         final List<SortBuilder> tmpSortList = Lists.newLinkedList();
-        ElasticSqlIdentifierHelper.parseSqlIdentifier(sqlExpr, queryAs, new ElasticSqlIdentifierHelper.ElasticSqlSinglePropertyFunc() {
+        ElasticSqlIdentifierHelper.parseSqlIdentifier(sqlExpr, queryAs, new ElasticSqlIdentifierHelper.SQLFlatFieldFunc() {
             @Override
-            public void parse(String propertyName) {
-                FieldSortBuilder originalSort = sortBuilder.buildSort(propertyName);
+            public void parse(String flatFieldName) {
+                FieldSortBuilder originalSort = sortBuilder.buildSort(flatFieldName);
                 tmpSortList.add(originalSort);
             }
-        }, new ElasticSqlIdentifierHelper.ElasticSqlPathPropertyFunc() {
+        }, new ElasticSqlIdentifierHelper.SQLNestedFieldFunc() {
             @Override
-            public void parse(String propertyPath, String propertyName) {
-                FieldSortBuilder originalSort = sortBuilder.buildSort(propertyName);
-                originalSort.setNestedPath(propertyPath);
+            public void parse(String nestedDocPath, String fieldName) {
+                FieldSortBuilder originalSort = sortBuilder.buildSort(fieldName);
+                originalSort.setNestedPath(nestedDocPath);
                 tmpSortList.add(originalSort);
             }
         });

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

@@ -1,13 +1,14 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.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.ElasticDslContext;
-import org.elasticsearch.dsl.ElasticSqlParseUtil;
-import org.elasticsearch.dsl.ParseActionListener;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.parser.QueryParser;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
 
@@ -30,7 +31,7 @@ public class QueryRoutingValParser implements QueryParser {
                 if (routingVal instanceof SQLCharExpr) {
                     routingStringValues.add(((SQLCharExpr) routingVal).getText());
                 } else if (routingVal instanceof SQLVariantRefExpr) {
-                    Object targetVal = ElasticSqlParseUtil.transferSqlArg(routingVal, dslContext.getSqlArgs());
+                    Object targetVal = ElasticSqlArgTransferHelper.transferSqlArg(routingVal, dslContext.getSqlArgs());
                     if (!(targetVal instanceof String)) {
                         throw new ElasticSql2DslException("[syntax error] Index routing val must be a string");
                     }

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

@@ -1,10 +1,11 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax;
 
 import com.alibaba.druid.sql.ast.statement.SQLSelectItem;
 import com.google.common.collect.Lists;
-import org.elasticsearch.dsl.ElasticDslContext;
-import org.elasticsearch.dsl.ElasticSqlIdentifier;
-import org.elasticsearch.dsl.ParseActionListener;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
+import org.elasticsearch.dsl.parser.QueryParser;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlIdentifierHelper;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
 
@@ -26,17 +27,17 @@ public class QuerySelectFieldListParser implements QueryParser {
 
         final List<String> selectFields = Lists.newLinkedList();
         for (SQLSelectItem selectField : queryBlock.getSelectList()) {
-            ElasticSqlIdentifier sqlIdentifier = ElasticSqlIdentifierHelper.parseSqlIdentifier(selectField.getExpr(), dslContext.getParseResult().getQueryAs(), new ElasticSqlIdentifierHelper.ElasticSqlSinglePropertyFunc() {
+            ElasticSqlQueryField sqlIdentifier = ElasticSqlIdentifierHelper.parseSqlIdentifier(selectField.getExpr(), dslContext.getParseResult().getQueryAs(), new ElasticSqlIdentifierHelper.SQLFlatFieldFunc() {
                 @Override
-                public void parse(String propertyName) {
-                    if (!SQL_FIELD_MATCH_ALL.equals(propertyName)) {
-                        selectFields.add(propertyName);
+                public void parse(String flatFieldName) {
+                    if (!SQL_FIELD_MATCH_ALL.equals(flatFieldName)) {
+                        selectFields.add(flatFieldName);
                     }
                 }
-            }, new ElasticSqlIdentifierHelper.ElasticSqlPathPropertyFunc() {
+            }, new ElasticSqlIdentifierHelper.SQLNestedFieldFunc() {
                 @Override
-                public void parse(String propertyPath, String propertyName) {
-                    selectFields.add(String.format("%s.%s", propertyPath, propertyName));
+                public void parse(String nestedDocPath, String fieldName) {
+                    selectFields.add(String.format("%s.%s", nestedDocPath, fieldName));
                 }
             });
             onSelectFieldParse(sqlIdentifier);
@@ -44,7 +45,7 @@ public class QuerySelectFieldListParser implements QueryParser {
         dslContext.getParseResult().setQueryFieldList(selectFields);
     }
 
-    private void onSelectFieldParse(ElasticSqlIdentifier field) {
+    private void onSelectFieldParse(ElasticSqlQueryField field) {
         try {
             parseActionListener.onSelectFieldParse(field);
         } catch (Exception ex) {

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

@@ -1,16 +1,18 @@
-package org.elasticsearch.dsl.parser;
+package org.elasticsearch.dsl.parser.syntax;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.expr.*;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.dsl.ElasticDslContext;
-import org.elasticsearch.dsl.ElasticSqlIdentifier;
-import org.elasticsearch.dsl.ElasticSqlParseUtil;
-import org.elasticsearch.dsl.ParseActionListener;
+import org.elasticsearch.dsl.bean.ElasticDslContext;
+import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
+import org.elasticsearch.dsl.bean.SqlCondition;
 import org.elasticsearch.dsl.enums.SQLConditionOperator;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.dsl.parser.QueryParser;
 import org.elasticsearch.dsl.parser.helper.ElasticSqlIdentifierHelper;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.helper.ElasticSqlArgTransferHelper;
 import org.elasticsearch.index.query.BoolFilterBuilder;
 import org.elasticsearch.index.query.FilterBuilder;
 import org.elasticsearch.index.query.FilterBuilders;
@@ -59,7 +61,7 @@ public class QueryWhereConditionParser implements QueryParser {
 
                 List<FilterBuilder> curFilterList = Lists.newArrayList();
 
-                if (!leftCondition.isAndOr() || leftCondition.operator == binaryOperator) {
+                if (!leftCondition.isAndOr() || leftCondition.getOperator() == binaryOperator) {
                     curFilterList.addAll(leftCondition.getFilterList());
                 } else {
                     final BoolFilterBuilder subBoolFilter = FilterBuilders.boolFilter();
@@ -77,7 +79,7 @@ public class QueryWhereConditionParser implements QueryParser {
                     curFilterList.add(subBoolFilter);
                 }
 
-                if (!rightCondition.isAndOr() || rightCondition.operator == binaryOperator) {
+                if (!rightCondition.isAndOr() || rightCondition.getOperator() == binaryOperator) {
                     curFilterList.addAll(rightCondition.getFilterList());
                 } else {
                     final BoolFilterBuilder subBoolFilter = FilterBuilders.boolFilter();
@@ -105,10 +107,10 @@ public class QueryWhereConditionParser implements QueryParser {
             SQLBinaryOpExpr sqlBinOpExpr = (SQLBinaryOpExpr) sqlExpr;
             final SQLBinaryOperator binaryOperator = sqlBinOpExpr.getOperator();
 
-            if (ElasticSqlParseUtil.isValidBinOperator(binaryOperator)) {
+            if (isValidBinOperator(binaryOperator)) {
                 //EQ NEQ
                 if (SQLBinaryOperator.Equality == binaryOperator || SQLBinaryOperator.LessThanOrGreater == binaryOperator || SQLBinaryOperator.NotEqual == binaryOperator) {
-                    Object targetVal = ElasticSqlParseUtil.transferSqlArg(sqlBinOpExpr.getRight(), dslContext.getSqlArgs());
+                    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() {
@@ -139,7 +141,7 @@ public class QueryWhereConditionParser implements QueryParser {
                         operator = SQLConditionOperator.LessThanOrEqual;
                     }
 
-                    Object targetVal = ElasticSqlParseUtil.transferSqlArg(sqlBinOpExpr.getRight(), dslContext.getSqlArgs());
+                    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) {
@@ -181,7 +183,7 @@ public class QueryWhereConditionParser implements QueryParser {
             if (CollectionUtils.isEmpty(inListExpr.getTargetList())) {
                 throw new ElasticSql2DslException("[syntax error] In list expr target list cannot be blank");
             }
-            Object[] targetInList = ElasticSqlParseUtil.transferSqlArgs(inListExpr.getTargetList(), dslContext.getSqlArgs());
+            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
@@ -196,8 +198,8 @@ public class QueryWhereConditionParser implements QueryParser {
         } else if (sqlExpr instanceof SQLBetweenExpr) {
             SQLBetweenExpr betweenExpr = (SQLBetweenExpr) sqlExpr;
 
-            Object from = ElasticSqlParseUtil.transferSqlArg(betweenExpr.getBeginExpr(), dslContext.getSqlArgs());
-            Object to = ElasticSqlParseUtil.transferSqlArg(betweenExpr.getEndExpr(), dslContext.getSqlArgs());
+            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");
@@ -217,17 +219,17 @@ public class QueryWhereConditionParser implements QueryParser {
         final List<FilterBuilder> conditionCollector = Lists.newLinkedList();
         final Object[] pRightParamValues = rightParamValues;
         final SQLConditionOperator pOperator = operator;
-        ElasticSqlIdentifier sqlIdentifier = ElasticSqlIdentifierHelper.parseSqlIdentifier(leftIdentifierExpr, queryAs, new ElasticSqlIdentifierHelper.ElasticSqlSinglePropertyFunc() {
+        ElasticSqlQueryField sqlIdentifier = ElasticSqlIdentifierHelper.parseSqlIdentifier(leftIdentifierExpr, queryAs, new ElasticSqlIdentifierHelper.SQLFlatFieldFunc() {
             @Override
-            public void parse(String propertyName) {
-                FilterBuilder originalFilter = filterBuilder.buildFilter(propertyName, pOperator, pRightParamValues);
+            public void parse(String flatFieldName) {
+                FilterBuilder originalFilter = filterBuilder.buildFilter(flatFieldName, pOperator, pRightParamValues);
                 conditionCollector.add(originalFilter);
             }
-        }, new ElasticSqlIdentifierHelper.ElasticSqlPathPropertyFunc() {
+        }, new ElasticSqlIdentifierHelper.SQLNestedFieldFunc() {
             @Override
-            public void parse(String propertyPath, String propertyName) {
-                FilterBuilder originalFilter = filterBuilder.buildFilter(propertyName, pOperator, pRightParamValues);
-                FilterBuilder nestFilter = FilterBuilders.nestedFilter(propertyPath, originalFilter);
+            public void parse(String nestedDocPath, String fieldName) {
+                FilterBuilder originalFilter = filterBuilder.buildFilter(fieldName, pOperator, pRightParamValues);
+                FilterBuilder nestFilter = FilterBuilders.nestedFilter(nestedDocPath, originalFilter);
                 conditionCollector.add(nestFilter);
             }
         });
@@ -238,7 +240,7 @@ public class QueryWhereConditionParser implements QueryParser {
         return null;
     }
 
-    private void onAtomConditionParse(ElasticSqlIdentifier paramName, Object[] paramValues, SQLConditionOperator operator) {
+    private void onAtomConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
         try {
             parseActionListener.onAtomConditionParse(paramName, paramValues, operator);
         } catch (Exception ex) {
@@ -255,35 +257,15 @@ public class QueryWhereConditionParser implements QueryParser {
         FilterBuilder buildFilter(String leftIdfName, SQLConditionOperator operator, Object[] rightParamValues);
     }
 
-    private class SqlCondition {
-        //是否AND/OR运算
-        private boolean isAndOr = false;
-        //运算符
-        private SQLBinaryOperator operator;
-        //条件集合
-        private List<FilterBuilder> filterList;
-
-        public SqlCondition(FilterBuilder atomFilter) {
-            filterList = Lists.newArrayList(atomFilter);
-            isAndOr = false;
-        }
-
-        public SqlCondition(List<FilterBuilder> filterList, SQLBinaryOperator operator) {
-            this.filterList = filterList;
-            isAndOr = true;
-            this.operator = operator;
-        }
-
-        public boolean isAndOr() {
-            return isAndOr;
-        }
-
-        public SQLBinaryOperator getOperator() {
-            return operator;
-        }
-
-        public List<FilterBuilder> getFilterList() {
-            return filterList;
-        }
+    private 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/test/java/org/elasticsearch/SqlParserLimitTest.java

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

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

@@ -1,10 +1,11 @@
 package org.elasticsearch;
 
 import com.google.common.collect.Lists;
-import org.elasticsearch.dsl.ElasticSql2DslParser;
-import org.elasticsearch.dsl.ElasticSqlIdentifier;
-import org.elasticsearch.dsl.ElasticSqlParseResult;
-import org.elasticsearch.dsl.ParseActionListenerAdapter;
+import org.elasticsearch.dsl.enums.QueryFieldType;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.elasticsearch.dsl.bean.ElasticSqlQueryField;
+import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.listener.ParseActionListenerAdapter;
 import org.elasticsearch.dsl.enums.SQLConditionOperator;
 import org.junit.Test;
 
@@ -19,9 +20,9 @@ public class SqlParserListenerTest {
         ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
         ElasticSqlParseResult parseResult = sql2DslParser.parse(sql, new ParseActionListenerAdapter() {
             @Override
-            public void onAtomConditionParse(ElasticSqlIdentifier paramName, Object[] paramValues, SQLConditionOperator operator) {
-                if (paramName.getIdentifierType() == ElasticSqlIdentifier.IdentifierType.Property
-                        && "updatedAt".equals(paramName.getPropertyName())) {
+            public void onAtomConditionParse(ElasticSqlQueryField paramName, Object[] paramValues, SQLConditionOperator operator) {
+                if (paramName.getQueryFieldType() == QueryFieldType.RootDocField
+                        && "updatedAt".equals(paramName.getSimpleQueryFieldName())) {
                     if (SQLConditionOperator.GreaterThan == operator || SQLConditionOperator.GreaterThanOrEqual == operator) {
 
                     }

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

@@ -1,7 +1,7 @@
 package org.elasticsearch;
 
-import org.elasticsearch.dsl.ElasticSql2DslParser;
-import org.elasticsearch.dsl.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
 import org.elasticsearch.search.sort.SortBuilder;
 import org.elasticsearch.search.sort.SortBuilders;
 import org.elasticsearch.search.sort.SortOrder;

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

@@ -1,7 +1,7 @@
 package org.elasticsearch;
 
-import org.elasticsearch.dsl.ElasticSql2DslParser;
-import org.elasticsearch.dsl.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -34,9 +34,9 @@ public class SqlParserRoutingTest {
 //
 //    @Test
 //    public void testJoin() {
-//        String sql = "select * from index.trx_order trx nested join product.xx x";
+//        String syntax = "select * from index.trx_order trx nested join product.xx x";
 //        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
-//        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+//        ElasticSqlParseResult parseResult = sql2DslParser.parse(syntax);
 //    }
 
 }

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

@@ -1,8 +1,8 @@
 package org.elasticsearch;
 
 import org.apache.commons.collections.CollectionUtils;
-import org.elasticsearch.dsl.ElasticSql2DslParser;
-import org.elasticsearch.dsl.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.elasticsearch.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;
 
 import org.elasticsearch.action.search.SearchRequestBuilder;
-import org.elasticsearch.dsl.ElasticSql2DslParser;
-import org.elasticsearch.dsl.ElasticSqlParseResult;
+import org.elasticsearch.dsl.parser.ElasticSql2DslParser;
+import org.elasticsearch.dsl.bean.ElasticSqlParseResult;
 import org.elasticsearch.index.query.FilterBuilder;
 import org.elasticsearch.index.query.FilterBuilders;
 import org.elasticsearch.index.query.NestedFilterBuilder;
@@ -143,6 +143,13 @@ public class SqlParserWhereConditionTest {
         System.out.println(parseResult.toString());
     }
 
+    @Test
+    public void test$Expr() {
+        String sql = "select * from index where a.$b.c.$d > 2";
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
+        ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
+        System.out.println(parseResult.toString());
+    }
 
     @Test
     public void testCreateSearchDsl() {