(improvement)(Headless) JsqlParser upgrade to 4.7 (#931)

common/src/main/java/com/tencent/supersonic/common/util/ChatGptHelper.java

@@ -7,15 +7,14 @@ import com.plexpt.chatgpt.entity.chat.ChatCompletion;
 import com.plexpt.chatgpt.entity.chat.ChatCompletionResponse;
 import com.plexpt.chatgpt.entity.chat.Message;
 import com.plexpt.chatgpt.util.Proxys;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Component;
-
 import java.net.Proxy;
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
 
 
 @Component
@@ -49,7 +48,7 @@ public class ChatGptHelper {
     }
 
     public Message getChatCompletion(Message system, Message message) {
-        List<Message> messages ;
+        List<Message> messages;
         if (StrUtil.isBlank(system.getContent())) {
             messages = Arrays.asList(message);
         } else {

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/DateFunctionHelper.java

@@ -2,18 +2,18 @@ package com.tencent.supersonic.common.util.jsqlparser;
 
 import com.tencent.supersonic.common.util.DatePeriodEnum;
 import com.tencent.supersonic.common.util.DateUtils;
-import java.util.List;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.expression.DoubleValue;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.LongValue;
 import net.sf.jsqlparser.expression.StringValue;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 
 @Slf4j
 public class DateFunctionHelper {
 
-    public static String getStartDateStr(ComparisonOperator minorThanEquals, List<Expression> expressions) {
+    public static String getStartDateStr(ComparisonOperator minorThanEquals, ExpressionList<?> expressions) {
         String unitValue = getUnit(expressions);
         String dateValue = getEndDateValue(expressions);
         String dateStr = "";
@@ -38,12 +38,12 @@ public class DateFunctionHelper {
         return "<=";
     }
 
-    public static String getEndDateValue(List<Expression> leftExpressions) {
+    public static String getEndDateValue(ExpressionList<?> leftExpressions) {
         StringValue date = (StringValue) leftExpressions.get(2);
         return date.getValue();
     }
 
-    private static String getUnit(List<Expression> expressions) {
+    private static String getUnit(ExpressionList<?> expressions) {
         StringValue unit = (StringValue) expressions.get(0);
         return unit.getValue();
     }

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/ExpressionReplaceVisitor.java

@@ -1,7 +1,5 @@
 package com.tencent.supersonic.common.util.jsqlparser;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import net.sf.jsqlparser.expression.BinaryExpression;
@@ -9,6 +7,7 @@ import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
 import net.sf.jsqlparser.expression.Function;
 import net.sf.jsqlparser.expression.WhenClause;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.schema.Column;
 
 public class ExpressionReplaceVisitor extends ExpressionVisitorAdapter {
@@ -80,12 +79,12 @@ public class ExpressionReplaceVisitor extends ExpressionVisitorAdapter {
             Expression expression = QueryExpressionReplaceVisitor.getExpression(
                     QueryExpressionReplaceVisitor.getReplaceExpr(function, fieldExprMap));
             if (Objects.nonNull(expression)) {
-                List<Expression> expressions = new ArrayList<>();
+                ExpressionList<Expression> expressions = new ExpressionList<>();
                 expressions.add(expression);
-                for (int i = 1; i < function.getParameters().getExpressions().size(); i++) {
+                for (int i = 1; i < function.getParameters().size(); i++) {
-                    expressions.add(function.getParameters().getExpressions().get(i));
+                    expressions.add((Expression) function.getParameters().get(i));
                 }
-                function.getParameters().setExpressions(expressions);
+                function.setParameters(expressions);
                 return true;
             }
         }

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/FieldAndValueAcquireVisitor.java

@@ -19,7 +19,6 @@ import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
 import net.sf.jsqlparser.expression.operators.relational.InExpression;
-import net.sf.jsqlparser.expression.operators.relational.ItemsList;
 import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
 import net.sf.jsqlparser.expression.operators.relational.MinorThan;
 import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
@@ -58,7 +57,7 @@ public class FieldAndValueAcquireVisitor extends ExpressionVisitorAdapter {
         }
         fieldExpression.setFieldName(((Column) leftExpression).getColumnName());
         fieldExpression.setOperator(JsqlConstants.IN);
-        ItemsList rightItemsList = expr.getRightItemsList();
+        Expression rightItemsList = expr.getRightExpression();
         fieldExpression.setFieldValue(rightItemsList);
         List<Object> result = new ArrayList<>();
         if (rightItemsList instanceof ExpressionList) {
@@ -143,7 +142,8 @@ public class FieldAndValueAcquireVisitor extends ExpressionVisitorAdapter {
     }
 
     private Column getColumn(Function leftExpressionFunction) {
-        List<Expression> leftExpressions = leftExpressionFunction.getParameters().getExpressions();
+        //List<Expression> leftExpressions = leftExpressionFunction.getParameters().getExpressions();
+        ExpressionList<?> leftExpressions = leftExpressionFunction.getParameters();
         if (CollectionUtils.isEmpty(leftExpressions)) {
             return null;
         }

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/FieldlValueReplaceVisitor.java

@@ -1,11 +1,10 @@
 package com.tencent.supersonic.common.util.jsqlparser;
 
-import java.util.List;
+import com.tencent.supersonic.common.util.JsonUtil;
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-
-import com.tencent.supersonic.common.util.JsonUtil;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.expression.DoubleValue;
 import net.sf.jsqlparser.expression.Expression;
@@ -15,12 +14,12 @@ import net.sf.jsqlparser.expression.LongValue;
 import net.sf.jsqlparser.expression.StringValue;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
 import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
+import net.sf.jsqlparser.expression.operators.relational.InExpression;
 import net.sf.jsqlparser.expression.operators.relational.MinorThan;
 import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
-import net.sf.jsqlparser.expression.operators.relational.InExpression;
-import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.schema.Column;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.util.CollectionUtils;
@@ -64,7 +63,7 @@ public class FieldlValueReplaceVisitor extends ExpressionVisitorAdapter {
         }
         Column column = (Column) inExpression.getLeftExpression();
         Map<String, String> valueMap = filedNameToValueMap.get(column.getColumnName());
-        ExpressionList rightItemsList = (ExpressionList) inExpression.getRightItemsList();
+        ExpressionList rightItemsList = (ExpressionList) inExpression.getRightExpression();
         List<Expression> expressions = rightItemsList.getExpressions();
         List<String> values = new ArrayList<>();
         expressions.stream().forEach(o -> {
@@ -86,7 +85,7 @@ public class FieldlValueReplaceVisitor extends ExpressionVisitorAdapter {
             newExpressions.add(stringValue);
         });
         rightItemsList.setExpressions(newExpressions);
-        inExpression.setRightItemsList(rightItemsList);
+        inExpression.setRightExpression(rightItemsList);
     }
 
     public <T extends Expression> void replaceComparisonExpression(T expression) {

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/FiledFilterReplaceVisitor.java

@@ -11,6 +11,7 @@ import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
 import net.sf.jsqlparser.expression.Function;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
 import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
 import net.sf.jsqlparser.expression.operators.relational.MinorThan;
@@ -85,7 +86,8 @@ public class FiledFilterReplaceVisitor extends ExpressionVisitorAdapter {
             return result;
         }
 
-        List<Expression> leftExpressions = leftExpressionFunction.getParameters().getExpressions();
+        //List<Expression> leftExpressions = leftExpressionFunction.getParameters().getExpressions();
+        ExpressionList<?> leftExpressions = leftExpressionFunction.getParameters();
         if (CollectionUtils.isEmpty(leftExpressions)) {
             return result;
         }

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/FunctionAliasReplaceVisitor.java

@@ -4,7 +4,7 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import net.sf.jsqlparser.expression.Function;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
+import net.sf.jsqlparser.statement.select.SelectItem;
 import net.sf.jsqlparser.statement.select.SelectItemVisitorAdapter;
 
 public class FunctionAliasReplaceVisitor extends SelectItemVisitorAdapter {
@@ -12,7 +12,7 @@ public class FunctionAliasReplaceVisitor extends SelectItemVisitorAdapter {
     private Map<String, String> aliasToActualExpression = new HashMap<>();
 
     @Override
-    public void visit(SelectExpressionItem selectExpressionItem) {
+    public void visit(SelectItem selectExpressionItem) {
         if (selectExpressionItem.getExpression() instanceof Function) {
             Function function = (Function) selectExpressionItem.getExpression();
             String columnName = SqlSelectHelper.getColumnName(function);

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/FunctionReplaceVisitor.java

@@ -12,6 +12,7 @@ import net.sf.jsqlparser.expression.Function;
 import net.sf.jsqlparser.expression.LongValue;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
 import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
 import net.sf.jsqlparser.expression.operators.relational.MinorThan;
@@ -79,7 +80,8 @@ public class FunctionReplaceVisitor extends ExpressionVisitorAdapter {
         if (!leftExpressionFunction.toString().contains(JsqlConstants.DATE_FUNCTION)) {
             return result;
         }
-        List<Expression> leftExpressions = leftExpressionFunction.getParameters().getExpressions();
+        //List<Expression> leftExpressions = leftExpressionFunction.getParameters().getExpressions();
+        ExpressionList<?> leftExpressions = leftExpressionFunction.getParameters();
         if (CollectionUtils.isEmpty(leftExpressions) || leftExpressions.size() < 3) {
             return result;
         }

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/GroupByReplaceVisitor.java

@@ -47,7 +47,14 @@ public class GroupByReplaceVisitor implements GroupByVisitor {
                 if (expression instanceof Function) {
                     try {
                         Expression element = CCJSqlParserUtil.parseExpression(replaceColumn);
-                        ((Function) expression).getParameters().getExpressions().set(0, element);
+                        ExpressionList<Expression> expressionList = new ExpressionList<Expression>();
+                        expressionList.add(element);
+                        if (((Function) expression).getParameters().size() > 1) {
+                            ((Function) expression).getParameters().stream().skip(1).forEach(e -> {
+                                expressionList.add((Function) e);
+                            });
+                        }
+                        ((Function) expression).setParameters(expressionList);
                     } catch (JSQLParserException e) {
                         log.error("e", e);
                     }

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/OrderByAcquireVisitor.java

@@ -1,10 +1,10 @@
 package com.tencent.supersonic.common.util.jsqlparser;
 
 import com.tencent.supersonic.common.pojo.Constants;
-import java.util.List;
 import java.util.Set;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.Function;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.statement.select.OrderByElement;
 import net.sf.jsqlparser.statement.select.OrderByVisitorAdapter;
@@ -26,7 +26,8 @@ public class OrderByAcquireVisitor extends OrderByVisitorAdapter {
         }
         if (expression instanceof Function) {
             Function function = (Function) expression;
-            List<Expression> expressions = function.getParameters().getExpressions();
+            //List<Expression> expressions = function.getParameters().getExpressions();
+            ExpressionList<?> expressions = function.getParameters();
             for (Expression column : expressions) {
                 if (column instanceof Column) {
                     fieldExpression.setFieldName(((Column) column).getColumnName());

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/OrderByReplaceVisitor.java

@@ -1,9 +1,9 @@
 package com.tencent.supersonic.common.util.jsqlparser;
 
-import java.util.List;
 import java.util.Map;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.Function;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.statement.select.OrderByElement;
 import net.sf.jsqlparser.statement.select.OrderByVisitorAdapter;
@@ -27,7 +27,8 @@ public class OrderByReplaceVisitor extends OrderByVisitorAdapter {
         }
         if (expression instanceof Function) {
             Function function = (Function) expression;
-            List<Expression> expressions = function.getParameters().getExpressions();
+            //List<Expression> expressions = function.getParameters().getExpressions();
+            ExpressionList<?> expressions = function.getParameters();
             for (Expression column : expressions) {
                 if (column instanceof Column) {
                     parseVisitorHelper.replaceColumn((Column) column, fieldNameMap, exactReplace);

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/QueryExpressionReplaceVisitor.java

@@ -9,7 +9,7 @@ import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
 import net.sf.jsqlparser.expression.Function;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Column;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
+import net.sf.jsqlparser.statement.select.SelectItem;
 
 public class QueryExpressionReplaceVisitor extends ExpressionVisitorAdapter {
 
@@ -43,7 +43,7 @@ public class QueryExpressionReplaceVisitor extends ExpressionVisitorAdapter {
 
     }
 
-    public void visit(SelectExpressionItem selectExpressionItem) {
+    public void visit(SelectItem selectExpressionItem) {
 
         Expression expression = selectExpressionItem.getExpression();
         String toReplace = "";

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlAddHelper.java

@@ -1,11 +1,10 @@
 package com.tencent.supersonic.common.util.jsqlparser;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import java.util.ArrayList;
-
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.Function;
@@ -21,8 +20,6 @@ import net.sf.jsqlparser.statement.select.GroupByElement;
 import net.sf.jsqlparser.statement.select.OrderByElement;
 import net.sf.jsqlparser.statement.select.PlainSelect;
 import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectBody;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
 import net.sf.jsqlparser.statement.select.SelectItem;
 import net.sf.jsqlparser.statement.select.SelectVisitorAdapter;
 import net.sf.jsqlparser.statement.select.SetOperationList;
@@ -41,21 +38,23 @@ public class SqlAddHelper {
         if (selectStatement == null) {
             return null;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (selectBody instanceof PlainSelect) {
+        if (selectStatement instanceof PlainSelect) {
-            PlainSelect plainSelect = (PlainSelect) selectBody;
+            PlainSelect plainSelect = (PlainSelect) selectStatement;
             fields.stream().filter(Objects::nonNull).forEach(field -> {
-                SelectExpressionItem selectExpressionItem = new SelectExpressionItem(new Column(field));
+                //SelectExpressionItem selectExpressionItem = new SelectExpressionItem(new Column(field));
+                SelectItem<Column> selectExpressionItem = new SelectItem(new Column(field));
                 plainSelect.addSelectItems(selectExpressionItem);
             });
 
-        } else if (selectBody instanceof SetOperationList) {
+        } else if (selectStatement instanceof SetOperationList) {
-            SetOperationList setOperationList = (SetOperationList) selectBody;
+            SetOperationList setOperationList = (SetOperationList) selectStatement;
             if (!CollectionUtils.isEmpty(setOperationList.getSelects())) {
                 setOperationList.getSelects().forEach(subSelectBody -> {
                     PlainSelect subPlainSelect = (PlainSelect) subSelectBody;
                     fields.stream().forEach(field -> {
-                        SelectExpressionItem selectExpressionItem = new SelectExpressionItem(new Column(field));
+                        //SelectExpressionItem selectExpressionItem = new SelectExpressionItem(new Column(field));
+                        SelectItem<Column> selectExpressionItem = new SelectItem(new Column(field));
                         subPlainSelect.addSelectItems(selectExpressionItem);
                     });
                 });
@@ -69,14 +68,14 @@ public class SqlAddHelper {
         if (selectStatement == null) {
             return null;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
         List<PlainSelect> plainSelectList = new ArrayList<>();
-        if (selectBody instanceof PlainSelect) {
+        if (selectStatement instanceof PlainSelect) {
-            PlainSelect plainSelect = (PlainSelect) selectBody;
+            PlainSelect plainSelect = (PlainSelect) selectStatement.getPlainSelect();
             plainSelectList.add(plainSelect);
-        } else if (selectBody instanceof SetOperationList) {
+        } else if (selectStatement instanceof SetOperationList) {
-            SetOperationList setOperationList = (SetOperationList) selectBody;
+            SetOperationList setOperationList = (SetOperationList) selectStatement.getSetOperationList();
             if (!CollectionUtils.isEmpty(setOperationList.getSelects())) {
                 setOperationList.getSelects().forEach(subSelectBody -> {
                     PlainSelect subPlainSelect = (PlainSelect) subSelectBody;
@@ -89,16 +88,16 @@ public class SqlAddHelper {
             return sql;
         }
         for (PlainSelect plainSelect : plainSelectList) {
-            List<SelectItem> selectItems = plainSelect.getSelectItems();
+            List<SelectItem<?>> selectItems = plainSelect.getSelectItems();
             if (CollectionUtils.isEmpty(selectItems)) {
                 continue;
             }
             boolean existFunction = false;
             for (Expression expression : expressionList) {
                 for (SelectItem selectItem : selectItems) {
-                    SelectExpressionItem expressionItem = (SelectExpressionItem) selectItem;
+                    //SelectExpressionItem expressionItem = (SelectExpressionItem) selectItem;
-                    if (expressionItem.getExpression() instanceof Function) {
+                    if (selectItem.getExpression() instanceof Function) {
-                        Function expressionFunction = (Function) expressionItem.getExpression();
+                        Function expressionFunction = (Function) selectItem.getExpression();
                         if (expression.toString().equalsIgnoreCase(expressionFunction.toString())) {
                             existFunction = true;
                             break;
@@ -106,7 +105,8 @@ public class SqlAddHelper {
                     }
                 }
                 if (!existFunction) {
-                    SelectExpressionItem sumExpressionItem = new SelectExpressionItem(expression);
+                    //SelectExpressionItem sumExpressionItem = new SelectExpressionItem(expression);
+                    SelectItem sumExpressionItem = new SelectItem(expression);
                     selectItems.add(sumExpressionItem);
                 }
             }
@@ -119,12 +119,12 @@ public class SqlAddHelper {
             return sql;
         }
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         Expression where = plainSelect.getWhere();
 
         Expression right = new StringValue(value.toString());
@@ -142,12 +142,12 @@ public class SqlAddHelper {
 
     public static String addWhere(String sql, Expression expression) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         Expression where = plainSelect.getWhere();
 
         if (where == null) {
@@ -160,9 +160,9 @@ public class SqlAddHelper {
 
     public static String addWhere(String sql, List<Expression> expressionList) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
         if (CollectionUtils.isEmpty(expressionList)) {
@@ -172,7 +172,7 @@ public class SqlAddHelper {
         for (int i = 1; i < expressionList.size(); i++) {
             expression = new AndExpression(expression, expressionList.get(i));
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         Expression where = plainSelect.getWhere();
 
         if (where == null) {
@@ -185,12 +185,12 @@ public class SqlAddHelper {
 
     public static String addAggregateToField(String sql, Map<String, String> fieldNameToAggregate) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        selectBody.accept(new SelectVisitorAdapter() {
+        selectStatement.accept(new SelectVisitorAdapter() {
             @Override
             public void visit(PlainSelect plainSelect) {
                 addAggregateToSelectItems(plainSelect.getSelectItems(), fieldNameToAggregate);
@@ -207,13 +207,13 @@ public class SqlAddHelper {
             return sql;
         }
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
 
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         GroupByElement groupByElement = new GroupByElement();
         List<String> originalGroupByFields = SqlSelectHelper.getGroupByFields(sql);
         if (!CollectionUtils.isEmpty(originalGroupByFields)) {
@@ -226,23 +226,20 @@ public class SqlAddHelper {
         return selectStatement.toString();
     }
 
-    private static void addAggregateToSelectItems(List<SelectItem> selectItems,
+    private static void addAggregateToSelectItems(List<SelectItem<?>> selectItems,
-                                                  Map<String, String> fieldNameToAggregate) {
+            Map<String, String> fieldNameToAggregate) {
         for (SelectItem selectItem : selectItems) {
-            if (selectItem instanceof SelectExpressionItem) {
+            Expression expression = selectItem.getExpression();
-                SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
+            Function function = SqlSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
-                Expression expression = selectExpressionItem.getExpression();
+            if (function == null) {
-                Function function = SqlSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
+                continue;
-                if (function == null) {
-                    continue;
-                }
-                selectExpressionItem.setExpression(function);
             }
+            selectItem.setExpression(function);
         }
     }
 
     private static void addAggregateToOrderByItems(List<OrderByElement> orderByElements,
-                                                   Map<String, String> fieldNameToAggregate) {
+            Map<String, String> fieldNameToAggregate) {
         if (orderByElements == null) {
             return;
         }
@@ -257,11 +254,12 @@ public class SqlAddHelper {
     }
 
     private static void addAggregateToGroupByItems(GroupByElement groupByElement,
-                                                   Map<String, String> fieldNameToAggregate) {
+            Map<String, String> fieldNameToAggregate) {
         if (groupByElement == null) {
             return;
         }
-        for (Expression expression : groupByElement.getGroupByExpressions()) {
+        for (int i = 0; i < groupByElement.getGroupByExpressionList().size(); i++) {
+            Expression expression = (Expression) groupByElement.getGroupByExpressionList().get(i);
             Function function = SqlSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
             if (function == null) {
                 continue;
@@ -278,7 +276,7 @@ public class SqlAddHelper {
     }
 
     private static void modifyWhereExpression(Expression whereExpression,
-                                              Map<String, String> fieldNameToAggregate) {
+            Map<String, String> fieldNameToAggregate) {
         if (SqlSelectHelper.isLogicExpression(whereExpression)) {
             if (whereExpression instanceof AndExpression) {
                 AndExpression andExpression = (AndExpression) whereExpression;
@@ -326,13 +324,13 @@ public class SqlAddHelper {
 
     public static String addHaving(String sql, Set<String> fieldNames) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
 
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         //replace metric to 1 and 1 and add having metric
         Expression where = plainSelect.getWhere();
         FiledFilterReplaceVisitor visitor = new FiledFilterReplaceVisitor(fieldNames);
@@ -355,9 +353,9 @@ public class SqlAddHelper {
 
     public static String addHaving(String sql, List<Expression> expressionList) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
         if (CollectionUtils.isEmpty(expressionList)) {
@@ -367,7 +365,7 @@ public class SqlAddHelper {
         for (int i = 1; i < expressionList.size(); i++) {
             expression = new AndExpression(expression, expressionList.get(i));
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         Expression having = plainSelect.getHaving();
 
         if (having == null) {
@@ -380,12 +378,12 @@ public class SqlAddHelper {
 
     public static String addParenthesisToWhere(String sql) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         Expression where = plainSelect.getWhere();
         if (Objects.nonNull(where)) {
             Parenthesis parenthesis = new Parenthesis(where);

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlRemoveHelper.java

@@ -1,5 +1,9 @@
 package com.tencent.supersonic.common.util.jsqlparser;
 
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.expression.BinaryExpression;
@@ -10,7 +14,6 @@ import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
 import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
 import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
-import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
 import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
@@ -18,22 +21,16 @@ import net.sf.jsqlparser.expression.operators.relational.InExpression;
 import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
 import net.sf.jsqlparser.expression.operators.relational.MinorThan;
 import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
+import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.statement.select.GroupByElement;
 import net.sf.jsqlparser.statement.select.PlainSelect;
 import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectBody;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
 import net.sf.jsqlparser.statement.select.SelectItem;
 import net.sf.jsqlparser.statement.select.SelectVisitorAdapter;
 import org.springframework.util.CollectionUtils;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.Objects;
-
 /**
  * Sql Parser remove Helper
  */
@@ -45,18 +42,14 @@ public class SqlRemoveHelper {
         if (selectStatement == null) {
             return sql;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        List<SelectItem> selectItems = ((PlainSelect) selectBody).getSelectItems();
+        List<SelectItem<?>> selectItems = ((PlainSelect) selectStatement).getSelectItems();
         selectItems.removeIf(selectItem -> {
-            if (selectItem instanceof SelectExpressionItem) {
+            String columnName = SqlSelectHelper.getColumnName(selectItem.getExpression());
-                SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
+            return fields.contains(columnName);
-                String columnName = SqlSelectHelper.getColumnName(selectExpressionItem.getExpression());
-                return fields.contains(columnName);
-            }
-            return false;
         });
         return selectStatement.toString();
     }
@@ -66,35 +59,32 @@ public class SqlRemoveHelper {
         if (selectStatement == null) {
             return sql;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        List<SelectItem> selectItems = ((PlainSelect) selectBody).getSelectItems();
+        List<SelectItem<?>> selectItems = ((PlainSelect) selectStatement).getSelectItems();
         Set<String> fields = new HashSet<>();
         selectItems.removeIf(selectItem -> {
-            if (selectItem instanceof SelectExpressionItem) {
+            String field = selectItem.getExpression().toString();
-                SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
+            if (fields.contains(field)) {
-                String field = selectExpressionItem.getExpression().toString();
+                return true;
-                if (fields.contains(field)) {
-                    return true;
-                }
-                fields.add(field);
             }
+            fields.add(field);
             return false;
         });
-        ((PlainSelect) selectBody).setSelectItems(selectItems);
+        ((PlainSelect) selectStatement).setSelectItems(selectItems);
         return selectStatement.toString();
     }
 
     public static String removeWhereCondition(String sql, Set<String> removeFieldNames) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        selectBody.accept(new SelectVisitorAdapter() {
+        selectStatement.accept(new SelectVisitorAdapter() {
             @Override
             public void visit(PlainSelect plainSelect) {
                 removeWhereCondition(plainSelect.getWhere(), removeFieldNames);
@@ -115,16 +105,16 @@ public class SqlRemoveHelper {
         if (selectStatement == null) {
             return sql;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        Expression where = ((PlainSelect) selectBody).getWhere();
+        Expression where = ((PlainSelect) selectStatement).getWhere();
-        Expression having = ((PlainSelect) selectBody).getHaving();
+        Expression having = ((PlainSelect) selectStatement).getHaving();
         try {
-            ((PlainSelect) selectBody).setWhere(filteredExpression(where, SqlEditEnum.NUMBER_FILTER));
+            ((PlainSelect) selectStatement).setWhere(filteredExpression(where, SqlEditEnum.NUMBER_FILTER));
-            ((PlainSelect) selectBody).setHaving(filteredExpression(having, SqlEditEnum.NUMBER_FILTER));
+            ((PlainSelect) selectStatement).setHaving(filteredExpression(having, SqlEditEnum.NUMBER_FILTER));
         } catch (Exception e) {
             log.info("replaceFunction has an exception:{}", e.toString());
         }
@@ -194,7 +184,8 @@ public class SqlRemoveHelper {
                 InExpression constantExpression = (InExpression) CCJSqlParserUtil.parseCondExpression(
                         JsqlConstants.IN_CONSTANT);
                 inExpression.setLeftExpression(constantExpression.getLeftExpression());
-                inExpression.setRightItemsList(constantExpression.getRightItemsList());
+                //inExpression.setRightItemsList(constantExpression.getRightItemsList());
+                inExpression.setRightExpression(constantExpression.getRightExpression());
                 inExpression.setASTNode(constantExpression.getASTNode());
             } catch (JSQLParserException e) {
                 log.error("JSQLParserException", e);
@@ -220,12 +211,12 @@ public class SqlRemoveHelper {
 
     public static String removeHavingCondition(String sql, Set<String> removeFieldNames) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        selectBody.accept(new SelectVisitorAdapter() {
+        selectStatement.accept(new SelectVisitorAdapter() {
             @Override
             public void visit(PlainSelect plainSelect) {
                 removeWhereCondition(plainSelect.getHaving(), removeFieldNames);
@@ -239,11 +230,11 @@ public class SqlRemoveHelper {
         if (selectStatement == null) {
             return sql;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        GroupByElement groupByElement = ((PlainSelect) selectBody).getGroupBy();
+        GroupByElement groupByElement = ((PlainSelect) selectStatement).getGroupBy();
         if (groupByElement == null) {
             return sql;
         }
@@ -256,7 +247,7 @@ public class SqlRemoveHelper {
             return false;
         });
         if (CollectionUtils.isEmpty(groupByExpressionList.getExpressions())) {
-            ((PlainSelect) selectBody).setGroupByElement(null);
+            ((PlainSelect) selectStatement).setGroupByElement(null);
         }
         return selectStatement.toString();
     }

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlReplaceHelper.java

@@ -16,6 +16,7 @@ import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
 import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
 import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
 import net.sf.jsqlparser.expression.operators.relational.MinorThan;
@@ -27,14 +28,13 @@ import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.select.GroupByElement;
 import net.sf.jsqlparser.statement.select.Join;
 import net.sf.jsqlparser.statement.select.OrderByElement;
+import net.sf.jsqlparser.statement.select.ParenthesedFromItem;
+import net.sf.jsqlparser.statement.select.ParenthesedSelect;
 import net.sf.jsqlparser.statement.select.PlainSelect;
 import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectBody;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
 import net.sf.jsqlparser.statement.select.SelectItem;
 import net.sf.jsqlparser.statement.select.SelectVisitorAdapter;
 import net.sf.jsqlparser.statement.select.SetOperationList;
-import net.sf.jsqlparser.statement.select.SubSelect;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import org.springframework.util.CollectionUtils;
@@ -47,12 +47,13 @@ public class SqlReplaceHelper {
 
     public static String replaceSelectFields(String sql, Map<String, String> fieldNameMap) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        ((PlainSelect) selectBody).getSelectItems().stream().forEach(o -> {
+        ((PlainSelect) selectStatement).getSelectItems().stream().forEach(o -> {
-            SelectExpressionItem selectExpressionItem = (SelectExpressionItem) o;
+            //SelectExpressionItem selectExpressionItem = (SelectExpressionItem) o;
+            SelectItem selectExpressionItem = (SelectItem) o;
             String alias = "";
             if (selectExpressionItem.getExpression() instanceof Function) {
                 Function function = (Function) selectExpressionItem.getExpression();
@@ -60,9 +61,7 @@ public class SqlReplaceHelper {
                 if (fieldNameMap.containsKey(column.getColumnName())) {
                     String value = fieldNameMap.get(column.getColumnName());
                     alias = value;
-                    List<Expression> expressions = new ArrayList<>();
+                    function.withParameters(new Column(value));
-                    expressions.add(new Column(value));
-                    function.getParameters().setExpressions(expressions);
                 }
             }
             if (selectExpressionItem.getExpression() instanceof Column) {
@@ -85,12 +84,12 @@ public class SqlReplaceHelper {
 
     public static String replaceAggFields(String sql, Map<String, Pair<String, String>> fieldNameToAggMap) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        ((PlainSelect) selectBody).getSelectItems().stream().forEach(o -> {
+        ((PlainSelect) selectStatement).getSelectItems().stream().forEach(o -> {
-            SelectExpressionItem selectExpressionItem = (SelectExpressionItem) o;
+            SelectItem selectExpressionItem = (SelectItem) o;
             if (selectExpressionItem.getExpression() instanceof Function) {
                 Function function = (Function) selectExpressionItem.getExpression();
                 Column column = (Column) function.getParameters().getExpressions().get(0);
@@ -104,9 +103,7 @@ public class SqlReplaceHelper {
                     } else {
                         function.setName(func);
                     }
-                    List<Expression> expressions = new ArrayList<>();
+                    function.withParameters(new Column(field));
-                    expressions.add(new Column(field));
-                    function.getParameters().setExpressions(expressions);
                     if (Objects.nonNull(selectExpressionItem.getAlias()) && StringUtils.isNotBlank(field)) {
                         selectExpressionItem.getAlias().setName(field);
                     }
@@ -123,12 +120,12 @@ public class SqlReplaceHelper {
     public static String replaceValue(String sql, Map<String, Map<String, String>> filedNameToValueMap,
             boolean exactReplace) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
         List<PlainSelect> plainSelectList = new ArrayList<>();
-        plainSelectList.add((PlainSelect) selectBody);
+        plainSelectList.add((PlainSelect) selectStatement);
         List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             Expression where = plainSelect.getWhere();
@@ -142,12 +139,12 @@ public class SqlReplaceHelper {
 
     public static String replaceFieldNameByValue(String sql, Map<String, Set<String>> fieldValueToFieldNames) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
         List<PlainSelect> plainSelectList = new ArrayList<>();
-        plainSelectList.add((PlainSelect) selectBody);
+        plainSelectList.add((PlainSelect) selectStatement);
         List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             Expression where = plainSelect.getWhere();
@@ -166,20 +163,17 @@ public class SqlReplaceHelper {
     public static String replaceFields(String sql, Map<String, String> fieldNameMap, boolean exactReplace) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
         System.out.println(selectStatement.getSelectBody());
-        SelectBody selectBody = selectStatement.getSelectBody();
         List<PlainSelect> plainSelectList = new ArrayList<>();
-        if (selectBody instanceof PlainSelect) {
+        if (selectStatement instanceof PlainSelect) {
-            plainSelectList.add((PlainSelect) selectBody);
+            plainSelectList.add((PlainSelect) selectStatement);
-        } else if (selectBody instanceof SetOperationList) {
+        } else if (selectStatement instanceof SetOperationList) {
-            SetOperationList setOperationList = (SetOperationList) selectBody;
+            SetOperationList setOperationList = (SetOperationList) selectStatement;
-            //replace select
             if (!CollectionUtils.isEmpty(setOperationList.getSelects())) {
                 setOperationList.getSelects().forEach(subSelectBody -> {
                     PlainSelect subPlainSelect = (PlainSelect) subSelectBody;
                     plainSelectList.add(subPlainSelect);
                 });
             }
-            //replace order by
             List<OrderByElement> orderByElements = setOperationList.getOrderByElements();
             if (!CollectionUtils.isEmpty(orderByElements)) {
                 for (OrderByElement orderByElement : orderByElements) {
@@ -232,12 +226,12 @@ public class SqlReplaceHelper {
         if (!CollectionUtils.isEmpty(joins)) {
             for (Join join : joins) {
                 join.getOnExpression().accept(visitor);
-                if (!(join.getRightItem() instanceof SubSelect)) {
+                if (!(join.getRightItem() instanceof ParenthesedSelect)) {
                     continue;
                 }
-                SelectBody subSelectBody = ((SubSelect) join.getRightItem()).getSelectBody();
+                // SelectBody subSelectBody = ((SubSelect) join.getRightItem()).getSelectBody();
                 List<PlainSelect> plainSelectList = new ArrayList<>();
-                plainSelectList.add((PlainSelect) subSelectBody);
+                plainSelectList.add((PlainSelect) join.getRightItem());
                 List<PlainSelect> subPlainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
                 for (PlainSelect subPlainSelect : subPlainSelects) {
                     replaceFieldsInPlainOneSelect(fieldNameMap, exactReplace, subPlainSelect);
@@ -247,28 +241,27 @@ public class SqlReplaceHelper {
     }
 
     private static void replaceAsName(Map<String, String> fieldNameMap, SelectItem selectItem) {
-        if (selectItem instanceof SelectExpressionItem) {
+
-            SelectExpressionItem expressionItem = (SelectExpressionItem) selectItem;
+        Alias alias = selectItem.getAlias();
-            Alias alias = expressionItem.getAlias();
+        if (Objects.isNull(alias)) {
-            if (Objects.isNull(alias)) {
+            return;
-                return;
-            }
-            String aliasName = alias.getName();
-            String replaceFieldName = fieldNameMap.get(aliasName);
-            if (StringUtils.isNotBlank(replaceFieldName)) {
-                alias.setName(replaceFieldName);
-            }
         }
+        String aliasName = alias.getName();
+        String replaceFieldName = fieldNameMap.get(aliasName);
+        if (StringUtils.isNotBlank(replaceFieldName)) {
+            alias.setName(replaceFieldName);
+        }
+
     }
 
     public static String replaceFunction(String sql, Map<String, String> functionMap) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
         List<PlainSelect> plainSelectList = new ArrayList<>();
-        plainSelectList.add((PlainSelect) selectBody);
+        plainSelectList.add((PlainSelect) selectStatement);
         List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             replaceFunction(functionMap, plainSelect);
@@ -304,14 +297,14 @@ public class SqlReplaceHelper {
 
     public static String replaceFunction(String sql) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        Expression where = ((PlainSelect) selectBody).getWhere();
+        Expression where = ((PlainSelect) selectStatement).getWhere();
         try {
             Expression expression = SqlRemoveHelper.filteredExpression(where, SqlEditEnum.DATEDIFF);
-            ((PlainSelect) selectBody).setWhere(expression);
+            ((PlainSelect) selectStatement).setWhere(expression);
         } catch (Exception e) {
             log.info("replaceFunction has an exception:{}", e.toString());
         }
@@ -385,12 +378,12 @@ public class SqlReplaceHelper {
             return sql;
         }
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (selectBody instanceof PlainSelect) {
+        if (selectStatement instanceof PlainSelect) {
-            PlainSelect plainSelect = (PlainSelect) selectBody;
+            PlainSelect plainSelect = (PlainSelect) selectStatement;
             replaceSingleTable(plainSelect, tableName);
-        } else if (selectBody instanceof SetOperationList) {
+        } else if (selectStatement instanceof SetOperationList) {
-            SetOperationList setOperationList = (SetOperationList) selectBody;
+            SetOperationList setOperationList = (SetOperationList) selectStatement;
             if (!CollectionUtils.isEmpty(setOperationList.getSelects())) {
                 setOperationList.getSelects().forEach(subSelectBody -> {
                     PlainSelect subPlainSelect = (PlainSelect) subSelectBody;
@@ -418,10 +411,10 @@ public class SqlReplaceHelper {
             List<Join> joins = painSelect.getJoins();
             if (!CollectionUtils.isEmpty(joins)) {
                 for (Join join : joins) {
-                    if (join.getRightItem() instanceof SubSelect) {
+                    if (join.getRightItem() instanceof ParenthesedFromItem) {
-                        SelectBody subSelectBody = ((SubSelect) join.getRightItem()).getSelectBody();
+                        //SelectBody subSelectBody = ((SubSelect) join.getRightItem()).getSelectBody();
                         List<PlainSelect> plainSelectList = new ArrayList<>();
-                        plainSelectList.add((PlainSelect) subSelectBody);
+                        plainSelectList.add((PlainSelect) join.getRightItem());
                         List<PlainSelect> subPlainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
                         for (PlainSelect subPlainSelect : subPlainSelects) {
                             subPlainSelect.getFromItem().accept(new TableNameReplaceVisitor(tableName));
@@ -437,11 +430,11 @@ public class SqlReplaceHelper {
 
     public static String replaceAlias(String sql) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         FunctionAliasReplaceVisitor visitor = new FunctionAliasReplaceVisitor();
         for (SelectItem selectItem : plainSelect.getSelectItems()) {
             selectItem.accept(visitor);
@@ -455,11 +448,11 @@ public class SqlReplaceHelper {
 
     public static String replaceHavingValue(String sql, Map<String, Map<String, String>> filedNameToValueMap) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return sql;
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         Expression having = plainSelect.getHaving();
         FieldlValueReplaceVisitor visitor = new FieldlValueReplaceVisitor(false, filedNameToValueMap);
         if (Objects.nonNull(having)) {
@@ -473,7 +466,7 @@ public class SqlReplaceHelper {
             Function function = (Function) leftExpression;
             if (function.getName().equals(JsqlConstants.DATE_FUNCTION)) {
                 ComparisonOperator comparisonOperator = (ComparisonOperator) expression;
-                List<Expression> leftExpressions = function.getParameters().getExpressions();
+                ExpressionList<?> leftExpressions = function.getParameters();
                 Column field = (Column) function.getParameters().getExpressions().get(1);
                 String columnName = field.getColumnName();
                 try {
@@ -524,12 +517,12 @@ public class SqlReplaceHelper {
 
     public static String replaceSqlByExpression(String sql, Map<String, String> replace) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
         List<PlainSelect> plainSelectList = new ArrayList<>();
-        if (selectBody instanceof PlainSelect) {
+        if (selectStatement instanceof PlainSelect) {
-            plainSelectList.add((PlainSelect) selectBody);
+            plainSelectList.add((PlainSelect) selectStatement);
-        } else if (selectBody instanceof SetOperationList) {
+        } else if (selectStatement instanceof SetOperationList) {
-            SetOperationList setOperationList = (SetOperationList) selectBody;
+            SetOperationList setOperationList = (SetOperationList) selectStatement;
             if (!CollectionUtils.isEmpty(setOperationList.getSelects())) {
                 setOperationList.getSelects().forEach(subSelectBody -> {
                     PlainSelect subPlainSelect = (PlainSelect) subSelectBody;

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectFunctionHelper.java

@@ -1,6 +1,11 @@
 package com.tencent.supersonic.common.util.jsqlparser;
 
 import com.tencent.supersonic.common.pojo.enums.AggOperatorEnum;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.Function;
@@ -8,17 +13,10 @@ import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.statement.select.PlainSelect;
 import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectBody;
 import net.sf.jsqlparser.statement.select.SelectItem;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.util.CollectionUtils;
 
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
 /**
  * Sql Parser Select function Helper
  */
@@ -42,13 +40,13 @@ public class SqlSelectFunctionHelper {
 
     public static Set<String> getFunctions(String sql) {
         Select selectStatement = SqlSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return new HashSet<>();
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
-        List<SelectItem> selectItems = plainSelect.getSelectItems();
+        List<SelectItem<?>> selectItems = plainSelect.getSelectItems();
         FunctionVisitor visitor = new FunctionVisitor();
         for (SelectItem selectItem : selectItems) {
             selectItem.accept(visitor);

common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectHelper.java

@@ -22,21 +22,21 @@ import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
 import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
 import net.sf.jsqlparser.expression.operators.conditional.XorExpression;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.Statement;
 import net.sf.jsqlparser.statement.select.Distinct;
 import net.sf.jsqlparser.statement.select.GroupByElement;
+import net.sf.jsqlparser.statement.select.LateralView;
 import net.sf.jsqlparser.statement.select.OrderByElement;
+import net.sf.jsqlparser.statement.select.ParenthesedSelect;
 import net.sf.jsqlparser.statement.select.PlainSelect;
 import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectBody;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
 import net.sf.jsqlparser.statement.select.SelectItem;
 import net.sf.jsqlparser.statement.select.SelectVisitorAdapter;
 import net.sf.jsqlparser.statement.select.SetOperationList;
-import net.sf.jsqlparser.statement.select.SubSelect;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.util.CollectionUtils;
 
@@ -98,7 +98,7 @@ public class SqlSelectHelper {
     public static Set<String> getSelectFields(List<PlainSelect> plainSelectList) {
         Set<String> result = new HashSet<>();
         plainSelectList.stream().forEach(plainSelect -> {
-            List<SelectItem> selectItems = plainSelect.getSelectItems();
+            List<SelectItem<?>> selectItems = plainSelect.getSelectItems();
             for (SelectItem selectItem : selectItems) {
                 selectItem.accept(new FieldAcquireVisitor(result));
             }
@@ -111,14 +111,14 @@ public class SqlSelectHelper {
         if (selectStatement == null) {
             return null;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
         List<PlainSelect> plainSelectList = new ArrayList<>();
-        if (selectBody instanceof PlainSelect) {
+        if (selectStatement instanceof PlainSelect) {
-            PlainSelect plainSelect = (PlainSelect) selectBody;
+            PlainSelect plainSelect = (PlainSelect) selectStatement;
             plainSelectList.add(plainSelect);
-        } else if (selectBody instanceof SetOperationList) {
+        } else if (selectStatement instanceof SetOperationList) {
-            SetOperationList setOperationList = (SetOperationList) selectBody;
+            SetOperationList setOperationList = (SetOperationList) selectStatement;
             if (!CollectionUtils.isEmpty(setOperationList.getSelects())) {
                 setOperationList.getSelects().forEach(subSelectBody -> {
                     PlainSelect subPlainSelect = (PlainSelect) subSelectBody;
@@ -138,6 +138,11 @@ public class SqlSelectHelper {
             return null;
         }
 
+        if (statement instanceof ParenthesedSelect) {
+            ParenthesedSelect parenthesedSelect = (ParenthesedSelect) statement;
+            return parenthesedSelect.getSelect();
+        }
+
         if (!(statement instanceof Select)) {
             return null;
         }
@@ -150,10 +155,12 @@ public class SqlSelectHelper {
             plainSelects.add(plainSelect);
             ExpressionVisitorAdapter expressionVisitor = new ExpressionVisitorAdapter() {
                 @Override
-                public void visit(SubSelect subSelect) {
+                public void visit(Select subSelect) {
-                    SelectBody subSelectBody = subSelect.getSelectBody();
+                    if (subSelect instanceof ParenthesedSelect) {
-                    if (subSelectBody instanceof PlainSelect) {
+                        ParenthesedSelect parenthesedSelect = (ParenthesedSelect) subSelect;
-                        plainSelects.add((PlainSelect) subSelectBody);
+                        if (parenthesedSelect.getSelect() instanceof PlainSelect) {
+                            plainSelects.add(parenthesedSelect.getPlainSelect());
+                        }
                     }
                 }
             };
@@ -169,7 +176,7 @@ public class SqlSelectHelper {
                     if (Objects.nonNull(having)) {
                         having.accept(expressionVisitor);
                     }
-                    List<SelectItem> selectItems = plainSelect.getSelectItems();
+                    List<SelectItem<?>> selectItems = plainSelect.getSelectItems();
                     if (!CollectionUtils.isEmpty(selectItems)) {
                         for (SelectItem selectItem : selectItems) {
                             selectItem.accept(expressionVisitor);
@@ -207,6 +214,8 @@ public class SqlSelectHelper {
 
         getHavingFields(plainSelect, result);
 
+        getLateralViewsFields(plainSelect, result);
+
         return new ArrayList<>(result);
     }
 
@@ -218,6 +227,17 @@ public class SqlSelectHelper {
 
     }
 
+    private static void getLateralViewsFields(PlainSelect plainSelect, Set<String> result) {
+        List<LateralView> lateralViews = plainSelect.getLateralViews();
+        if (!CollectionUtils.isEmpty(lateralViews)) {
+            lateralViews.stream().forEach(l -> {
+                if (Objects.nonNull(l.getGeneratorFunction())) {
+                    l.getGeneratorFunction().accept(new FieldAcquireVisitor(result));
+                }
+            });
+        }
+    }
+
     public static List<Expression> getHavingExpression(String sql) {
         List<PlainSelect> plainSelectList = getPlainSelect(sql);
         List<Expression> expressionList = new ArrayList<>();
@@ -349,19 +369,18 @@ public class SqlSelectHelper {
             if (Objects.isNull(plainSelect)) {
                 continue;
             }
-            List<SelectItem> selectItems = plainSelect.getSelectItems();
+            List<SelectItem<?>> selectItems = plainSelect.getSelectItems();
             for (SelectItem selectItem : selectItems) {
-                if (selectItem instanceof SelectExpressionItem) {
+
-                    SelectExpressionItem expressionItem = (SelectExpressionItem) selectItem;
+                if (selectItem.getExpression() instanceof Function) {
-                    if (expressionItem.getExpression() instanceof Function) {
+                    Function function = (Function) selectItem.getExpression();
-                        Function function = (Function) expressionItem.getExpression();
+                    if (Objects.nonNull(function.getParameters())
-                        if (Objects.nonNull(function.getParameters())
+                            && !CollectionUtils.isEmpty(function.getParameters().getExpressions())) {
-                                && !CollectionUtils.isEmpty(function.getParameters().getExpressions())) {
+                        String columnName = function.getParameters().getExpressions().get(0).toString();
-                            String columnName = function.getParameters().getExpressions().get(0).toString();
+                        result.add(columnName);
-                            result.add(columnName);
-                        }
                     }
                 }
+
             }
         }
         return new ArrayList<>(result);
@@ -374,24 +393,23 @@ public class SqlSelectHelper {
             if (Objects.isNull(plainSelect)) {
                 continue;
             }
-            List<SelectItem> selectItems = plainSelect.getSelectItems();
+            List<SelectItem<?>> selectItems = plainSelect.getSelectItems();
             for (SelectItem selectItem : selectItems) {
-                if (selectItem instanceof SelectExpressionItem) {
+
-                    SelectExpressionItem expressionItem = (SelectExpressionItem) selectItem;
+                if (selectItem.getExpression() instanceof Function) {
-                    if (expressionItem.getExpression() instanceof Function) {
+                    Function function = (Function) selectItem.getExpression();
-                        Function function = (Function) expressionItem.getExpression();
+                    Alias alias = selectItem.getAlias();
-                        Alias alias = expressionItem.getAlias();
+                    if (alias != null && StringUtils.isNotBlank(alias.getName())) {
-                        if (alias != null && StringUtils.isNotBlank(alias.getName())) {
+                        result.add(alias.getName());
-                            result.add(alias.getName());
+                    } else {
-                        } else {
+                        if (Objects.nonNull(function.getParameters())
-                            if (Objects.nonNull(function.getParameters())
+                                && !CollectionUtils.isEmpty(function.getParameters().getExpressions())) {
-                                    && !CollectionUtils.isEmpty(function.getParameters().getExpressions())) {
+                            String columnName = function.getParameters().getExpressions().get(0).toString();
-                                String columnName = function.getParameters().getExpressions().get(0).toString();
+                            result.add(columnName);
-                                result.add(columnName);
-                            }
                         }
                     }
                 }
+
             }
         }
         return new ArrayList<>(result);
@@ -399,12 +417,12 @@ public class SqlSelectHelper {
 
     public static boolean hasGroupBy(String sql) {
         Select selectStatement = getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return false;
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         GroupByElement groupBy = plainSelect.getGroupBy();
         if (Objects.nonNull(groupBy)) {
             GroupByVisitor replaceVisitor = new GroupByVisitor();
@@ -416,12 +434,12 @@ public class SqlSelectHelper {
 
     public static boolean hasDistinct(String sql) {
         Select selectStatement = getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
 
-        if (!(selectBody instanceof PlainSelect)) {
+        if (!(selectStatement instanceof PlainSelect)) {
             return false;
         }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
+        PlainSelect plainSelect = (PlainSelect) selectStatement;
         Distinct distinct = plainSelect.getDistinct();
         return Objects.nonNull(distinct);
     }
@@ -436,7 +454,8 @@ public class SqlSelectHelper {
             return ((Column) leftExpression).getColumnName();
         }
         if (leftExpression instanceof Function) {
-            List<Expression> expressionList = ((Function) leftExpression).getParameters().getExpressions();
+            ExpressionList<?> expressionList = ((Function) leftExpression).getParameters();
+
             if (!CollectionUtils.isEmpty(expressionList) && expressionList.get(0) instanceof Column) {
                 return ((Column) expressionList.get(0)).getColumnName();
             }
@@ -454,8 +473,8 @@ public class SqlSelectHelper {
         }
         if (leftExpression instanceof Function) {
             Function function = (Function) leftExpression;
-            if (!CollectionUtils.isEmpty(function.getParameters().getExpressions())) {
+            if (!CollectionUtils.isEmpty(function.getParameters())) {
-                Expression expression = function.getParameters().getExpressions().get(0);
+                Expression expression = (Expression) function.getParameters().get(0);
                 if (expression instanceof Column) {
                     return ((Column) expression).getColumnName();
                 }
@@ -481,20 +500,21 @@ public class SqlSelectHelper {
         if (selectStatement == null) {
             return null;
         }
-        SelectBody selectBody = selectStatement.getSelectBody();
+        //SelectBody selectBody = selectStatement.getSelectBody();
-        if (selectBody instanceof PlainSelect) {
+        if (selectStatement instanceof PlainSelect) {
-            PlainSelect plainSelect = (PlainSelect) selectBody;
+            PlainSelect plainSelect = (PlainSelect) selectStatement;
             if (plainSelect.getFromItem() instanceof Table) {
                 return (Table) plainSelect.getFromItem();
             }
-            if (plainSelect.getFromItem() instanceof SubSelect) {
+            if (plainSelect.getFromItem() instanceof ParenthesedSelect) {
 
-                SubSelect subSelect = (SubSelect) plainSelect.getFromItem();
+                //ParenthesedFromItem subSelect = (ParenthesedFromItem) plainSelect.getFromItem();
+                PlainSelect subSelect = ((ParenthesedSelect) plainSelect.getFromItem()).getPlainSelect();
                 return getTable(subSelect.getSelectBody().toString());
             }
 
-        } else if (selectBody instanceof SetOperationList) {
+        } else if (selectStatement instanceof SetOperationList) {
-            SetOperationList setOperationList = (SetOperationList) selectBody;
+            SetOperationList setOperationList = (SetOperationList) selectStatement;
             if (!CollectionUtils.isEmpty(setOperationList.getSelects())) {
                 return (Table) ((PlainSelect) setOperationList.getSelects().get(0)).getFromItem();
             }
@@ -521,7 +541,8 @@ public class SqlSelectHelper {
             columns.add(((Column) expression).getColumnName());
         }
         if (expression instanceof Function) {
-            List<Expression> expressionList = ((Function) expression).getParameters().getExpressions();
+            //List<Expression> expressionList = ((Function) expression).getParameters().getExpressions();
+            ExpressionList<?> expressionList = ((Function) expression).getParameters();
             for (Expression expr : expressionList) {
                 getColumnFromExpr(expr, columns);
             }

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/request/QueryStructReq.java

@@ -31,9 +31,8 @@ import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.select.GroupByElement;
 import net.sf.jsqlparser.statement.select.Limit;
 import net.sf.jsqlparser.statement.select.OrderByElement;
+import net.sf.jsqlparser.statement.select.ParenthesedSelect;
 import net.sf.jsqlparser.statement.select.PlainSelect;
-import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.select.SelectExpressionItem;
 import net.sf.jsqlparser.statement.select.SelectItem;
 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -169,14 +168,14 @@ public class QueryStructReq extends SemanticQueryReq {
     }
 
     private String buildSql(QueryStructReq queryStructReq, boolean isBizName) throws JSQLParserException {
-        Select select = new Select();
+        ParenthesedSelect select = new ParenthesedSelect();
         //1.Set the select items (columns)
         PlainSelect plainSelect = new PlainSelect();
-        List<SelectItem> selectItems = new ArrayList<>();
+        List<SelectItem<?>> selectItems = new ArrayList<>();
         List<String> groups = queryStructReq.getGroups();
         if (!CollectionUtils.isEmpty(groups)) {
             for (String group : groups) {
-                selectItems.add(new SelectExpressionItem(new Column(group)));
+                selectItems.add(new SelectItem(new Column(group)));
             }
         }
         List<Aggregator> aggregators = queryStructReq.getAggregators();
@@ -184,7 +183,7 @@ public class QueryStructReq extends SemanticQueryReq {
             for (Aggregator aggregator : aggregators) {
                 String columnName = aggregator.getColumn();
                 if (queryStructReq.getQueryType().isNativeAggQuery()) {
-                    selectItems.add(new SelectExpressionItem(new Column(columnName)));
+                    selectItems.add(new SelectItem(new Column(columnName)));
                 } else {
                     Function sumFunction = new Function();
                     AggOperatorEnum func = aggregator.getFunc();
@@ -197,7 +196,7 @@ public class QueryStructReq extends SemanticQueryReq {
                         sumFunction.setDistinct(true);
                     }
                     sumFunction.setParameters(new ExpressionList(new Column(columnName)));
-                    SelectExpressionItem selectExpressionItem = new SelectExpressionItem(sumFunction);
+                    SelectItem selectExpressionItem = new SelectItem(sumFunction);
                     String alias = StringUtils.isNotBlank(aggregator.getAlias()) ? aggregator.getAlias() : columnName;
                     selectExpressionItem.setAlias(new Alias(alias));
                     selectItems.add(selectExpressionItem);
@@ -243,7 +242,9 @@ public class QueryStructReq extends SemanticQueryReq {
             limit.setRowCount(new LongValue(queryStructReq.getLimit()));
             plainSelect.setLimit(limit);
         }
-        select.setSelectBody(plainSelect);
+        //select.setSelectBody(plainSelect);
+        select.setSelect(plainSelect);
+
 
         //6.Set where
         List<Filter> dimensionFilters = queryStructReq.getDimensionFilters();

headless/core/src/main/java/com/tencent/supersonic/headless/core/parser/converter/DefaultDimValueConverter.java

@@ -56,7 +56,7 @@ public class DefaultDimValueConverter implements HeadlessConverter {
             expressionList.setExpressions(exprs);
             InExpression inExpression = new InExpression();
             inExpression.setLeftExpression(new Column(dimension.getBizName()));
-            inExpression.setRightItemsList(expressionList);
+            inExpression.setRightExpression(expressionList);
             expressions.add(inExpression);
             if (metricTable != null) {
                 metricTable.getDimensions().add(dimension.getBizName());

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/ChatQueryServiceImpl.java

@@ -501,7 +501,7 @@ public class ChatQueryServiceImpl implements ChatQueryService {
         });
         expressionList.setExpressions(expressions);
         inExpression.setLeftExpression(column);
-        inExpression.setRightItemsList(expressionList);
+        inExpression.setRightExpression(expressionList);
         addConditions.add(inExpression);
         contextMetricFilters.stream().forEach(o -> {
             if (o.getName().equals(dslQueryFilter.getName())) {

headless/server/src/main/java/com/tencent/supersonic/headless/server/utils/QueryReqConverter.java

@@ -33,7 +33,6 @@ import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
 

pom.xml

@@ -32,8 +32,9 @@
         <maven.compiler.target>8</maven.compiler.target>
         <file.encoding>UTF-8</file.encoding>
         <apache.log4j.version>2.17.1</apache.log4j.version>
-        <pagehelper.version>5.3.3</pagehelper.version>
+        <jsqlparser.version>4.7</jsqlparser.version>
-        <pagehelper.spring.version>1.2.10</pagehelper.spring.version>
+        <pagehelper.version>6.1.0</pagehelper.version>
+        <pagehelper.spring.version>2.1.0</pagehelper.spring.version>
         <mybatis.version>3.5.3</mybatis.version>
         <lombok.version>1.18.20</lombok.version>
         <guava.version>20.0</guava.version>
@@ -63,7 +64,7 @@
         <calcite.avatica.version>1.23.0</calcite.avatica.version>
         <xk.time.version>3.2.4</xk.time.version>
         <mockito-inline.version>4.5.1</mockito-inline.version>
-        <jsqlparser.version>4.5</jsqlparser.version>
+
         <revision>0.9.0-SNAPSHOT</revision>
         <!-- Do not bump spotless plugin version since 2.30.0 is the latest version supports Java 8-->
         <maven.plugin.spotless.version>2.30.0</maven.plugin.spotless.version>