reform

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

@@ -57,7 +57,7 @@ public class ElasticSql2DslParser {
                 }
             });
         } else {
-            throw new ElasticSql2DslException("[syntax error] ElasticSql only support Select Sql");
+            throw new ElasticSql2DslException("[syntax error] Sql only support Select Sql");
         }
         return elasticDslContext.getParseResult();
     }

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

@@ -5,12 +5,10 @@ import org.apache.commons.lang.StringUtils;
 import org.elasticsearch.action.search.SearchRequestBuilder;
 import org.elasticsearch.client.Client;
 import org.elasticsearch.index.query.BoolFilterBuilder;
-import org.elasticsearch.index.query.FilterBuilders;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.search.sort.SortBuilder;
 import org.elasticsearch.util.ElasticMockClient;
 
-import java.util.LinkedList;
 import java.util.List;
 import java.util.function.Consumer;
 
@@ -30,25 +28,9 @@ public class ElasticSqlParseResult {
     /*查询字段列表*/
     private List<String> queryFieldList;
     /*SQL的where条件*/
-    private transient BoolFilterBuilder filterBuilder;
+    private transient BoolFilterBuilder whereCondition;
     /*SQL的order by条件*/
-    private transient List<SortBuilder> sortBuilderList;
-
-    public void addSort(SortBuilder sortBuilder) {
-        if (sortBuilder != null) {
-            if (sortBuilderList == null) {
-                sortBuilderList = new LinkedList<SortBuilder>();
-            }
-            sortBuilderList.add(sortBuilder);
-        }
-    }
-
-    public BoolFilterBuilder boolFilter() {
-        if (filterBuilder == null) {
-            filterBuilder = FilterBuilders.boolFilter();
-        }
-        return filterBuilder;
-    }
+    private transient List<SortBuilder> orderBy;
 
     public List<String> getQueryFieldList() {
         return queryFieldList;
@@ -98,12 +80,20 @@ public class ElasticSqlParseResult {
         this.queryAs = queryAs;
     }
 
-    public BoolFilterBuilder getFilterBuilder() {
-        return filterBuilder;
+    public BoolFilterBuilder getWhereCondition() {
+        return whereCondition;
+    }
+
+    public void setWhereCondition(BoolFilterBuilder whereCondition) {
+        this.whereCondition = whereCondition;
+    }
+
+    public List<SortBuilder> getOrderBy() {
+        return orderBy;
     }
 
-    public List<SortBuilder> getSortBuilderList() {
-        return sortBuilderList;
+    public void setOrderBy(List<SortBuilder> orderBy) {
+        this.orderBy = orderBy;
     }
 
     public List<String> getRoutingBy() {
@@ -116,12 +106,7 @@ public class ElasticSqlParseResult {
 
     public SearchRequestBuilder toRequest(Client client) {
         final SearchRequestBuilder requestBuilder = new SearchRequestBuilder(client);
-
-        if (size > 100) {
-            requestBuilder.setFrom(from).setSize(100);
-        } else {
-            requestBuilder.setFrom(from).setSize(size);
-        }
+        requestBuilder.setFrom(from).setSize(size);
 
         if (StringUtils.isNotBlank(index)) {
             requestBuilder.setIndices(index);
@@ -131,14 +116,14 @@ public class ElasticSqlParseResult {
             requestBuilder.setTypes(type);
         }
 
-        if (filterBuilder != null && filterBuilder.hasClauses()) {
-            requestBuilder.setQuery(QueryBuilders.filteredQuery(null, filterBuilder));
+        if (whereCondition != null && whereCondition.hasClauses()) {
+            requestBuilder.setQuery(QueryBuilders.filteredQuery(null, whereCondition));
         } else {
             requestBuilder.setQuery(QueryBuilders.matchAllQuery());
         }
 
-        if (CollectionUtils.isNotEmpty(sortBuilderList)) {
-            sortBuilderList.stream().forEach(new Consumer<SortBuilder>() {
+        if (CollectionUtils.isNotEmpty(orderBy)) {
+            orderBy.stream().forEach(new Consumer<SortBuilder>() {
                 @Override
                 public void accept(SortBuilder sortBuilder) {
                     requestBuilder.addSort(sortBuilder);
@@ -150,7 +135,7 @@ public class ElasticSqlParseResult {
             requestBuilder.setFetchSource(queryFieldList.toArray(new String[queryFieldList.size()]), null);
         }
 
-        if(CollectionUtils.isNotEmpty(routingBy)) {
+        if (CollectionUtils.isNotEmpty(routingBy)) {
             requestBuilder.setRouting(routingBy.toArray(new String[routingBy.size()]));
         }
         return requestBuilder;

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

@@ -29,12 +29,14 @@ public class QueryOrderConditionParser implements QueryParser {
         ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
         SQLOrderBy sqlOrderBy = queryBlock.getOrderBy();
         if (sqlOrderBy != null && CollectionUtils.isNotEmpty(sqlOrderBy.getItems())) {
+            List<SortBuilder> orderByList = Lists.newLinkedList();
             for (SQLSelectOrderByItem orderByItem : sqlOrderBy.getItems()) {
                 SortBuilder orderBy = parseOrderCondition(orderByItem, dslContext.getParseResult().getQueryAs(), dslContext.getSqlArgs());
                 if (orderBy != null) {
-                    dslContext.getParseResult().addSort(orderBy);
+                    orderByList.add(orderBy);
                 }
             }
+            dslContext.getParseResult().setOrderBy(orderByList);
         }
     }
 
@@ -89,7 +91,7 @@ public class QueryOrderConditionParser implements QueryParser {
                 });
             }
         }
-        throw new ElasticSql2DslException("[syntax error] ElasticSql cannot support sort type: " + orderByItem.getExpr().getClass());
+        throw new ElasticSql2DslException("[syntax error] Sql cannot support sort type: " + orderByItem.getExpr().getClass());
     }
 
     private SortBuilder parseCondition(SQLExpr sqlExpr, String queryAs, final ConditionSortBuilder sortBuilder) {

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

@@ -20,21 +20,23 @@ public class QueryWhereConditionParser implements QueryParser {
     @Override
     public void parse(ElasticDslContext dslContext) {
         ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) dslContext.getQueryExpr().getSubQuery().getQuery();
+        BoolFilterBuilder whereCondition = FilterBuilders.boolFilter();
         if (queryBlock.getWhere() != null) {
             SqlCondition sqlCondition = parseFilterCondition(dslContext, queryBlock.getWhere());
             if (!sqlCondition.isAndOr()) {
-                dslContext.getParseResult().boolFilter().must(sqlCondition.getFilterList().get(0));
+                whereCondition.must(sqlCondition.getFilterList().get(0));
             } else {
                 for (FilterBuilder filter : sqlCondition.getFilterList()) {
                     if (sqlCondition.getOperator() == SQLBinaryOperator.BooleanAnd) {
-                        dslContext.getParseResult().boolFilter().must(filter);
+                        whereCondition.must(filter);
                     }
                     if (sqlCondition.getOperator() == SQLBinaryOperator.BooleanOr) {
-                        dslContext.getParseResult().boolFilter().should(filter);
+                        whereCondition.should(filter);
                     }
                 }
             }
         }
+        dslContext.getParseResult().setWhereCondition(whereCondition);
     }
 
     private SqlCondition parseFilterCondition(ElasticDslContext dslContext, SQLExpr sqlExpr) {
@@ -207,9 +209,8 @@ public class QueryWhereConditionParser implements QueryParser {
         return null;
     }
 
-    @FunctionalInterface
-    private interface ConditionFilterBuilder {
-        FilterBuilder buildFilter(String idfName);
+    private abstract class ConditionFilterBuilder {
+        public abstract FilterBuilder buildFilter(String idfName);
     }
 
     private class SqlCondition {

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

@@ -82,7 +82,7 @@ public class ElasticSqlDateParseHelper {
         if (SqlDateRegex.DATE_REGEX_03.getPattern().matcher(date).matches()) {
             return formatDefaultEsDate(SqlDateRegex.DATE_REGEX_03.getPatternString(), date);
         }
-        throw new ElasticSql2DslException("[syntax error] ElasticSql cannot support such date type: " + date);
+        throw new ElasticSql2DslException("[syntax error] Sql cannot support such date type: " + date);
     }
 
     public static String formatDefaultEsDateObjectValue(Object date) {
@@ -90,7 +90,7 @@ public class ElasticSqlDateParseHelper {
             SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_ES_DATE_FORMAT);
             return dateFormat.format(date);
         }
-        throw new ElasticSql2DslException("[syntax error] ElasticSql cannot support such date type: " + date.getClass());
+        throw new ElasticSql2DslException("[syntax error] Sql cannot support such date type: " + date.getClass());
     }
 
     public static String formatDefaultEsDate(String patternArg, String timeValArg) {

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

@@ -1,6 +1,7 @@
 package org.elasticsearch.dsl.parser.helper;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLAllColumnExpr;
 import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
@@ -22,7 +23,7 @@ public class ElasticSqlIdentifierHelper {
         if (propertyNameExpr instanceof SQLMethodInvokeExpr) {
             //如果指定是inner doc类型
             SQLMethodInvokeExpr innerObjExpr = (SQLMethodInvokeExpr) propertyNameExpr;
-            if ("inner_doc".equalsIgnoreCase(innerObjExpr.getMethodName())) {
+            if (ElasticSqlMethodInvokeHelper.INNER_DOC_METHOD.equalsIgnoreCase(innerObjExpr.getMethodName())) {
                 ElasticSqlMethodInvokeHelper.checkInnerDocMethod(innerObjExpr);
 
                 ElasticSqlIdentifierHelper.parseSqlIdf(innerObjExpr.getParameters().get(0), queryAsAlias, new ElasticSqlSinglePropertyFunc() {
@@ -40,7 +41,7 @@ public class ElasticSqlIdentifierHelper {
             }
 
             //如果执行是nested doc类型
-            if ("nested_doc".equalsIgnoreCase(innerObjExpr.getMethodName())) {
+            if (ElasticSqlMethodInvokeHelper.NESTED_DOC_METHOD.equalsIgnoreCase(innerObjExpr.getMethodName())) {
                 ElasticSqlMethodInvokeHelper.checkNestedDocMethod(innerObjExpr);
 
                 ElasticSqlIdentifierHelper.parseSqlIdf(innerObjExpr.getParameters().get(0), queryAsAlias, new ElasticSqlSinglePropertyFunc() {
@@ -57,7 +58,7 @@ public class ElasticSqlIdentifierHelper {
                 return;
             }
 
-            throw new ElasticSql2DslException("[syntax error] ElasticSql identifier method only support nested_doc and inner_doc");
+            throw new ElasticSql2DslException("[syntax error] Sql identifier method only support nested_doc and inner_doc");
         }
 
         //默认按照inner doc或者property name来处理
@@ -76,12 +77,14 @@ public class ElasticSqlIdentifierHelper {
 
     private static void parseSqlIdf(final SQLExpr propertyNameExpr, final String queryAsAlias,
                                     final ElasticSqlSinglePropertyFunc singlePropertyFunc, final ElasticSqlPathPropertyFunc pathPropertyFunc) {
-        //如果标识符直接返回
-        if (propertyNameExpr instanceof SQLIdentifierExpr) {
-            singlePropertyFunc.parse(((SQLIdentifierExpr) propertyNameExpr).getName());
+        //查询所有字段
+        if (propertyNameExpr instanceof SQLAllColumnExpr) {
+            return;
         }
 
-        if (propertyNameExpr instanceof SQLPropertyExpr) {
+        if (propertyNameExpr instanceof SQLIdentifierExpr) {
+            singlePropertyFunc.parse(((SQLIdentifierExpr) propertyNameExpr).getName());
+        } else if (propertyNameExpr instanceof SQLPropertyExpr) {
             SQLPropertyExpr propertyExpr = (SQLPropertyExpr) propertyNameExpr;
             StringBuffer ownerIdfNameBuilder = new StringBuffer();
             propertyExpr.getOwner().output(ownerIdfNameBuilder);
@@ -105,6 +108,8 @@ public class ElasticSqlIdentifierHelper {
                 //如果使用未使用别名
                 pathPropertyFunc.parse(ownerIdfNameBuilder.toString(), propertyExpr.getName());
             }
+        } else {
+            throw new ElasticSql2DslException("[syntax error] Sql unSupport Identifier type: " + propertyNameExpr.getClass());
         }
     }
 

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

@@ -15,7 +15,7 @@ public class ElasticSqlMethodInvokeHelper {
 
     public static void checkDateMethod(SQLMethodInvokeExpr dateInvokeExpr) {
         if (!DATE_METHOD.equalsIgnoreCase(dateInvokeExpr.getMethodName())) {
-            throw new ElasticSql2DslException("[syntax error] ElasticSql not support method:" + dateInvokeExpr.getMethodName());
+            throw new ElasticSql2DslException("[syntax error] Sql not support method:" + dateInvokeExpr.getMethodName());
         }
 
         if (CollectionUtils.isEmpty(dateInvokeExpr.getParameters()) || dateInvokeExpr.getParameters().size() != 2) {
@@ -37,7 +37,7 @@ public class ElasticSqlMethodInvokeHelper {
 
     public static void checkInnerDocMethod(SQLMethodInvokeExpr innerDocInvokeExpr) {
         if (!INNER_DOC_METHOD.equalsIgnoreCase(innerDocInvokeExpr.getMethodName())) {
-            throw new ElasticSql2DslException("[syntax error] ElasticSql not support method:" + innerDocInvokeExpr.getMethodName());
+            throw new ElasticSql2DslException("[syntax error] Sql not support method:" + innerDocInvokeExpr.getMethodName());
         }
 
         if (CollectionUtils.isEmpty(innerDocInvokeExpr.getParameters()) || innerDocInvokeExpr.getParameters().size() != 1) {
@@ -71,7 +71,7 @@ public class ElasticSqlMethodInvokeHelper {
 
     public static void checkNvlMethod(SQLMethodInvokeExpr nvlInvokeExpr) {
         if (!NVL_METHOD.equalsIgnoreCase(nvlInvokeExpr.getMethodName())) {
-            throw new ElasticSql2DslException("[syntax error] ElasticSql sort condition only support nvl method invoke");
+            throw new ElasticSql2DslException("[syntax error] Sql sort condition only support nvl method invoke");
         }
 
         if (CollectionUtils.isEmpty(nvlInvokeExpr.getParameters()) || nvlInvokeExpr.getParameters().size() > 3) {

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

@@ -17,44 +17,44 @@ public class SqlParserOrderByTest {
         ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
 
         SortBuilder targetSort = SortBuilders.fieldSort("price").order(SortOrder.ASC);
-        Assert.assertEquals(parseResult.getSortBuilderList().get(0).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(0).toString(), targetSort.toString());
         targetSort = SortBuilders.fieldSort("id").order(SortOrder.DESC);
-        Assert.assertEquals(parseResult.getSortBuilderList().get(1).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(1).toString(), targetSort.toString());
         targetSort = SortBuilders.fieldSort("updatedAt").order(SortOrder.ASC);
-        Assert.assertEquals(parseResult.getSortBuilderList().get(2).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(2).toString(), targetSort.toString());
 
         sql = "select id,productStatus from index.trx_order order by nvl(price, 0) asc";
         sql2DslParser = new ElasticSql2DslParser();
         parseResult = sql2DslParser.parse(sql);
         targetSort = SortBuilders.fieldSort("price").order(SortOrder.ASC).missing(0);
-        Assert.assertEquals(parseResult.getSortBuilderList().get(0).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(0).toString(), targetSort.toString());
 
         sql = "select id,productStatus from index.trx_order order by nvl(inner_doc(product.price), 0) asc";
         sql2DslParser = new ElasticSql2DslParser();
         parseResult = sql2DslParser.parse(sql);
         targetSort = SortBuilders.fieldSort("product.price").order(SortOrder.ASC).missing(0);
-        Assert.assertEquals(parseResult.getSortBuilderList().get(0).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(0).toString(), targetSort.toString());
 
         sql = "select id,productStatus from index.trx_order order by nvl(nested_doc(product.price), 0) asc";
         sql2DslParser = new ElasticSql2DslParser();
         parseResult = sql2DslParser.parse(sql);
         targetSort = SortBuilders.fieldSort("price").order(SortOrder.ASC).missing(0).setNestedPath("product");
-        Assert.assertEquals(parseResult.getSortBuilderList().get(0).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(0).toString(), targetSort.toString());
 
 
         sql = "select id,productStatus from index.trx_order order by nvl(product.price, 0) asc";
         sql2DslParser = new ElasticSql2DslParser();
         parseResult = sql2DslParser.parse(sql);
         targetSort = SortBuilders.fieldSort("product.price").order(SortOrder.ASC).missing(0);
-        Assert.assertEquals(parseResult.getSortBuilderList().get(0).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(0).toString(), targetSort.toString());
 
         sql = "select id,productStatus from index.trx_order order by product.price asc,nested_doc(productTags.sortNo) desc";
         sql2DslParser = new ElasticSql2DslParser();
         parseResult = sql2DslParser.parse(sql);
         targetSort = SortBuilders.fieldSort("product.price").order(SortOrder.ASC);
-        Assert.assertEquals(parseResult.getSortBuilderList().get(0).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(0).toString(), targetSort.toString());
         targetSort = SortBuilders.fieldSort("sortNo").order(SortOrder.DESC).setNestedPath("productTags");
-        Assert.assertEquals(parseResult.getSortBuilderList().get(1).toString(), targetSort.toString());
+        Assert.assertEquals(parseResult.getOrderBy().get(1).toString(), targetSort.toString());
     }
 
 }

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

@@ -15,37 +15,37 @@ public class SqlParserWhereConditionTest  {
         ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser();
         ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
         FilterBuilder targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.termFilter("status", "SUCCESS"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where trx.price='123.4'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.termFilter("price", "123.4"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where inner_doc(product.price)='123.4'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.termFilter("product.price", "123.4"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where nested_doc(product.price)='123.4'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.nestedFilter("product", FilterBuilders.termFilter("price", "123.4")));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where nested_doc(trx.product.price)='123.4'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.nestedFilter("product", FilterBuilders.termFilter("price", "123.4")));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where nested_doc(abc.trx.product.price)='123.4'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.nestedFilter("abc.trx.product", FilterBuilders.termFilter("price", "123.4")));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where trx.product.price='123.4'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.termFilter("product.price", "123.4"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
     }
 
     @Test
@@ -56,17 +56,17 @@ public class SqlParserWhereConditionTest  {
         String sql = "select id,productStatus from index.trx_order trx where trx.price > 123.4";
         ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
         FilterBuilder targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter("price").gt(123.4));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where inner_doc(product.price) > 123.4";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter("product.price").gt(123.4));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where nested_doc(product.price) > 123.4";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.nestedFilter("product", FilterBuilders.rangeFilter("price").gt(123.4)));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
     }
 
@@ -78,28 +78,28 @@ public class SqlParserWhereConditionTest  {
         String sql = "select id,productStatus from index.trx_order trx where trx.updatedAt > '2017-01-25'";
         ElasticSqlParseResult parseResult = sql2DslParser.parse(sql);
         FilterBuilder targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter("updatedAt").gt("2017-01-25T00:00:00.000+0800"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where trx.updatedAt > '2017-01-25 13:32'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter("updatedAt").gt("2017-01-25T13:32:00.000+0800"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where trx.updatedAt > '2017-01-25 13:32:59'";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter("updatedAt").gt("2017-01-25T13:32:59.000+0800"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
         sql = "select id,productStatus from index.trx_order trx where trx.updatedAt > date('yyyy/MM/dd hh:mm:ss', '2017/01/25 13:32:59')";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter("updatedAt").gt("2017-01-25T13:32:59.000+0800"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
 
         sql = "select id,productStatus from index.trx_order trx where trx.updatedAt > date('yyyy/MM/dd hh-mm', '2017/01/25 13-32')";
         parseResult = sql2DslParser.parse(sql);
         targetFilter = FilterBuilders.boolFilter().must(FilterBuilders.rangeFilter("updatedAt").gt("2017-01-25T13:32:00.000+0800"));
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
 
 
         sql = "select id,productStatus from index.trx_order trx where trx.updatedAt between date('yyyy/MM/dd hh-mm', '2017/01/25 13-32') and '2018-10-25'";
@@ -109,7 +109,7 @@ public class SqlParserWhereConditionTest  {
                         .gte("2017-01-25T13:32:00.000+0800")
                         .lte("2018-10-25T00:00:00.000+0800")
         );
-        Assert.assertEquals(parseResult.getFilterBuilder().toString(), targetFilter.toString());
+        Assert.assertEquals(parseResult.getWhereCondition().toString(), targetFilter.toString());
     }
 
     @Test