x

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

@@ -7,6 +7,7 @@ import org.elasticsearch.dsl.parser.*;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
+import java.util.function.Consumer;
 
 public class ElasticDslBuilder {
 
@@ -33,9 +34,14 @@ public class ElasticDslBuilder {
     }
 
     public ElasticDslContext build() {
-        ElasticDslContext dslContext = new ElasticDslContext(queryExpr);
+        final ElasticDslContext dslContext = new ElasticDslContext(queryExpr);
         if (queryExpr.getSubQuery().getQuery() instanceof ElasticSqlSelectQueryBlock) {
-            buildSqlParserChain().stream().forEach(sqlParser -> sqlParser.parse(dslContext));
+            buildSqlParserChain().stream().forEach(new Consumer<ElasticSqlParser>() {
+                @Override
+                public void accept(ElasticSqlParser sqlParser) {
+                    sqlParser.parse(dslContext);
+                }
+            });
             return dslContext;
         }
         throw new ElasticSql2DslException("[syntax error] ElasticSql only support Select Sql, but get: " + queryExpr.getSubQuery().getQuery().getClass());

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

@@ -2,6 +2,7 @@ package org.elasticsearch.dsl;
 
 import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
 import org.elasticsearch.ElasticMockClient;
 import org.elasticsearch.action.search.SearchRequestBuilder;
 import org.elasticsearch.client.Client;
@@ -13,6 +14,7 @@ import org.elasticsearch.utils.GsonHelper;
 
 import java.util.LinkedList;
 import java.util.List;
+import java.util.function.Consumer;
 
 public class ElasticDslContext {
     /*取数开始位置*/
@@ -20,9 +22,9 @@ public class ElasticDslContext {
     /*取数大小*/
     private int size = 15;
     /*查询索引*/
-    private List<String> indices;
+    private String index;
     /*查询文档类*/
-    private List<String> types;
+    private String type;
     /*查询索引别名*/
     private String queryAs;
     /*查询字段列表*/
@@ -62,20 +64,20 @@ public class ElasticDslContext {
         this.queryFieldList = queryFieldList;
     }
 
-    public List<String> getIndices() {
-        return indices;
+    public String getIndex() {
+        return index;
     }
 
-    public void setIndices(List<String> indices) {
-        this.indices = indices;
+    public void setIndex(String index) {
+        this.index = index;
     }
 
-    public List<String> getTypes() {
-        return types;
+    public String getType() {
+        return type;
     }
 
-    public void setTypes(List<String> types) {
-        this.types = types;
+    public void setType(String type) {
+        this.type = type;
     }
 
     public int getFrom() {
@@ -115,7 +117,7 @@ public class ElasticDslContext {
     }
 
     public SearchRequestBuilder toRequest(Client client) {
-        SearchRequestBuilder requestBuilder = new SearchRequestBuilder(client);
+        final SearchRequestBuilder requestBuilder = new SearchRequestBuilder(client);
 
         if (size > 100) {
             requestBuilder.setFrom(from).setSize(100);
@@ -123,12 +125,12 @@ public class ElasticDslContext {
             requestBuilder.setFrom(from).setSize(size);
         }
 
-        if (CollectionUtils.isNotEmpty(indices)) {
-            requestBuilder.setIndices(indices.toArray(new String[indices.size()]));
+        if (StringUtils.isNotBlank(index)) {
+            requestBuilder.setIndices(index);
         }
 
-        if (CollectionUtils.isNotEmpty(types)) {
-            requestBuilder.setTypes(types.toArray(new String[types.size()]));
+        if (StringUtils.isNotBlank(type)) {
+            requestBuilder.setTypes(type);
         }
 
         if (filterBuilder != null && filterBuilder.hasClauses()) {
@@ -138,7 +140,12 @@ public class ElasticDslContext {
         }
 
         if (CollectionUtils.isNotEmpty(sortBuilderList)) {
-            sortBuilderList.stream().forEach(requestBuilder::addSort);
+            sortBuilderList.stream().forEach(new Consumer<SortBuilder>() {
+                @Override
+                public void accept(SortBuilder sortBuilder) {
+                    requestBuilder.addSort(sortBuilder);
+                }
+            });
         }
 
         if (CollectionUtils.isNotEmpty(queryFieldList)) {

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

@@ -1,31 +1,43 @@
 package org.elasticsearch.dsl.parser;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
-import com.alibaba.druid.sql.ast.expr.SQLBinaryOperator;
-import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
-import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
-import com.alibaba.druid.sql.ast.expr.SQLNumberExpr;
+import com.alibaba.druid.sql.ast.expr.*;
+import com.google.common.base.Function;
 import com.google.common.collect.Lists;
+import org.apache.commons.collections.CollectionUtils;
 import org.elasticsearch.dsl.exception.ElasticSql2DslException;
 
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.List;
+import java.util.TimeZone;
 
 public class ElasticSqlParseUtil {
     public static Object[] transferSqlArgs(List<SQLExpr> exprList) {
         SQLExpr firstArg = exprList.get(0);
         if (firstArg instanceof SQLIntegerExpr) {
-            return toObjectArray(Lists.transform(exprList, argItem -> {
-                return ((SQLIntegerExpr) argItem).getNumber().longValue();
+            return toObjectArray(Lists.transform(exprList, new Function<SQLExpr, Object>() {
+                @Override
+                public Object apply(SQLExpr sqlExpr) {
+                    return ((SQLIntegerExpr) sqlExpr).getNumber().longValue();
+                }
             }));
         }
         if (firstArg instanceof SQLNumberExpr) {
-            return toObjectArray(Lists.transform(exprList, argItem -> {
-                return ((SQLNumberExpr) argItem).getNumber().doubleValue();
+            return toObjectArray(Lists.transform(exprList, new Function<SQLExpr, Object>() {
+                @Override
+                public Object apply(SQLExpr sqlExpr) {
+                    return ((SQLNumberExpr) sqlExpr).getNumber().doubleValue();
+                }
             }));
         }
         if (firstArg instanceof SQLCharExpr) {
-            return toObjectArray(Lists.transform(exprList, argItem -> {
-                return ((SQLCharExpr) argItem).getValue();
+            return toObjectArray(Lists.transform(exprList, new Function<SQLExpr, Object>() {
+                @Override
+                public Object apply(SQLExpr sqlExpr) {
+                    return ((SQLCharExpr) sqlExpr).getValue();
+                }
             }));
         }
         throw new ElasticSql2DslException("[syntax error] Can not support arg type: " + firstArg.getClass());
@@ -41,7 +53,44 @@ public class ElasticSqlParseUtil {
         if (expr instanceof SQLCharExpr) {
             return ((SQLCharExpr) expr).getValue();
         }
-        throw new ElasticSql2DslException("[syntax error] Can not support arg type: " + expr.getClass());
+        if (expr instanceof SQLMethodInvokeExpr) {
+            SQLMethodInvokeExpr dateMethodExpr = (SQLMethodInvokeExpr) expr;
+            checkDateMethod(dateMethodExpr);
+            final String patternArg = (String) ElasticSqlParseUtil.transferSqlArg(dateMethodExpr.getParameters().get(0));
+            final String timeValArg = (String) ElasticSqlParseUtil.transferSqlArg(dateMethodExpr.getParameters().get(1));
+            try {
+                SimpleDateFormat dateFormat = new SimpleDateFormat(patternArg);
+                Date date = dateFormat.parse(timeValArg);
+
+                dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
+                return dateFormat.format(date);
+            } catch (ParseException pex) {
+                throw new ElasticSql2DslException("[syntax error] Parse time arg error: " + expr.toString());
+            }
+        }
+        throw new ElasticSql2DslException("[syntax error] Can not support arg type: " + expr.toString());
+    }
+
+    private static void checkDateMethod(SQLMethodInvokeExpr dateInvokeExpr) {
+        if (!"date".equalsIgnoreCase(dateInvokeExpr.getMethodName())) {
+            throw new ElasticSql2DslException("[syntax error] ElasticSql not support method:" + dateInvokeExpr.getMethodName());
+        }
+
+        if (CollectionUtils.isEmpty(dateInvokeExpr.getParameters()) || dateInvokeExpr.getParameters().size() != 2) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There is no %s args method named nvl",
+                    dateInvokeExpr.getParameters() != null ? dateInvokeExpr.getParameters().size() : 0));
+        }
+
+        SQLExpr patternArg = dateInvokeExpr.getParameters().get(0);
+        SQLExpr timeValArg = dateInvokeExpr.getParameters().get(1);
+
+        if (!(patternArg instanceof SQLCharExpr)) {
+            throw new ElasticSql2DslException("[syntax error] The first arg of date method should be a time pattern");
+        }
+
+        if (!(timeValArg instanceof SQLCharExpr)) {
+            throw new ElasticSql2DslException("[syntax error] The second arg of date method should be a string of time");
+        }
     }
 
     private static <T> Object[] toObjectArray(List<T> list) {

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

@@ -1,8 +1,7 @@
 package org.elasticsearch.dsl.parser;
 
-import com.alibaba.druid.sql.ast.expr.SQLBinaryOpExpr;
-import com.alibaba.druid.sql.ast.expr.SQLBinaryOperator;
 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.ImmutableList;
 import org.elasticsearch.dsl.ElasticDslContext;
@@ -18,22 +17,20 @@ public class QueryFromParser implements ElasticSqlParser {
             dslContext.setQueryAs(tableSource.getAlias());
 
             if (tableSource.getExpr() instanceof SQLIdentifierExpr) {
-                dslContext.setIndices(ImmutableList.of(((SQLIdentifierExpr) tableSource.getExpr()).getName()));
+                dslContext.setIndex(((SQLIdentifierExpr) tableSource.getExpr()).getName());
                 return;
             }
-            if (tableSource.getExpr() instanceof SQLBinaryOpExpr) {
-                SQLBinaryOpExpr idxExpr = (SQLBinaryOpExpr) tableSource.getExpr();
+            if (tableSource.getExpr() instanceof SQLPropertyExpr) {
+                SQLPropertyExpr idxExpr = (SQLPropertyExpr) tableSource.getExpr();
 
-                if (!(idxExpr.getLeft() instanceof SQLIdentifierExpr)
-                        || !(idxExpr.getRight() instanceof SQLIdentifierExpr)
-                        || idxExpr.getOperator() != SQLBinaryOperator.Divide) {
-                    throw new ElasticSql2DslException("[syntax error] From table should like [index]/[type]");
+                if (!(idxExpr.getOwner() instanceof SQLIdentifierExpr)) {
+                    throw new ElasticSql2DslException("[syntax error] From table should like [index].[type]");
                 }
-                dslContext.setIndices(ImmutableList.of(((SQLIdentifierExpr) idxExpr.getLeft()).getName()));
-                dslContext.setTypes(ImmutableList.of(((SQLIdentifierExpr) idxExpr.getRight()).getName()));
+                dslContext.setIndex(((SQLIdentifierExpr) idxExpr.getOwner()).getName());
+                dslContext.setType(idxExpr.getName());
                 return;
             }
         }
-        throw new ElasticSql2DslException("[syntax error] From table source should be [SQLExprTableSource],but get: " + queryBlock.getFrom().getClass());
+        throw new ElasticSql2DslException("[syntax error] From table should like [index].[type]");
     }
 }

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

@@ -23,43 +23,49 @@ public class QueryOrderConditionParser implements ElasticSqlParser {
         ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
         SQLOrderBy sqlOrderBy = queryBlock.getOrderBy();
         if (sqlOrderBy != null && CollectionUtils.isNotEmpty(sqlOrderBy.getItems())) {
-            sqlOrderBy.getItems().stream().forEach(orderByItem -> {
+            for (SQLSelectOrderByItem orderByItem : sqlOrderBy.getItems()) {
                 SortBuilder orderBy = parseOrderCondition(orderByItem, dslContext.getQueryAs());
                 if (orderBy != null) {
                     dslContext.addSort(orderBy);
                 }
-            });
+            }
         }
     }
 
-    private SortBuilder parseOrderCondition(SQLSelectOrderByItem orderByItem, String queryAs) {
+    private SortBuilder parseOrderCondition(final SQLSelectOrderByItem orderByItem, String queryAs) {
         if (orderByItem.getExpr() instanceof SQLPropertyExpr || orderByItem.getExpr() instanceof SQLIdentifierExpr) {
-            return parseCondition(orderByItem.getExpr(), queryAs, idfName -> {
-                if (SQLOrderingSpecification.ASC == orderByItem.getType()) {
-                    return SortBuilders.fieldSort(idfName).order(SortOrder.ASC);
-                } else {
-                    return SortBuilders.fieldSort(idfName).order(SortOrder.DESC);
+            return parseCondition(orderByItem.getExpr(), queryAs, new ConditionSortBuilder() {
+                @Override
+                public FieldSortBuilder buildSort(String idfName) {
+                    if (SQLOrderingSpecification.ASC == orderByItem.getType()) {
+                        return SortBuilders.fieldSort(idfName).order(SortOrder.ASC);
+                    } else {
+                        return SortBuilders.fieldSort(idfName).order(SortOrder.DESC);
+                    }
                 }
             });
         }
         if (orderByItem.getExpr() instanceof SQLMethodInvokeExpr) {
-            SQLMethodInvokeExpr methodInvokeExpr = (SQLMethodInvokeExpr) orderByItem.getExpr();
+            final SQLMethodInvokeExpr methodInvokeExpr = (SQLMethodInvokeExpr) orderByItem.getExpr();
             checkNvlMethod(methodInvokeExpr);
 
-            Object valueArg = ElasticSqlParseUtil.transferSqlArg(methodInvokeExpr.getParameters().get(1));
-            return parseCondition(methodInvokeExpr.getParameters().get(0), queryAs, idfName -> {
-                FieldSortBuilder fieldSortBuilder = null;
-                if (SQLOrderingSpecification.ASC == orderByItem.getType()) {
-                    fieldSortBuilder = SortBuilders.fieldSort(idfName).order(SortOrder.ASC).missing(valueArg);
-                } else {
-                    fieldSortBuilder = SortBuilders.fieldSort(idfName).order(SortOrder.DESC).missing(valueArg);
+            final Object valueArg = ElasticSqlParseUtil.transferSqlArg(methodInvokeExpr.getParameters().get(1));
+            return parseCondition(methodInvokeExpr.getParameters().get(0), queryAs, new ConditionSortBuilder() {
+                @Override
+                public FieldSortBuilder buildSort(String idfName) {
+                    FieldSortBuilder fieldSortBuilder = null;
+                    if (SQLOrderingSpecification.ASC == orderByItem.getType()) {
+                        fieldSortBuilder = SortBuilders.fieldSort(idfName).order(SortOrder.ASC).missing(valueArg);
+                    } else {
+                        fieldSortBuilder = SortBuilders.fieldSort(idfName).order(SortOrder.DESC).missing(valueArg);
+                    }
+                    if (methodInvokeExpr.getParameters().size() == 3) {
+                        SQLExpr sortModArg = methodInvokeExpr.getParameters().get(2);
+                        String sortModeText = ((SQLCharExpr) sortModArg).getText();
+                        fieldSortBuilder.sortMode(SortOption.get(sortModeText).mode());
+                    }
+                    return fieldSortBuilder;
                 }
-                if (methodInvokeExpr.getParameters().size() == 3) {
-                    SQLExpr sortModArg = methodInvokeExpr.getParameters().get(2);
-                    String sortModeText = ((SQLCharExpr) sortModArg).getText();
-                    fieldSortBuilder.sortMode(SortOption.get(sortModeText).mode());
-                }
-                return fieldSortBuilder;
             });
         }
         throw new ElasticSql2DslException("[syntax error] ElasticSql cannot support sort type: " + orderByItem.getExpr().getClass());
@@ -99,15 +105,21 @@ public class QueryOrderConditionParser implements ElasticSqlParser {
         }
     }
 
-    private SortBuilder parseCondition(SQLExpr sqlExpr, String queryAs, ConditionSortBuilder sortBuilder) {
-        List<SortBuilder> tmpSortList = Lists.newLinkedList();
-        ElasticSqlIdfParser.parseSqlIdentifier(sqlExpr, queryAs, idfName -> {
-            FieldSortBuilder originalSort = sortBuilder.buildSort(idfName);
-            tmpSortList.add(originalSort);
-        }, (nestPath, idfName) -> {
-            FieldSortBuilder originalSort = sortBuilder.buildSort(idfName);
-            originalSort.setNestedPath(nestPath);
-            tmpSortList.add(originalSort);
+    private SortBuilder parseCondition(SQLExpr sqlExpr, String queryAs, final ConditionSortBuilder sortBuilder) {
+        final List<SortBuilder> tmpSortList = Lists.newLinkedList();
+        ElasticSqlIdfParser.parseSqlIdentifier(sqlExpr, queryAs, new ElasticSqlIdfParser.ElasticSqlTopIdfFunc() {
+            @Override
+            public void parse(String idfName) {
+                FieldSortBuilder originalSort = sortBuilder.buildSort(idfName);
+                tmpSortList.add(originalSort);
+            }
+        }, new ElasticSqlIdfParser.ElasticSqlNestIdfFunc() {
+            @Override
+            public void parse(String nestPath, String idfName) {
+                FieldSortBuilder originalSort = sortBuilder.buildSort(idfName);
+                originalSort.setNestedPath(nestPath);
+                tmpSortList.add(originalSort);
+            }
         });
         if (CollectionUtils.isNotEmpty(tmpSortList)) {
             return tmpSortList.get(0);

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

@@ -1,5 +1,6 @@
 package org.elasticsearch.dsl.parser;
 
+import com.alibaba.druid.sql.ast.statement.SQLSelectItem;
 import com.google.common.collect.Lists;
 import org.elasticsearch.dsl.ElasticDslContext;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
@@ -14,19 +15,22 @@ public class QuerySelectFieldListParser implements ElasticSqlParser {
     public void parse(ElasticDslContext dslContext) {
         ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
 
-        List<String> selectFields = Lists.newLinkedList();
-        queryBlock.getSelectList().stream().forEach(
-                selectField -> ElasticSqlIdfParser.parseSqlIdentifier(selectField.getExpr(), dslContext.getQueryAs(),
-                        idfName -> {
-                            if (!SQL_FIELD_MATCH_ALL.equals(idfName)) {
-                                selectFields.add(idfName);
-                            }
-                        },
-                        (nestPath, idfName) -> {
-                            selectFields.add(String.format("%s.%s", nestPath, idfName));
-                        }
-                )
-        );
+        final List<String> selectFields = Lists.newLinkedList();
+        for (SQLSelectItem selectField : queryBlock.getSelectList()) {
+            ElasticSqlIdfParser.parseSqlIdentifier(selectField.getExpr(), dslContext.getQueryAs(), new ElasticSqlIdfParser.ElasticSqlTopIdfFunc() {
+                @Override
+                public void parse(String idfName) {
+                    if (!SQL_FIELD_MATCH_ALL.equals(idfName)) {
+                        selectFields.add(idfName);
+                    }
+                }
+            }, new ElasticSqlIdfParser.ElasticSqlNestIdfFunc() {
+                @Override
+                public void parse(String nestPath, String idfName) {
+                    selectFields.add(String.format("%s.%s", nestPath, idfName));
+                }
+            });
+        }
         dslContext.setQueryFieldList(selectFields);
     }
 }

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

@@ -12,6 +12,7 @@ import org.elasticsearch.index.query.FilterBuilders;
 import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
 
 import java.util.List;
+import java.util.function.Consumer;
 
 public class QueryWhereConditionParser implements ElasticSqlParser {
     @Override
@@ -22,14 +23,14 @@ public class QueryWhereConditionParser implements ElasticSqlParser {
             if (!sqlCondition.isAndOr()) {
                 dslContext.boolFilter().must(sqlCondition.getFilterList().get(0));
             } else {
-                sqlCondition.getFilterList().stream().forEach(filter -> {
+                for (FilterBuilder filter : sqlCondition.getFilterList()) {
                     if (sqlCondition.getOperator() == SQLBinaryOperator.BooleanAnd) {
                         dslContext.boolFilter().must(filter);
                     }
                     if (sqlCondition.getOperator() == SQLBinaryOperator.BooleanOr) {
                         dslContext.boolFilter().should(filter);
                     }
-                });
+                }
             }
         }
     }
@@ -39,21 +40,24 @@ public class QueryWhereConditionParser implements ElasticSqlParser {
             SQLBinaryOpExpr sqlBinOpExpr = (SQLBinaryOpExpr) sqlExpr;
             SQLBinaryOperator binaryOperator = sqlBinOpExpr.getOperator();
             if (SQLBinaryOperator.BooleanAnd == binaryOperator || SQLBinaryOperator.BooleanOr == binaryOperator) {
-                SqlCondition leftCondition = parseFilterCondition(dslContext, sqlBinOpExpr.getLeft());
-                SqlCondition rightCondition = parseFilterCondition(dslContext, sqlBinOpExpr.getRight());
+                final SqlCondition leftCondition = parseFilterCondition(dslContext, sqlBinOpExpr.getLeft());
+                final SqlCondition rightCondition = parseFilterCondition(dslContext, sqlBinOpExpr.getRight());
 
                 List<FilterBuilder> curFilterList = Lists.newArrayList();
 
                 if (!leftCondition.isAndOr() || leftCondition.operator == binaryOperator) {
                     curFilterList.addAll(leftCondition.getFilterList());
                 } else {
-                    BoolFilterBuilder subBoolFilter = FilterBuilders.boolFilter();
-                    leftCondition.getFilterList().stream().forEach(filter -> {
-                        if (leftCondition.getOperator() == SQLBinaryOperator.BooleanAnd) {
-                            subBoolFilter.must(filter);
-                        }
-                        if (leftCondition.getOperator() == SQLBinaryOperator.BooleanOr) {
-                            subBoolFilter.should(filter);
+                    final BoolFilterBuilder subBoolFilter = FilterBuilders.boolFilter();
+                    leftCondition.getFilterList().stream().forEach(new Consumer<FilterBuilder>() {
+                        @Override
+                        public void accept(FilterBuilder filter) {
+                            if (leftCondition.getOperator() == SQLBinaryOperator.BooleanAnd) {
+                                subBoolFilter.must(filter);
+                            }
+                            if (leftCondition.getOperator() == SQLBinaryOperator.BooleanOr) {
+                                subBoolFilter.should(filter);
+                            }
                         }
                     });
                     curFilterList.add(subBoolFilter);
@@ -62,13 +66,16 @@ public class QueryWhereConditionParser implements ElasticSqlParser {
                 if (!rightCondition.isAndOr() || rightCondition.operator == binaryOperator) {
                     curFilterList.addAll(rightCondition.getFilterList());
                 } else {
-                    BoolFilterBuilder subBoolFilter = FilterBuilders.boolFilter();
-                    rightCondition.getFilterList().stream().forEach(filter -> {
-                        if (rightCondition.getOperator() == SQLBinaryOperator.BooleanAnd) {
-                            subBoolFilter.must(filter);
-                        }
-                        if (rightCondition.getOperator() == SQLBinaryOperator.BooleanOr) {
-                            subBoolFilter.should(filter);
+                    final BoolFilterBuilder subBoolFilter = FilterBuilders.boolFilter();
+                    rightCondition.getFilterList().stream().forEach(new Consumer<FilterBuilder>() {
+                        @Override
+                        public void accept(FilterBuilder filter) {
+                            if (rightCondition.getOperator() == SQLBinaryOperator.BooleanAnd) {
+                                subBoolFilter.must(filter);
+                            }
+                            if (rightCondition.getOperator() == SQLBinaryOperator.BooleanOr) {
+                                subBoolFilter.should(filter);
+                            }
                         }
                     });
                     curFilterList.add(subBoolFilter);
@@ -82,7 +89,7 @@ public class QueryWhereConditionParser implements ElasticSqlParser {
     private FilterBuilder parseAtomFilterCondition(ElasticDslContext dslContext, SQLExpr sqlExpr) {
         if (sqlExpr instanceof SQLBinaryOpExpr) {
             SQLBinaryOpExpr sqlBinOpExpr = (SQLBinaryOpExpr) sqlExpr;
-            SQLBinaryOperator binaryOperator = sqlBinOpExpr.getOperator();
+            final SQLBinaryOperator binaryOperator = sqlBinOpExpr.getOperator();
 
             if (ElasticSqlParseUtil.isValidBinOperator(binaryOperator)) {
                 //以下是二元运算,左边必须是变量
@@ -92,13 +99,16 @@ public class QueryWhereConditionParser implements ElasticSqlParser {
 
                 //EQ NEQ
                 if (SQLBinaryOperator.Equality == binaryOperator || SQLBinaryOperator.LessThanOrGreater == binaryOperator || SQLBinaryOperator.NotEqual == binaryOperator) {
-                    Object targetVal = ElasticSqlParseUtil.transferSqlArg(sqlBinOpExpr.getRight());
-                    return parseCondition(sqlBinOpExpr.getLeft(), dslContext.getQueryAs(), idfName -> {
-                        FilterBuilder eqFilter = FilterBuilders.termFilter(idfName, targetVal);
-                        if (SQLBinaryOperator.Equality == binaryOperator) {
-                            return eqFilter;
-                        } else {
-                            return FilterBuilders.notFilter(eqFilter);
+                    final Object targetVal = ElasticSqlParseUtil.transferSqlArg(sqlBinOpExpr.getRight());
+                    return parseCondition(sqlBinOpExpr.getLeft(), dslContext.getQueryAs(), new ConditionFilterBuilder() {
+                        @Override
+                        public FilterBuilder buildFilter(String idfName) {
+                            FilterBuilder eqFilter = FilterBuilders.termFilter(idfName, targetVal);
+                            if (SQLBinaryOperator.Equality == binaryOperator) {
+                                return eqFilter;
+                            } else {
+                                return FilterBuilders.notFilter(eqFilter);
+                            }
                         }
                     });
                 }
@@ -106,19 +116,22 @@ public class QueryWhereConditionParser implements ElasticSqlParser {
                 //GT GTE LT LTE
                 if (SQLBinaryOperator.GreaterThan == binaryOperator || SQLBinaryOperator.GreaterThanOrEqual == binaryOperator
                         || SQLBinaryOperator.LessThan == binaryOperator || SQLBinaryOperator.LessThanOrEqual == binaryOperator) {
-                    Object targetVal = ElasticSqlParseUtil.transferSqlArg(sqlBinOpExpr.getRight());
-                    return parseCondition(sqlBinOpExpr.getLeft(), dslContext.getQueryAs(), idfName -> {
-                        FilterBuilder rangeFilter = null;
-                        if (SQLBinaryOperator.GreaterThan == binaryOperator) {
-                            rangeFilter = FilterBuilders.rangeFilter(idfName).gt(targetVal);
-                        } else if (SQLBinaryOperator.GreaterThanOrEqual == binaryOperator) {
-                            rangeFilter = FilterBuilders.rangeFilter(idfName).gte(targetVal);
-                        } else if (SQLBinaryOperator.LessThan == binaryOperator) {
-                            rangeFilter = FilterBuilders.rangeFilter(idfName).lt(targetVal);
-                        } else if (SQLBinaryOperator.LessThanOrEqual == binaryOperator) {
-                            rangeFilter = FilterBuilders.rangeFilter(idfName).lte(targetVal);
+                    final Object targetVal = ElasticSqlParseUtil.transferSqlArg(sqlBinOpExpr.getRight());
+                    return parseCondition(sqlBinOpExpr.getLeft(), dslContext.getQueryAs(), new ConditionFilterBuilder() {
+                        @Override
+                        public FilterBuilder buildFilter(String idfName) {
+                            FilterBuilder rangeFilter = null;
+                            if (SQLBinaryOperator.GreaterThan == binaryOperator) {
+                                rangeFilter = FilterBuilders.rangeFilter(idfName).gt(targetVal);
+                            } else if (SQLBinaryOperator.GreaterThanOrEqual == binaryOperator) {
+                                rangeFilter = FilterBuilders.rangeFilter(idfName).gte(targetVal);
+                            } else if (SQLBinaryOperator.LessThan == binaryOperator) {
+                                rangeFilter = FilterBuilders.rangeFilter(idfName).lt(targetVal);
+                            } else if (SQLBinaryOperator.LessThanOrEqual == binaryOperator) {
+                                rangeFilter = FilterBuilders.rangeFilter(idfName).lte(targetVal);
+                            }
+                            return rangeFilter;
                         }
-                        return rangeFilter;
                     });
                 }
 
@@ -127,54 +140,69 @@ public class QueryWhereConditionParser implements ElasticSqlParser {
                     if (!(sqlBinOpExpr.getRight() instanceof SQLNullExpr)) {
                         throw new ElasticSql2DslException("[syntax error] Is/IsNot expr right part should be null");
                     }
-                    return parseCondition(sqlBinOpExpr.getLeft(), dslContext.getQueryAs(), idfName -> {
-                        FilterBuilder missingFilter = FilterBuilders.missingFilter(idfName);
-                        if (SQLBinaryOperator.IsNot == binaryOperator) {
-                            return FilterBuilders.notFilter(missingFilter);
+                    return parseCondition(sqlBinOpExpr.getLeft(), dslContext.getQueryAs(), new ConditionFilterBuilder() {
+                        @Override
+                        public FilterBuilder buildFilter(String idfName) {
+                            FilterBuilder missingFilter = FilterBuilders.missingFilter(idfName);
+                            if (SQLBinaryOperator.IsNot == binaryOperator) {
+                                return FilterBuilders.notFilter(missingFilter);
+                            }
+                            return missingFilter;
                         }
-                        return missingFilter;
                     });
                 }
             }
         } else if (sqlExpr instanceof SQLInListExpr) {
-            SQLInListExpr inListExpr = (SQLInListExpr) sqlExpr;
+            final SQLInListExpr inListExpr = (SQLInListExpr) sqlExpr;
             if (CollectionUtils.isEmpty(inListExpr.getTargetList())) {
                 throw new ElasticSql2DslException("[syntax error] In list expr target list cannot be blank");
             }
-            Object[] targetInList = ElasticSqlParseUtil.transferSqlArgs(inListExpr.getTargetList());
-            return parseCondition(inListExpr.getExpr(), dslContext.getQueryAs(), idfName -> {
-                if (inListExpr.isNot()) {
-                    return FilterBuilders.notFilter(FilterBuilders.inFilter(idfName, targetInList));
-                } else {
-                    return FilterBuilders.inFilter(idfName, targetInList);
+            final Object[] targetInList = ElasticSqlParseUtil.transferSqlArgs(inListExpr.getTargetList());
+            return parseCondition(inListExpr.getExpr(), dslContext.getQueryAs(), new ConditionFilterBuilder() {
+                @Override
+                public FilterBuilder buildFilter(String idfName) {
+                    if (inListExpr.isNot()) {
+                        return FilterBuilders.notFilter(FilterBuilders.inFilter(idfName, targetInList));
+                    } else {
+                        return FilterBuilders.inFilter(idfName, targetInList);
+                    }
                 }
             });
         } else if (sqlExpr instanceof SQLBetweenExpr) {
             SQLBetweenExpr betweenExpr = (SQLBetweenExpr) sqlExpr;
 
-            Object from = ElasticSqlParseUtil.transferSqlArg(betweenExpr.getBeginExpr());
-            Object to = ElasticSqlParseUtil.transferSqlArg(betweenExpr.getEndExpr());
+            final Object from = ElasticSqlParseUtil.transferSqlArg(betweenExpr.getBeginExpr());
+            final Object to = ElasticSqlParseUtil.transferSqlArg(betweenExpr.getEndExpr());
 
             if (from == null || to == null) {
                 throw new ElasticSql2DslException("[syntax error] Between Expr only support one of [number,date] arg type");
             }
 
-            return parseCondition(betweenExpr.getTestExpr(), dslContext.getQueryAs(), idfName -> {
-                return FilterBuilders.rangeFilter(idfName).gte(from).lte(to);
+            return parseCondition(betweenExpr.getTestExpr(), dslContext.getQueryAs(), new ConditionFilterBuilder() {
+                @Override
+                public FilterBuilder buildFilter(String idfName) {
+                    return FilterBuilders.rangeFilter(idfName).gte(from).lte(to);
+                }
             });
         }
-        throw new ElasticSql2DslException("[syntax error] Can not support Op type: " + sqlExpr.getClass());
+        throw new ElasticSql2DslException("[syntax error] Can not support syntax type: " + sqlExpr.toString());
     }
 
-    private FilterBuilder parseCondition(SQLExpr sqlExpr, String queryAs, ConditionFilterBuilder filterBuilder) {
-        List<FilterBuilder> tmpFilterList = Lists.newLinkedList();
-        ElasticSqlIdfParser.parseSqlIdentifier(sqlExpr, queryAs, idfName -> {
-            FilterBuilder originalFilter = filterBuilder.buildFilter(idfName);
-            tmpFilterList.add(originalFilter);
-        }, (nestPath, idfName) -> {
-            FilterBuilder originalFilter = filterBuilder.buildFilter(idfName);
-            FilterBuilder nestFilter = FilterBuilders.nestedFilter(nestPath, originalFilter);
-            tmpFilterList.add(nestFilter);
+    private FilterBuilder parseCondition(SQLExpr sqlExpr, String queryAs, final ConditionFilterBuilder filterBuilder) {
+        final List<FilterBuilder> tmpFilterList = Lists.newLinkedList();
+        ElasticSqlIdfParser.parseSqlIdentifier(sqlExpr, queryAs, new ElasticSqlIdfParser.ElasticSqlTopIdfFunc() {
+            @Override
+            public void parse(String idfName) {
+                FilterBuilder originalFilter = filterBuilder.buildFilter(idfName);
+                tmpFilterList.add(originalFilter);
+            }
+        }, new ElasticSqlIdfParser.ElasticSqlNestIdfFunc() {
+            @Override
+            public void parse(String nestPath, String idfName) {
+                FilterBuilder originalFilter = filterBuilder.buildFilter(idfName);
+                FilterBuilder nestFilter = FilterBuilders.nestedFilter(nestPath, originalFilter);
+                tmpFilterList.add(nestFilter);
+            }
         });
         if (CollectionUtils.isNotEmpty(tmpFilterList)) {
             return tmpFilterList.get(0);

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

@@ -11,7 +11,7 @@ public class ElasticSqlLexer extends Lexer {
     public final static Keywords DEFAULT_ELASTIC_SQL_KEYWORDS;
 
     static {
-        Map<String, Token> map = new HashMap<>();
+        Map<String, Token> map = new HashMap<String, Token>();
 
         map.put("SELECT", Token.SELECT);
         map.put("DISTINCT", Token.DISTINCT);

src/test/java/org/elasticsearch/SqlParserTest.java

@@ -39,7 +39,7 @@ public class SqlParserTest {
 
     @Test
     public void testParseSelectFieldMatchAll_01() {
-        String sql = "select * from book where c = 1";
+        String sql = "select * from lib.av as b where c = 1 and updated_at > date('yyyy-MM-dd', '2016-10-22')";
         ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser(sql);
         ElasticDslContext dslContext = sql2DslParser.parse();
 
@@ -81,7 +81,7 @@ public class SqlParserTest {
 
     @Test
     public void testParseNestCondition() {
-        String sql = "select id,bookStatus,updatedAt,bookClassifications from book/basic dd where"
+        String sql = "select id,bookStatus,updatedAt,bookClassifications from book.basic dd where"
                 + " bookCategory = '802'"
                 + " and bookClassifications.classificationId > 0"
                 + " order by id desc,nvl(bookClassifications.sortNo, 999, 'min') asc";
@@ -91,4 +91,5 @@ public class SqlParserTest {
 
         System.out.println(dslContext.toString());
     }
+    
 }