Merge branch '2.x'

src/main/java/org/elasticsearch/dsl/parser/syntax/query/method/AbstractAtomMethodQueryParser.java

@@ -30,10 +30,10 @@ public abstract class AbstractAtomMethodQueryParser {
     protected abstract AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs);
 
 
-    public final AtomQuery parseAtomMethodQuery(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        checkQueryMethod(matchQueryExpr, queryAs, sqlArgs);
+    public final AtomQuery parseAtomMethodQuery(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        checkQueryMethod(methodQueryExpr, queryAs, sqlArgs);
 
-        return parseMethodQueryExpr(matchQueryExpr, queryAs, sqlArgs);
+        return parseMethodQueryExpr(methodQueryExpr, queryAs, sqlArgs);
     }
 
     protected AtomQuery parseCondition(SQLExpr queryFieldExpr, Object[] parameters, String queryAs, IConditionMethodQueryBuilder queryBuilder) {
@@ -73,12 +73,12 @@ public abstract class AbstractAtomMethodQueryParser {
         }
     }
 
-    protected Map<String, String> buildExtraMatchQueryParamsMap(String strMatchQueryParams) {
+    protected Map<String, String> buildExtraMethodQueryParamsMap(String strMatchQueryParams) {
         try {
             Map<String, String> extraParamMap = Maps.newHashMap();
             for (String paramPair : strMatchQueryParams.split(COMMA)) {
                 String[] paramPairArr = paramPair.split(COLON);
-                extraParamMap.put(paramPairArr[0], paramPairArr[1]);
+                extraParamMap.put(paramPairArr[0].trim(), paramPairArr[1].trim());
             }
             return extraParamMap;
         }

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

@@ -19,20 +19,20 @@ public class FullTextAtomQueryParser {
         return matchAtomQueryParser.parseAtomMethodQuery(methodQueryExpr, queryAs, sqlArgs);
     }
 
-    private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr matchQueryExpr) {
-        if (Boolean.TRUE == isMatchQuery(matchQueryExpr)) {
+    private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr methodQueryExpr) {
+        if (Boolean.TRUE == isMatchQuery(methodQueryExpr)) {
             return new MatchAtomQueryParser(parseActionListener);
         }
-        else if (Boolean.TRUE == isMatchPrefixQuery(matchQueryExpr)) {
+        else if (Boolean.TRUE == isMatchPrefixQuery(methodQueryExpr)) {
             return new MultiMatchAtomQueryParser(parseActionListener);
         }
-        else if(Boolean.TRUE == isQueryStringQuery(matchQueryExpr)) {
+        else if(Boolean.TRUE == isQueryStringQuery(methodQueryExpr)) {
             return new QueryStringAtomQueryParser(parseActionListener);
         }
-        else if(Boolean.TRUE == isSimpleQueryStringQuery(matchQueryExpr)) {
+        else if(Boolean.TRUE == isSimpleQueryStringQuery(methodQueryExpr)) {
             return new SimpleQueryStringAtomQueryParser(parseActionListener);
         }
-        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", matchQueryExpr.getMethodName()));
+        throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", methodQueryExpr.getMethodName()));
     }
 
     private Boolean isMatchQuery(SQLMethodInvokeExpr methodQueryExpr) {

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

@@ -24,17 +24,17 @@ public class MatchAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == "match".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected match query method name is [match],but get [%s]", matchQueryExpr.getMethodName()));
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "match".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected match query method name is [match],but get [%s]", methodQueryExpr.getMethodName()));
         }
 
-        int paramCount = matchQueryExpr.getParameters().size();
+        int paramCount = methodQueryExpr.getParameters().size();
         if (paramCount != 2 && paramCount != 3) {
             throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: match", paramCount));
         }
 
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
         String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
         if(StringUtils.isEmpty(text)) {
@@ -44,16 +44,16 @@ public class MatchAtomQueryParser extends AbstractAtomMethodQueryParser {
 
     @Override
     @SuppressWarnings("unchecked")
-    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        SQLExpr queryField = matchQueryExpr.getParameters().get(0);
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryField = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
         Map<String, String> extraParamMap = null;
-        if (matchQueryExpr.getParameters().size() == 3) {
-            SQLExpr ExtraParamExpr = matchQueryExpr.getParameters().get(2);
+        if (methodQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
             String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
 
-            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
         }
 
         Object text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false);

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

@@ -23,18 +23,18 @@ public class MultiMatchAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == "multiMatch".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected multiMatch query method name is [multiMatch],but get [%s]", matchQueryExpr.getMethodName()));
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "multiMatch".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected multiMatch query method name is [multiMatch],but get [%s]", methodQueryExpr.getMethodName()));
         }
 
-        int paramCount = matchQueryExpr.getParameters().size();
+        int paramCount = methodQueryExpr.getParameters().size();
         if (paramCount != 2 && paramCount != 3) {
             throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: multiMatch", paramCount));
         }
 
-        SQLExpr fieldsExpr = matchQueryExpr.getParameters().get(0);
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+        SQLExpr fieldsExpr = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
         String strFields = ElasticSqlArgTransferHelper.transferSqlArg(fieldsExpr, sqlArgs, false).toString();
         String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
@@ -48,16 +48,16 @@ public class MultiMatchAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
-    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        SQLExpr queryFields = matchQueryExpr.getParameters().get(0);
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr queryFields = methodQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(1);
 
         Map<String, String> extraParamMap = null;
-        if (matchQueryExpr.getParameters().size() == 3) {
-            SQLExpr ExtraParamExpr = matchQueryExpr.getParameters().get(2);
+        if (methodQueryExpr.getParameters().size() == 3) {
+            SQLExpr ExtraParamExpr = methodQueryExpr.getParameters().get(2);
             String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(ExtraParamExpr, sqlArgs, false).toString();
 
-            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
         }
 
         String[] fields = ElasticSqlArgTransferHelper.transferSqlArg(queryFields, sqlArgs, false).toString().split(COMMA);

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

@@ -23,17 +23,17 @@ public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == "queryString".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected queryString query method name is [queryString],but get [%s]", matchQueryExpr.getMethodName()));
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "queryString".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected queryString query method name is [queryString],but get [%s]", methodQueryExpr.getMethodName()));
         }
 
-        int paramCount = matchQueryExpr.getParameters().size();
+        int paramCount = methodQueryExpr.getParameters().size();
         if (paramCount != 1 && paramCount != 2 && paramCount != 3) {
             throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: queryString", paramCount));
         }
 
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(0);
         String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
 
         if (StringUtils.isEmpty(text)) {
@@ -41,7 +41,7 @@ public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
         }
 
         if (paramCount == 3) {
-            SQLExpr fieldsExpr = matchQueryExpr.getParameters().get(1);
+            SQLExpr fieldsExpr = methodQueryExpr.getParameters().get(1);
             String strFields = ElasticSqlArgTransferHelper.transferSqlArg(fieldsExpr, sqlArgs, false).toString();
 
             if (StringUtils.isEmpty(text)) {
@@ -60,17 +60,17 @@ public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
     }
 
     @Override
-    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(0);
 
         SQLExpr queryFields = null;
         SQLExpr extraParamExpr = null;
 
-        if (matchQueryExpr.getParameters().size() == 2) {
-            extraParamExpr = matchQueryExpr.getParameters().get(1);
-        } else if (matchQueryExpr.getParameters().size() == 3) {
-            queryFields = matchQueryExpr.getParameters().get(1);
-            extraParamExpr = matchQueryExpr.getParameters().get(2);
+        if (methodQueryExpr.getParameters().size() == 2) {
+            extraParamExpr = methodQueryExpr.getParameters().get(1);
+        } else if (methodQueryExpr.getParameters().size() == 3) {
+            queryFields = methodQueryExpr.getParameters().get(1);
+            extraParamExpr = methodQueryExpr.getParameters().get(2);
         }
 
 
@@ -93,7 +93,7 @@ public class QueryStringAtomQueryParser extends AbstractAtomMethodQueryParser {
         Map<String, String> extraParamMap = null;
         if (extraParamExpr != null) {
             String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
-            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
         }
 
 

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

@@ -25,17 +25,17 @@ public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryPar
     }
 
     @Override
-    protected void checkQueryMethod(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        if (Boolean.FALSE == "simpleQueryString".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
-            throw new ElasticSql2DslException(String.format("[syntax error] Expected simpleQueryString query method name is [simpleQueryString],but get [%s]", matchQueryExpr.getMethodName()));
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        if (Boolean.FALSE == "simpleQueryString".equalsIgnoreCase(methodQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected simpleQueryString query method name is [simpleQueryString],but get [%s]", methodQueryExpr.getMethodName()));
         }
 
-        int paramCount = matchQueryExpr.getParameters().size();
+        int paramCount = methodQueryExpr.getParameters().size();
         if (paramCount != 1 && paramCount != 2 && paramCount != 3) {
             throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: queryString", paramCount));
         }
 
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(0);
         String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
 
         if (StringUtils.isEmpty(text)) {
@@ -43,7 +43,7 @@ public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryPar
         }
 
         if (paramCount == 3) {
-            SQLExpr fieldsExpr = matchQueryExpr.getParameters().get(1);
+            SQLExpr fieldsExpr = methodQueryExpr.getParameters().get(1);
             String strFields = ElasticSqlArgTransferHelper.transferSqlArg(fieldsExpr, sqlArgs, false).toString();
 
             if (StringUtils.isEmpty(text)) {
@@ -62,17 +62,17 @@ public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryPar
     }
 
     @Override
-    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr matchQueryExpr, String queryAs, Object[] sqlArgs) {
-        SQLExpr textExpr = matchQueryExpr.getParameters().get(0);
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        SQLExpr textExpr = methodQueryExpr.getParameters().get(0);
 
         SQLExpr queryFields = null;
         SQLExpr extraParamExpr = null;
 
-        if (matchQueryExpr.getParameters().size() == 2) {
-            extraParamExpr = matchQueryExpr.getParameters().get(1);
-        } else if (matchQueryExpr.getParameters().size() == 3) {
-            queryFields = matchQueryExpr.getParameters().get(1);
-            extraParamExpr = matchQueryExpr.getParameters().get(2);
+        if (methodQueryExpr.getParameters().size() == 2) {
+            extraParamExpr = methodQueryExpr.getParameters().get(1);
+        } else if (methodQueryExpr.getParameters().size() == 3) {
+            queryFields = methodQueryExpr.getParameters().get(1);
+            extraParamExpr = methodQueryExpr.getParameters().get(2);
         }
 
 
@@ -91,7 +91,7 @@ public class SimpleQueryStringAtomQueryParser extends AbstractAtomMethodQueryPar
         Map<String, String> extraParamMap = null;
         if (extraParamExpr != null) {
             String extraParam = ElasticSqlArgTransferHelper.transferSqlArg(extraParamExpr, sqlArgs, false).toString();
-            extraParamMap = buildExtraMatchQueryParamsMap(extraParam);
+            extraParamMap = buildExtraMethodQueryParamsMap(extraParam);
         }
 
 

src/main/java/org/elasticsearch/dsl/parser/syntax/query/method/term/PrefixAtomQueryParser.java

@@ -0,0 +1,40 @@
+package org.elasticsearch.dsl.parser.syntax.query.method.term;
+
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import org.elasticsearch.dsl.bean.AtomQuery;
+import org.elasticsearch.dsl.parser.listener.ParseActionListener;
+import org.elasticsearch.dsl.parser.syntax.query.method.AbstractAtomMethodQueryParser;
+
+public class PrefixAtomQueryParser extends AbstractAtomMethodQueryParser {
+
+    public PrefixAtomQueryParser(ParseActionListener parseActionListener) {
+        super(parseActionListener);
+    }
+
+    @Override
+    protected void checkQueryMethod(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        /*
+        if (Boolean.FALSE == "match".equalsIgnoreCase(matchQueryExpr.getMethodName())) {
+            throw new ElasticSql2DslException(String.format("[syntax error] Expected match query method name is [match],but get [%s]", matchQueryExpr.getMethodName()));
+        }
+
+        int paramCount = matchQueryExpr.getParameters().size();
+        if (paramCount != 2 && paramCount != 3) {
+            throw new ElasticSql2DslException(String.format("[syntax error] There's no %s args method: match", paramCount));
+        }
+
+        SQLExpr textExpr = matchQueryExpr.getParameters().get(1);
+
+        String text = ElasticSqlArgTransferHelper.transferSqlArg(textExpr, sqlArgs, false).toString();
+        if(StringUtils.isEmpty(text)) {
+            throw new ElasticSql2DslException("[syntax error] Search text can not be blank!");
+        }
+        */
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected AtomQuery parseMethodQueryExpr(SQLMethodInvokeExpr methodQueryExpr, String queryAs, Object[] sqlArgs) {
+        return null;
+    }
+}

src/main/java/org/elasticsearch/dsl/parser/syntax/query/method/term/TermLevelAtomMethodQueryParser.java

@@ -21,12 +21,12 @@ public class TermLevelAtomMethodQueryParser {
 
     private AbstractAtomMethodQueryParser getQueryParser(SQLMethodInvokeExpr methodQueryExpr) {
         if (Boolean.TRUE == isPrefixQuery(methodQueryExpr)) {
-            //todo ..
+            return new PrefixAtomQueryParser(parseActionListener);
         }
         throw new ElasticSql2DslException(String.format("[syntax error] Can not support method query expr[%s] condition", methodQueryExpr.getMethodName()));
     }
 
-    private Boolean isPrefixQuery(SQLMethodInvokeExpr matchQueryExpr) {
-        return "prefix".equalsIgnoreCase(matchQueryExpr.getMethodName());
+    private Boolean isPrefixQuery(SQLMethodInvokeExpr methodQueryExpr) {
+        return "prefix".equalsIgnoreCase(methodQueryExpr.getMethodName());
     }
 }