[improvement][Chat] Add TimeCorrector and rename the associated SqlParserHelper. (#707)

chat/core/src/main/java/com/tencent/supersonic/chat/core/corrector/BaseSemanticCorrector.java

@@ -6,9 +6,9 @@ import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
 import com.tencent.supersonic.chat.core.pojo.QueryContext;
 import com.tencent.supersonic.common.pojo.enums.AggregateTypeEnum;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectFunctionHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectFunctionHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
@@ -75,14 +75,14 @@ public abstract class BaseSemanticCorrector implements SemanticCorrector {
     }
 
     protected void addFieldsToSelect(SemanticParseInfo semanticParseInfo, String correctS2SQL) {
-        Set<String> selectFields = new HashSet<>(SqlParserSelectHelper.getSelectFields(correctS2SQL));
+        Set<String> selectFields = new HashSet<>(SqlSelectHelper.getSelectFields(correctS2SQL));
-        Set<String> needAddFields = new HashSet<>(SqlParserSelectHelper.getGroupByFields(correctS2SQL));
+        Set<String> needAddFields = new HashSet<>(SqlSelectHelper.getGroupByFields(correctS2SQL));
-        needAddFields.addAll(SqlParserSelectHelper.getOrderByFields(correctS2SQL));
+        needAddFields.addAll(SqlSelectHelper.getOrderByFields(correctS2SQL));
 
         // If there is no aggregate function in the S2SQL statement and
         // there is a data field in 'WHERE' statement, add the field to the 'SELECT' statement.
-        if (!SqlParserSelectFunctionHelper.hasAggregateFunction(correctS2SQL)) {
+        if (!SqlSelectFunctionHelper.hasAggregateFunction(correctS2SQL)) {
-            List<String> whereFields = SqlParserSelectHelper.getWhereFields(correctS2SQL);
+            List<String> whereFields = SqlSelectHelper.getWhereFields(correctS2SQL);
             List<String> timeChNameList = TimeDimensionEnum.getChNameList();
             Set<String> timeFields = whereFields.stream().filter(field -> timeChNameList.contains(field))
                     .collect(Collectors.toSet());
@@ -94,7 +94,7 @@ public abstract class BaseSemanticCorrector implements SemanticCorrector {
         }
 
         needAddFields.removeAll(selectFields);
-        String replaceFields = SqlParserAddHelper.addFieldsToSelect(correctS2SQL, new ArrayList<>(needAddFields));
+        String replaceFields = SqlAddHelper.addFieldsToSelect(correctS2SQL, new ArrayList<>(needAddFields));
         semanticParseInfo.getSqlInfo().setCorrectS2SQL(replaceFields);
     }
 
@@ -123,7 +123,7 @@ public abstract class BaseSemanticCorrector implements SemanticCorrector {
         if (CollectionUtils.isEmpty(metricToAggregate)) {
             return;
         }
-        String aggregateSql = SqlParserAddHelper.addAggregateToField(correctS2SQL, metricToAggregate);
+        String aggregateSql = SqlAddHelper.addAggregateToField(correctS2SQL, metricToAggregate);
         semanticParseInfo.getSqlInfo().setCorrectS2SQL(aggregateSql);
     }
 

chat/core/src/main/java/com/tencent/supersonic/chat/core/corrector/GroupByCorrector.java

@@ -5,8 +5,8 @@ import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
 import com.tencent.supersonic.chat.api.pojo.response.SqlInfo;
 import com.tencent.supersonic.chat.core.pojo.QueryContext;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.util.CollectionUtils;
 
@@ -35,7 +35,7 @@ public class GroupByCorrector extends BaseSemanticCorrector {
         String correctS2SQL = sqlInfo.getCorrectS2SQL();
         SemanticSchema semanticSchema = queryContext.getSemanticSchema();
         // check if has distinct
-        boolean hasDistinct = SqlParserSelectHelper.hasDistinct(correctS2SQL);
+        boolean hasDistinct = SqlSelectHelper.hasDistinct(correctS2SQL);
         if (hasDistinct) {
             log.info("not add group by ,exist distinct in correctS2SQL:{}", correctS2SQL);
             return;
@@ -54,7 +54,7 @@ public class GroupByCorrector extends BaseSemanticCorrector {
                 ).collect(Collectors.toSet());
         dimensions.add(TimeDimensionEnum.DAY.getChName());
 
-        List<String> selectFields = SqlParserSelectHelper.getSelectFields(correctS2SQL);
+        List<String> selectFields = SqlSelectHelper.getSelectFields(correctS2SQL);
 
         if (CollectionUtils.isEmpty(selectFields) || CollectionUtils.isEmpty(dimensions)) {
             return;
@@ -63,12 +63,12 @@ public class GroupByCorrector extends BaseSemanticCorrector {
         if (selectFields.size() == 1 && selectFields.contains(TimeDimensionEnum.DAY.getChName())) {
             return;
         }
-        if (SqlParserSelectHelper.hasGroupBy(correctS2SQL)) {
+        if (SqlSelectHelper.hasGroupBy(correctS2SQL)) {
             log.info("not add group by ,exist group by in correctS2SQL:{}", correctS2SQL);
             return;
         }
 
-        List<String> aggregateFields = SqlParserSelectHelper.getAggregateFields(correctS2SQL);
+        List<String> aggregateFields = SqlSelectHelper.getAggregateFields(correctS2SQL);
         Set<String> groupByFields = selectFields.stream()
                 .filter(field -> dimensions.contains(field))
                 .filter(field -> {
@@ -78,13 +78,13 @@ public class GroupByCorrector extends BaseSemanticCorrector {
                     return true;
                 })
                 .collect(Collectors.toSet());
-        semanticParseInfo.getSqlInfo().setCorrectS2SQL(SqlParserAddHelper.addGroupBy(correctS2SQL, groupByFields));
+        semanticParseInfo.getSqlInfo().setCorrectS2SQL(SqlAddHelper.addGroupBy(correctS2SQL, groupByFields));
 
         addAggregate(queryContext, semanticParseInfo);
     }
 
     private void addAggregate(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
-        List<String> sqlGroupByFields = SqlParserSelectHelper.getGroupByFields(
+        List<String> sqlGroupByFields = SqlSelectHelper.getGroupByFields(
                 semanticParseInfo.getSqlInfo().getCorrectS2SQL());
         if (CollectionUtils.isEmpty(sqlGroupByFields)) {
             return;

chat/core/src/main/java/com/tencent/supersonic/chat/core/corrector/HavingCorrector.java

@@ -3,9 +3,9 @@ package com.tencent.supersonic.chat.core.corrector;
 import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
 import com.tencent.supersonic.chat.api.pojo.SemanticSchema;
 import com.tencent.supersonic.chat.core.pojo.QueryContext;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectFunctionHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectFunctionHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.expression.Expression;
 import org.springframework.util.CollectionUtils;
@@ -42,18 +42,18 @@ public class HavingCorrector extends BaseSemanticCorrector {
         if (CollectionUtils.isEmpty(metrics)) {
             return;
         }
-        String havingSql = SqlParserAddHelper.addHaving(semanticParseInfo.getSqlInfo().getCorrectS2SQL(), metrics);
+        String havingSql = SqlAddHelper.addHaving(semanticParseInfo.getSqlInfo().getCorrectS2SQL(), metrics);
         semanticParseInfo.getSqlInfo().setCorrectS2SQL(havingSql);
     }
 
     private void addHavingToSelect(SemanticParseInfo semanticParseInfo) {
         String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        if (!SqlParserSelectFunctionHelper.hasAggregateFunction(correctS2SQL)) {
+        if (!SqlSelectFunctionHelper.hasAggregateFunction(correctS2SQL)) {
             return;
         }
-        List<Expression> havingExpressionList = SqlParserSelectHelper.getHavingExpression(correctS2SQL);
+        List<Expression> havingExpressionList = SqlSelectHelper.getHavingExpression(correctS2SQL);
         if (!CollectionUtils.isEmpty(havingExpressionList)) {
-            String replaceSql = SqlParserAddHelper.addFunctionToSelect(correctS2SQL, havingExpressionList);
+            String replaceSql = SqlAddHelper.addFunctionToSelect(correctS2SQL, havingExpressionList);
             semanticParseInfo.getSqlInfo().setCorrectS2SQL(replaceSql);
         }
         return;

chat/core/src/main/java/com/tencent/supersonic/chat/core/corrector/SchemaCorrector.java

@@ -8,7 +8,7 @@ import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMReq.ElementValue;
 import com.tencent.supersonic.common.pojo.Constants;
 import com.tencent.supersonic.common.util.JsonUtil;
 import com.tencent.supersonic.common.util.jsqlparser.AggregateEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.util.CollectionUtils;
 
@@ -19,7 +19,7 @@ import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
- * Perform schema corrections on the Schema information in S2QL.
+ * Perform schema corrections on the Schema information in S2SQL.
  */
 @Slf4j
 public class SchemaCorrector extends BaseSemanticCorrector {
@@ -41,20 +41,20 @@ public class SchemaCorrector extends BaseSemanticCorrector {
     private void correctAggFunction(SemanticParseInfo semanticParseInfo) {
         Map<String, String> aggregateEnum = AggregateEnum.getAggregateEnum();
         SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String sql = SqlParserReplaceHelper.replaceFunction(sqlInfo.getCorrectS2SQL(), aggregateEnum);
+        String sql = SqlReplaceHelper.replaceFunction(sqlInfo.getCorrectS2SQL(), aggregateEnum);
         sqlInfo.setCorrectS2SQL(sql);
     }
 
     private void replaceAlias(SemanticParseInfo semanticParseInfo) {
         SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String replaceAlias = SqlParserReplaceHelper.replaceAlias(sqlInfo.getCorrectS2SQL());
+        String replaceAlias = SqlReplaceHelper.replaceAlias(sqlInfo.getCorrectS2SQL());
         sqlInfo.setCorrectS2SQL(replaceAlias);
     }
 
     private void correctFieldName(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
         Map<String, String> fieldNameMap = getFieldNameMap(queryContext, semanticParseInfo.getViewId());
         SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String sql = SqlParserReplaceHelper.replaceFields(sqlInfo.getCorrectS2SQL(), fieldNameMap);
+        String sql = SqlReplaceHelper.replaceFields(sqlInfo.getCorrectS2SQL(), fieldNameMap);
         sqlInfo.setCorrectS2SQL(sql);
     }
 
@@ -70,7 +70,7 @@ public class SchemaCorrector extends BaseSemanticCorrector {
 
         SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
 
-        String sql = SqlParserReplaceHelper.replaceFieldNameByValue(sqlInfo.getCorrectS2SQL(), fieldValueToFieldNames);
+        String sql = SqlReplaceHelper.replaceFieldNameByValue(sqlInfo.getCorrectS2SQL(), fieldValueToFieldNames);
         sqlInfo.setCorrectS2SQL(sql);
     }
 
@@ -102,7 +102,7 @@ public class SchemaCorrector extends BaseSemanticCorrector {
                         )));
 
         SqlInfo sqlInfo = semanticParseInfo.getSqlInfo();
-        String sql = SqlParserReplaceHelper.replaceValue(sqlInfo.getCorrectS2SQL(), filedNameToValueMap, false);
+        String sql = SqlReplaceHelper.replaceValue(sqlInfo.getCorrectS2SQL(), filedNameToValueMap, false);
         sqlInfo.setCorrectS2SQL(sql);
     }
 }

chat/core/src/main/java/com/tencent/supersonic/chat/core/corrector/SelectCorrector.java

@@ -2,7 +2,7 @@ package com.tencent.supersonic.chat.core.corrector;
 
 import com.tencent.supersonic.chat.core.pojo.QueryContext;
 import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import java.util.List;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.util.CollectionUtils;
@@ -16,8 +16,8 @@ public class SelectCorrector extends BaseSemanticCorrector {
     @Override
     public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
         String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        List<String> aggregateFields = SqlParserSelectHelper.getAggregateFields(correctS2SQL);
+        List<String> aggregateFields = SqlSelectHelper.getAggregateFields(correctS2SQL);
-        List<String> selectFields = SqlParserSelectHelper.getSelectFields(correctS2SQL);
+        List<String> selectFields = SqlSelectHelper.getSelectFields(correctS2SQL);
         // If the number of aggregated fields is equal to the number of queried fields, do not add fields to select.
         if (!CollectionUtils.isEmpty(aggregateFields)
                 && !CollectionUtils.isEmpty(selectFields)

chat/core/src/main/java/com/tencent/supersonic/chat/core/corrector/TimeCorrector.java

@@ -0,0 +1,57 @@
+package com.tencent.supersonic.chat.core.corrector;
+
+import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
+import com.tencent.supersonic.chat.core.pojo.QueryContext;
+import com.tencent.supersonic.common.util.jsqlparser.DateVisitor.DateBoundInfo;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlDateSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
+import java.util.Objects;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * Perform SQL corrections on the time in S2SQL.
+ */
+@Slf4j
+public class TimeCorrector extends BaseSemanticCorrector {
+
+    @Override
+    public void doCorrect(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
+
+        parserDateDiffFunction(semanticParseInfo);
+
+        addLowerBoundDate(semanticParseInfo);
+
+    }
+
+    private void addLowerBoundDate(SemanticParseInfo semanticParseInfo) {
+        String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
+        DateBoundInfo dateBoundInfo = SqlDateSelectHelper.getDateBoundInfo(correctS2SQL);
+        if (Objects.isNull(dateBoundInfo)) {
+            return;
+        }
+        if (StringUtils.isBlank(dateBoundInfo.getLowerBound())
+                && StringUtils.isNotBlank(dateBoundInfo.getUpperBound())
+                && StringUtils.isNotBlank(dateBoundInfo.getUpperDate())) {
+            String upperDate = dateBoundInfo.getUpperDate();
+            try {
+                correctS2SQL = SqlAddHelper.addParenthesisToWhere(correctS2SQL);
+                String condExpr = dateBoundInfo.getColumName() + " >= '" + upperDate + "'";
+                correctS2SQL = SqlAddHelper.addWhere(correctS2SQL, CCJSqlParserUtil.parseCondExpression(condExpr));
+            } catch (JSQLParserException e) {
+                log.error("parseCondExpression", e);
+            }
+            semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctS2SQL);
+        }
+    }
+
+    private void parserDateDiffFunction(SemanticParseInfo semanticParseInfo) {
+        String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
+        correctS2SQL = SqlReplaceHelper.replaceFunction(correctS2SQL);
+        semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctS2SQL);
+    }
+
+}

chat/core/src/main/java/com/tencent/supersonic/chat/core/corrector/WhereCorrector.java

@@ -10,9 +10,9 @@ import com.tencent.supersonic.chat.core.pojo.QueryContext;
 import com.tencent.supersonic.common.pojo.Constants;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
 import com.tencent.supersonic.common.util.StringUtil;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.expression.Expression;
@@ -38,8 +38,6 @@ public class WhereCorrector extends BaseSemanticCorrector {
 
         addDateIfNotExist(queryContext, semanticParseInfo);
 
-        parserDateDiffFunction(semanticParseInfo);
-
         addQueryFilter(queryContext, semanticParseInfo);
 
         updateFieldValueByTechName(queryContext, semanticParseInfo);
@@ -58,25 +56,19 @@ public class WhereCorrector extends BaseSemanticCorrector {
             } catch (JSQLParserException e) {
                 log.error("parseCondExpression", e);
             }
-            correctS2SQL = SqlParserAddHelper.addWhere(correctS2SQL, expression);
+            correctS2SQL = SqlAddHelper.addWhere(correctS2SQL, expression);
             semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctS2SQL);
         }
     }
 
-    private void parserDateDiffFunction(SemanticParseInfo semanticParseInfo) {
-        String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        correctS2SQL = SqlParserReplaceHelper.replaceFunction(correctS2SQL);
-        semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctS2SQL);
-    }
-
     private void addDateIfNotExist(QueryContext queryContext, SemanticParseInfo semanticParseInfo) {
         String correctS2SQL = semanticParseInfo.getSqlInfo().getCorrectS2SQL();
-        List<String> whereFields = SqlParserSelectHelper.getWhereFields(correctS2SQL);
+        List<String> whereFields = SqlSelectHelper.getWhereFields(correctS2SQL);
         if (CollectionUtils.isEmpty(whereFields) || !TimeDimensionEnum.containsZhTimeDimension(whereFields)) {
             String currentDate = S2SqlDateHelper.getReferenceDate(queryContext, semanticParseInfo.getViewId());
             if (StringUtils.isNotBlank(currentDate)) {
-                correctS2SQL = SqlParserAddHelper.addParenthesisToWhere(correctS2SQL);
+                correctS2SQL = SqlAddHelper.addParenthesisToWhere(correctS2SQL);
-                correctS2SQL = SqlParserAddHelper.addWhere(
+                correctS2SQL = SqlAddHelper.addWhere(
                         correctS2SQL, TimeDimensionEnum.DAY.getChName(), currentDate);
             }
         }
@@ -107,7 +99,7 @@ public class WhereCorrector extends BaseSemanticCorrector {
         }
 
         Map<String, Map<String, String>> aliasAndBizNameToTechName = getAliasAndBizNameToTechName(dimensions);
-        String correctS2SQL = SqlParserReplaceHelper.replaceValue(semanticParseInfo.getSqlInfo().getCorrectS2SQL(),
+        String correctS2SQL = SqlReplaceHelper.replaceValue(semanticParseInfo.getSqlInfo().getCorrectS2SQL(),
                 aliasAndBizNameToTechName);
         semanticParseInfo.getSqlInfo().setCorrectS2SQL(correctS2SQL);
     }

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/QueryTypeParser.java

@@ -12,7 +12,7 @@ import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlQuery;
 import com.tencent.supersonic.chat.core.query.rule.RuleSemanticQuery;
 import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -54,7 +54,7 @@ public class QueryTypeParser implements SemanticParser {
         SemanticSchema semanticSchema = queryContext.getSemanticSchema();
         if (semanticQuery instanceof RuleSemanticQuery || semanticQuery instanceof LLMSqlQuery) {
             //If all the fields in the SELECT statement are of tag type.
-            List<String> whereFields = SqlParserSelectHelper.getWhereFields(sqlInfo.getS2SQL())
+            List<String> whereFields = SqlSelectHelper.getWhereFields(sqlInfo.getS2SQL())
                     .stream().filter(field -> !TimeDimensionEnum.containsTimeDimension(field))
                     .collect(Collectors.toList());
 
@@ -72,7 +72,7 @@ public class QueryTypeParser implements SemanticParser {
             }
         }
         //2. metric queryType
-        List<String> selectFields = SqlParserSelectHelper.getSelectFields(sqlInfo.getS2SQL());
+        List<String> selectFields = SqlSelectHelper.getSelectFields(sqlInfo.getS2SQL());
         List<SchemaElement> metrics = semanticSchema.getMetrics(viewId);
         if (CollectionUtils.isNotEmpty(metrics)) {
             Set<String> metricNameSet = metrics.stream().map(SchemaElement::getName).collect(Collectors.toSet());

chat/core/src/main/java/com/tencent/supersonic/chat/core/parser/sql/llm/LLMResponseService.java

@@ -9,7 +9,7 @@ import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMResp;
 import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlQuery;
 import com.tencent.supersonic.chat.core.query.llm.s2sql.LLMSqlResp;
 import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserEqualHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlEqualHelper;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.MapUtils;
 import org.springframework.stereotype.Service;
@@ -52,7 +52,7 @@ public class LLMResponseService {
         Map<String, LLMSqlResp> result = new HashMap<>();
         for (Map.Entry<String, LLMSqlResp> entry : llmResp.getSqlRespMap().entrySet()) {
             String key = entry.getKey();
-            if (result.keySet().stream().anyMatch(existKey -> SqlParserEqualHelper.equals(existKey, key))) {
+            if (result.keySet().stream().anyMatch(existKey -> SqlEqualHelper.equals(existKey, key))) {
                 continue;
             }
             result.put(key, entry.getValue());

chat/core/src/test/java/com/tencent/supersonic/chat/core/corrector/TimeCorrectorTest.java

@@ -0,0 +1,100 @@
+package com.tencent.supersonic.chat.core.corrector;
+
+import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
+import com.tencent.supersonic.chat.api.pojo.response.SqlInfo;
+import com.tencent.supersonic.chat.core.pojo.QueryContext;
+import org.junit.Assert;
+import org.junit.jupiter.api.Test;
+
+class TimeCorrectorTest {
+
+    @Test
+    void testDoCorrect() {
+        TimeCorrector corrector = new TimeCorrector();
+        QueryContext queryContext = new QueryContext();
+        SemanticParseInfo semanticParseInfo = new SemanticParseInfo();
+        SqlInfo sqlInfo = new SqlInfo();
+        //1.数据日期 <=
+        String sql = "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 <= '2023-11-17' GROUP BY 维度1";
+        sqlInfo.setCorrectS2SQL(sql);
+        semanticParseInfo.setSqlInfo(sqlInfo);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+
+        Assert.assertEquals(
+                "SELECT 维度1, SUM(播放量) FROM 数据库 WHERE ((歌手名 = '张三') AND 数据日期 <= '2023-11-17') "
+                        + "AND 数据日期 >= '2023-11-17' GROUP BY 维度1",
+                sqlInfo.getCorrectS2SQL());
+
+        //2.数据日期 <
+        sql = "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 < '2023-11-17' GROUP BY 维度1";
+        sqlInfo.setCorrectS2SQL(sql);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+
+        Assert.assertEquals(
+                "SELECT 维度1, SUM(播放量) FROM 数据库 WHERE ((歌手名 = '张三') AND 数据日期 < '2023-11-17') "
+                        + "AND 数据日期 >= '2023-11-17' GROUP BY 维度1",
+                sqlInfo.getCorrectS2SQL());
+
+        //3.数据日期 >=
+        sql = "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 >= '2023-11-17' GROUP BY 维度1";
+        sqlInfo.setCorrectS2SQL(sql);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+
+        Assert.assertEquals(
+                "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                        + "WHERE (歌手名 = '张三') AND 数据日期 >= '2023-11-17' GROUP BY 维度1",
+                sqlInfo.getCorrectS2SQL());
+
+        //4.数据日期 >
+        sql = "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 > '2023-11-17' GROUP BY 维度1";
+        sqlInfo.setCorrectS2SQL(sql);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+
+        Assert.assertEquals(
+                "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                        + "WHERE (歌手名 = '张三') AND 数据日期 > '2023-11-17' GROUP BY 维度1",
+                sqlInfo.getCorrectS2SQL());
+
+        //5.no 数据日期
+        sql = "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                + "WHERE 歌手名 = '张三' GROUP BY 维度1";
+        sqlInfo.setCorrectS2SQL(sql);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+
+        Assert.assertEquals(
+                "SELECT 维度1, SUM(播放量) FROM 数据库 WHERE 歌手名 = '张三' GROUP BY 维度1",
+                sqlInfo.getCorrectS2SQL());
+
+        //6. 数据日期-月 <=
+        sql = "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                + "WHERE 歌手名 = '张三' AND 数据日期_月 <= '2024-01' GROUP BY 维度1";
+        sqlInfo.setCorrectS2SQL(sql);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+
+        Assert.assertEquals(
+                "SELECT 维度1, SUM(播放量) FROM 数据库 WHERE (歌手名 = '张三' AND 数据日期_月 <= '2024-01') "
+                        + "AND 数据日期_月 >= '2024-01' GROUP BY 维度1",
+                sqlInfo.getCorrectS2SQL());
+
+        //7. 数据日期-月 >
+        sql = "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                + "WHERE 歌手名 = '张三' AND 数据日期_月 > '2024-01' GROUP BY 维度1";
+        sqlInfo.setCorrectS2SQL(sql);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+
+        Assert.assertEquals(
+                "SELECT 维度1, SUM(播放量) FROM 数据库 "
+                        + "WHERE 歌手名 = '张三' AND 数据日期_月 > '2024-01' GROUP BY 维度1",
+                sqlInfo.getCorrectS2SQL());
+
+        //8. no where
+        sql = "SELECT COUNT(1) FROM 数据库";
+        sqlInfo.setCorrectS2SQL(sql);
+        corrector.doCorrect(queryContext, semanticParseInfo);
+        Assert.assertEquals("SELECT COUNT(1) FROM 数据库", sqlInfo.getCorrectS2SQL());
+    }
+}

chat/server/src/main/java/com/tencent/supersonic/chat/server/processor/parse/MetricCheckProcessor.java

@@ -15,8 +15,8 @@ import com.tencent.supersonic.chat.server.service.SemanticService;
 import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
 import com.tencent.supersonic.common.util.ContextUtils;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserRemoveHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlRemoveHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
@@ -61,9 +61,9 @@ public class MetricCheckProcessor implements ParseResultProcessor {
 
     public String processCorrectSql(SemanticParseInfo parseInfo, SemanticSchema semanticSchema) {
         String correctSql = parseInfo.getSqlInfo().getCorrectS2SQL();
-        List<String> groupByFields = SqlParserSelectHelper.getGroupByFields(correctSql);
+        List<String> groupByFields = SqlSelectHelper.getGroupByFields(correctSql);
-        List<String> metricFields = SqlParserSelectHelper.getAggregateFields(correctSql);
+        List<String> metricFields = SqlSelectHelper.getAggregateFields(correctSql);
-        List<String> whereFields = SqlParserSelectHelper.getWhereFields(correctSql);
+        List<String> whereFields = SqlSelectHelper.getWhereFields(correctSql);
         List<String> dimensionFields = getDimensionFields(groupByFields, whereFields);
         if (CollectionUtils.isEmpty(metricFields) || StringUtils.isBlank(correctSql)) {
             return correctSql;
@@ -195,8 +195,8 @@ public class MetricCheckProcessor implements ParseResultProcessor {
     }
 
     private boolean checkHasMetric(String correctSql, SemanticSchema semanticSchema) {
-        List<String> selectFields = SqlParserSelectHelper.getSelectFields(correctSql);
+        List<String> selectFields = SqlSelectHelper.getSelectFields(correctSql);
-        List<String> aggFields = SqlParserSelectHelper.getAggregateFields(correctSql);
+        List<String> aggFields = SqlSelectHelper.getAggregateFields(correctSql);
         List<String> collect = semanticSchema.getMetrics().stream()
                 .map(SchemaElement::getName).collect(Collectors.toList());
         for (String field : selectFields) {
@@ -209,11 +209,11 @@ public class MetricCheckProcessor implements ParseResultProcessor {
 
     private static String removeFieldInSql(String sql, Set<String> metricToRemove,
             Set<String> dimensionByToRemove, Set<String> whereFieldsToRemove) {
-        sql = SqlParserRemoveHelper.removeWhereCondition(sql, whereFieldsToRemove);
+        sql = SqlRemoveHelper.removeWhereCondition(sql, whereFieldsToRemove);
-        sql = SqlParserRemoveHelper.removeSelect(sql, metricToRemove);
+        sql = SqlRemoveHelper.removeSelect(sql, metricToRemove);
-        sql = SqlParserRemoveHelper.removeSelect(sql, dimensionByToRemove);
+        sql = SqlRemoveHelper.removeSelect(sql, dimensionByToRemove);
-        sql = SqlParserRemoveHelper.removeGroupBy(sql, dimensionByToRemove);
+        sql = SqlRemoveHelper.removeGroupBy(sql, dimensionByToRemove);
-        sql = SqlParserRemoveHelper.removeNumberFilter(sql);
+        sql = SqlRemoveHelper.removeNumberFilter(sql);
         return sql;
     }
 

chat/server/src/main/java/com/tencent/supersonic/chat/server/processor/parse/ParseInfoProcessor.java

@@ -17,7 +17,7 @@ import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
 import com.tencent.supersonic.common.util.ContextUtils;
 import com.tencent.supersonic.common.util.jsqlparser.FieldExpression;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;
@@ -60,7 +60,7 @@ public class ParseInfoProcessor implements ParseResultProcessor {
         if (correctS2SQL.equals(sqlInfo.getS2SQL())) {
             return;
         }
-        List<FieldExpression> expressions = SqlParserSelectHelper.getFilterExpression(correctS2SQL);
+        List<FieldExpression> expressions = SqlSelectHelper.getFilterExpression(correctS2SQL);
         //set dataInfo
         try {
             if (!org.apache.commons.collections.CollectionUtils.isEmpty(expressions)) {
@@ -87,15 +87,15 @@ public class ParseInfoProcessor implements ParseResultProcessor {
         if (Objects.isNull(semanticSchema)) {
             return;
         }
-        List<String> allFields = getFieldsExceptDate(SqlParserSelectHelper.getAllFields(sqlInfo.getCorrectS2SQL()));
+        List<String> allFields = getFieldsExceptDate(SqlSelectHelper.getAllFields(sqlInfo.getCorrectS2SQL()));
         Set<SchemaElement> metrics = getElements(viewId, allFields, semanticSchema.getMetrics());
         parseInfo.setMetrics(metrics);
         if (QueryType.METRIC.equals(parseInfo.getQueryType())) {
-            List<String> groupByFields = SqlParserSelectHelper.getGroupByFields(sqlInfo.getCorrectS2SQL());
+            List<String> groupByFields = SqlSelectHelper.getGroupByFields(sqlInfo.getCorrectS2SQL());
             List<String> groupByDimensions = getFieldsExceptDate(groupByFields);
             parseInfo.setDimensions(getElements(viewId, groupByDimensions, semanticSchema.getDimensions()));
         } else if (QueryType.TAG.equals(parseInfo.getQueryType())) {
-            List<String> selectFields = SqlParserSelectHelper.getSelectFields(sqlInfo.getCorrectS2SQL());
+            List<String> selectFields = SqlSelectHelper.getSelectFields(sqlInfo.getCorrectS2SQL());
             List<String> selectDimensions = getFieldsExceptDate(selectFields);
             parseInfo.setDimensions(getElements(viewId, selectDimensions, semanticSchema.getDimensions()));
         }

chat/server/src/main/java/com/tencent/supersonic/chat/server/service/impl/QueryServiceImpl.java

@@ -60,10 +60,10 @@ import com.tencent.supersonic.common.util.ContextUtils;
 import com.tencent.supersonic.common.util.DateUtils;
 import com.tencent.supersonic.common.util.JsonUtil;
 import com.tencent.supersonic.common.util.jsqlparser.FieldExpression;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserRemoveHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlRemoveHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import com.tencent.supersonic.headless.api.pojo.request.QueryStructReq;
 import com.tencent.supersonic.headless.api.pojo.response.SemanticQueryResp;
 import lombok.extern.slf4j.Slf4j;
@@ -318,7 +318,7 @@ public class QueryServiceImpl implements QueryService {
         if (Objects.nonNull(parseInfo.getSqlInfo())
                 && StringUtils.isNotBlank(parseInfo.getSqlInfo().getCorrectS2SQL())) {
             String correctorSql = parseInfo.getSqlInfo().getCorrectS2SQL();
-            fields = SqlParserSelectHelper.getAllFields(correctorSql);
+            fields = SqlSelectHelper.getAllFields(correctorSql);
         }
         if (LLMSqlQuery.QUERY_MODE.equalsIgnoreCase(parseInfo.getQueryMode())
                 && checkMetricReplace(fields, queryData.getMetrics())) {
@@ -373,8 +373,8 @@ public class QueryServiceImpl implements QueryService {
         String correctorSql = parseInfo.getSqlInfo().getCorrectS2SQL();
         log.info("correctorSql before replacing:{}", correctorSql);
         // get where filter and having filter
-        List<FieldExpression> whereExpressionList = SqlParserSelectHelper.getWhereExpressions(correctorSql);
+        List<FieldExpression> whereExpressionList = SqlSelectHelper.getWhereExpressions(correctorSql);
-        List<FieldExpression> havingExpressionList = SqlParserSelectHelper.getHavingExpressions(correctorSql);
+        List<FieldExpression> havingExpressionList = SqlSelectHelper.getHavingExpressions(correctorSql);
         List<Expression> addWhereConditions = new ArrayList<>();
         List<Expression> addHavingConditions = new ArrayList<>();
         Set<String> removeWhereFieldNames = new HashSet<>();
@@ -384,16 +384,16 @@ public class QueryServiceImpl implements QueryService {
                 parseInfo.getDimensionFilters(), addWhereConditions, removeWhereFieldNames);
         updateDateInfo(queryData, parseInfo, filedNameToValueMap,
                 whereExpressionList, addWhereConditions, removeWhereFieldNames);
-        correctorSql = SqlParserReplaceHelper.replaceValue(correctorSql, filedNameToValueMap);
+        correctorSql = SqlReplaceHelper.replaceValue(correctorSql, filedNameToValueMap);
-        correctorSql = SqlParserRemoveHelper.removeWhereCondition(correctorSql, removeWhereFieldNames);
+        correctorSql = SqlRemoveHelper.removeWhereCondition(correctorSql, removeWhereFieldNames);
         // replace having filter
         updateFilters(havingExpressionList, queryData.getDimensionFilters(),
                 parseInfo.getDimensionFilters(), addHavingConditions, removeHavingFieldNames);
-        correctorSql = SqlParserReplaceHelper.replaceHavingValue(correctorSql, havingFiledNameToValueMap);
+        correctorSql = SqlReplaceHelper.replaceHavingValue(correctorSql, havingFiledNameToValueMap);
-        correctorSql = SqlParserRemoveHelper.removeHavingCondition(correctorSql, removeHavingFieldNames);
+        correctorSql = SqlRemoveHelper.removeHavingCondition(correctorSql, removeHavingFieldNames);
 
-        correctorSql = SqlParserAddHelper.addWhere(correctorSql, addWhereConditions);
+        correctorSql = SqlAddHelper.addWhere(correctorSql, addWhereConditions);
-        correctorSql = SqlParserAddHelper.addHaving(correctorSql, addHavingConditions);
+        correctorSql = SqlAddHelper.addHaving(correctorSql, addHavingConditions);
         log.info("correctorSql after replacing:{}", correctorSql);
         return correctorSql;
     }
@@ -407,7 +407,7 @@ public class QueryServiceImpl implements QueryService {
         Map<String, Pair<String, String>> fieldMap = new HashMap<>();
         if (CollectionUtils.isNotEmpty(oriMetrics) && !oriMetrics.contains(metric.getName())) {
             fieldMap.put(oriMetrics.get(0), Pair.of(metric.getName(), metric.getDefaultAgg()));
-            correctorSql = SqlParserReplaceHelper.replaceAggFields(correctorSql, fieldMap);
+            correctorSql = SqlReplaceHelper.replaceAggFields(correctorSql, fieldMap);
         }
         log.info("after replaceMetrics:{}", correctorSql);
         parseInfo.getSqlInfo().setCorrectS2SQL(correctorSql);

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

@@ -0,0 +1,90 @@
+package com.tencent.supersonic.common.util.jsqlparser;
+
+import java.util.List;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
+import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
+import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
+import net.sf.jsqlparser.expression.operators.relational.MinorThan;
+import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
+import net.sf.jsqlparser.schema.Column;
+import org.springframework.util.CollectionUtils;
+
+@Slf4j
+public class DateVisitor extends ExpressionVisitorAdapter {
+
+    private List<String> filedNames;
+
+    private DateBoundInfo dateBoundInfo = new DateBoundInfo();
+
+    public DateVisitor(List<String> filedNames) {
+        this.filedNames = filedNames;
+    }
+
+    @Override
+    public void visit(GreaterThan expr) {
+        if (containsField(expr.getLeftExpression())) {
+            dateBoundInfo.setColumName(SqlSelectHelper.getColumnName(expr.getLeftExpression()));
+            dateBoundInfo.setLowerBound(expr.getStringExpression());
+            String columnValue = SqlSelectHelper.getColumValue(expr.getRightExpression());
+            dateBoundInfo.setLowerDate(columnValue);
+        }
+    }
+
+    @Override
+    public void visit(GreaterThanEquals expr) {
+        if (containsField(expr.getLeftExpression())) {
+            dateBoundInfo.setColumName(SqlSelectHelper.getColumnName(expr.getLeftExpression()));
+            dateBoundInfo.setLowerBound(expr.getStringExpression());
+            String columnValue = SqlSelectHelper.getColumValue(expr.getRightExpression());
+            dateBoundInfo.setLowerDate(columnValue);
+        }
+    }
+
+    @Override
+    public void visit(MinorThanEquals expr) {
+        if (containsField(expr.getLeftExpression())) {
+            dateBoundInfo.setColumName(SqlSelectHelper.getColumnName(expr.getLeftExpression()));
+            dateBoundInfo.setUpperBound(expr.getStringExpression());
+            String columnValue = SqlSelectHelper.getColumValue(expr.getRightExpression());
+            dateBoundInfo.setUpperDate(columnValue);
+        }
+    }
+
+    @Override
+    public void visit(MinorThan expr) {
+        if (containsField(expr.getLeftExpression())) {
+            dateBoundInfo.setColumName(SqlSelectHelper.getColumnName(expr.getLeftExpression()));
+            dateBoundInfo.setUpperBound(expr.getStringExpression());
+            String columnValue = SqlSelectHelper.getColumValue(expr.getRightExpression());
+            dateBoundInfo.setUpperDate(columnValue);
+        }
+    }
+
+    private boolean containsField(Expression expr) {
+        if (expr instanceof Column) {
+            Column column = (Column) expr;
+            if (!CollectionUtils.isEmpty(filedNames)
+                    && filedNames.contains(column.getColumnName())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public DateBoundInfo getDateBoundInfo() {
+        return dateBoundInfo;
+    }
+
+    @Data
+    public class DateBoundInfo {
+
+        private String columName;
+        private String lowerBound;
+        private String lowerDate;
+        private String upperBound;
+        private String upperDate;
+    }
+}

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

@@ -102,7 +102,7 @@ public class FieldlValueReplaceVisitor extends ExpressionVisitorAdapter {
         if (Objects.isNull(rightExpression) || Objects.isNull(leftExpression)) {
             return;
         }
-        String columnName = SqlParserSelectHelper.getColumnName(leftExpression);
+        String columnName = SqlSelectHelper.getColumnName(leftExpression);
         if (StringUtils.isEmpty(columnName)) {
             return;
         }

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

@@ -15,7 +15,7 @@ public class FunctionAliasReplaceVisitor extends SelectItemVisitorAdapter {
     public void visit(SelectExpressionItem selectExpressionItem) {
         if (selectExpressionItem.getExpression() instanceof Function) {
             Function function = (Function) selectExpressionItem.getExpression();
-            String columnName = SqlParserSelectHelper.getColumnName(function);
+            String columnName = SqlSelectHelper.getColumnName(function);
             //1.exist alias. as
             //2.alias's fieldName not equal. "sum(pv) as pv" cannot be replaced.
             if (Objects.nonNull(selectExpressionItem.getAlias()) && !selectExpressionItem.getAlias().getName()

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

@@ -31,10 +31,10 @@ import org.springframework.util.CollectionUtils;
  * Sql Parser add Helper
  */
 @Slf4j
-public class SqlParserAddHelper {
+public class SqlAddHelper {
 
     public static String addFieldsToSelect(String sql, List<String> fields) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         // add fields to select
         if (selectStatement == null) {
             return null;
@@ -63,7 +63,7 @@ public class SqlParserAddHelper {
     }
 
     public static String addFunctionToSelect(String sql, List<Expression> expressionList) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         if (selectStatement == null) {
             return null;
         }
@@ -116,7 +116,7 @@ public class SqlParserAddHelper {
         if (StringUtils.isEmpty(column) || Objects.isNull(value)) {
             return sql;
         }
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -139,7 +139,7 @@ public class SqlParserAddHelper {
     }
 
     public static String addWhere(String sql, Expression expression) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -157,7 +157,7 @@ public class SqlParserAddHelper {
     }
 
     public static String addWhere(String sql, List<Expression> expressionList) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -182,7 +182,7 @@ public class SqlParserAddHelper {
     }
 
     public static String addAggregateToField(String sql, Map<String, String> fieldNameToAggregate) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -204,7 +204,7 @@ public class SqlParserAddHelper {
         if (CollectionUtils.isEmpty(groupByFields)) {
             return sql;
         }
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -213,7 +213,7 @@ public class SqlParserAddHelper {
 
         PlainSelect plainSelect = (PlainSelect) selectBody;
         GroupByElement groupByElement = new GroupByElement();
-        List<String> originalGroupByFields = SqlParserSelectHelper.getGroupByFields(sql);
+        List<String> originalGroupByFields = SqlSelectHelper.getGroupByFields(sql);
         if (!CollectionUtils.isEmpty(originalGroupByFields)) {
             groupByFields.addAll(originalGroupByFields);
         }
@@ -230,7 +230,7 @@ public class SqlParserAddHelper {
             if (selectItem instanceof SelectExpressionItem) {
                 SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
                 Expression expression = selectExpressionItem.getExpression();
-                Function function = SqlParserSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
+                Function function = SqlSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
                 if (function == null) {
                     continue;
                 }
@@ -246,7 +246,7 @@ public class SqlParserAddHelper {
         }
         for (OrderByElement orderByElement : orderByElements) {
             Expression expression = orderByElement.getExpression();
-            Function function = SqlParserSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
+            Function function = SqlSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
             if (function == null) {
                 continue;
             }
@@ -260,7 +260,7 @@ public class SqlParserAddHelper {
             return;
         }
         for (Expression expression : groupByElement.getGroupByExpressions()) {
-            Function function = SqlParserSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
+            Function function = SqlSelectFunctionHelper.getFunction(expression, fieldNameToAggregate);
             if (function == null) {
                 continue;
             }
@@ -277,7 +277,7 @@ public class SqlParserAddHelper {
 
     private static void modifyWhereExpression(Expression whereExpression,
             Map<String, String> fieldNameToAggregate) {
-        if (SqlParserSelectHelper.isLogicExpression(whereExpression)) {
+        if (SqlSelectHelper.isLogicExpression(whereExpression)) {
             AndExpression andExpression = (AndExpression) whereExpression;
             Expression leftExpression = andExpression.getLeftExpression();
             Expression rightExpression = andExpression.getRightExpression();
@@ -297,7 +297,7 @@ public class SqlParserAddHelper {
         ComparisonOperator comparisonOperator = (ComparisonOperator) expression;
         if (comparisonOperator.getRightExpression() instanceof Column) {
             String columnName = ((Column) (comparisonOperator).getRightExpression()).getColumnName();
-            Function function = SqlParserSelectFunctionHelper.getFunction(comparisonOperator.getRightExpression(),
+            Function function = SqlSelectFunctionHelper.getFunction(comparisonOperator.getRightExpression(),
                     fieldNameToAggregate.get(columnName));
             if (Objects.nonNull(function)) {
                 comparisonOperator.setRightExpression(function);
@@ -305,7 +305,7 @@ public class SqlParserAddHelper {
         }
         if (comparisonOperator.getLeftExpression() instanceof Column) {
             String columnName = ((Column) (comparisonOperator).getLeftExpression()).getColumnName();
-            Function function = SqlParserSelectFunctionHelper.getFunction(comparisonOperator.getLeftExpression(),
+            Function function = SqlSelectFunctionHelper.getFunction(comparisonOperator.getLeftExpression(),
                     fieldNameToAggregate.get(columnName));
             if (Objects.nonNull(function)) {
                 comparisonOperator.setLeftExpression(function);
@@ -314,7 +314,7 @@ public class SqlParserAddHelper {
     }
 
     public static String addHaving(String sql, Set<String> fieldNames) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -339,11 +339,11 @@ public class SqlParserAddHelper {
                 }
             }
         }
-        return SqlParserRemoveHelper.removeNumberFilter(selectStatement.toString());
+        return SqlRemoveHelper.removeNumberFilter(selectStatement.toString());
     }
 
     public static String addHaving(String sql, List<Expression> expressionList) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -368,7 +368,7 @@ public class SqlParserAddHelper {
     }
 
     public static String addParenthesisToWhere(String sql) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {

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

@@ -0,0 +1,35 @@
+package com.tencent.supersonic.common.util.jsqlparser;
+
+import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
+import com.tencent.supersonic.common.util.jsqlparser.DateVisitor.DateBoundInfo;
+import java.util.List;
+import java.util.Objects;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.statement.select.PlainSelect;
+
+/**
+ * Date field parsing helper class
+ */
+@Slf4j
+public class SqlDateSelectHelper {
+
+    public static DateBoundInfo getDateBoundInfo(String sql) {
+        List<PlainSelect> plainSelectList = SqlSelectHelper.getPlainSelect(sql);
+        if (plainSelectList.size() != 1) {
+            return null;
+        }
+        PlainSelect plainSelect = plainSelectList.get(0);
+        if (Objects.isNull(plainSelect)) {
+            return null;
+        }
+        Expression where = plainSelect.getWhere();
+        if (Objects.isNull(where)) {
+            return null;
+        }
+        DateVisitor dateVisitor = new DateVisitor(TimeDimensionEnum.getChNameList());
+        where.accept(dateVisitor);
+        return dateVisitor.getDateBoundInfo();
+    }
+}
+

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

@@ -8,7 +8,7 @@ import org.apache.commons.collections.CollectionUtils;
  * Sql Parser equal Helper
  */
 @Slf4j
-public class SqlParserEqualHelper {
+public class SqlEqualHelper {
 
     /**
      * determine if two SQL statements are equal.
@@ -19,43 +19,43 @@ public class SqlParserEqualHelper {
      */
     public static boolean equals(String thisSql, String otherSql) {
         //1. select fields
-        List<String> thisSelectFields = SqlParserSelectHelper.getSelectFields(thisSql);
+        List<String> thisSelectFields = SqlSelectHelper.getSelectFields(thisSql);
-        List<String> otherSelectFields = SqlParserSelectHelper.getSelectFields(otherSql);
+        List<String> otherSelectFields = SqlSelectHelper.getSelectFields(otherSql);
 
         if (!CollectionUtils.isEqualCollection(thisSelectFields, otherSelectFields)) {
             return false;
         }
 
         //2. all fields
-        List<String> thisAllFields = SqlParserSelectHelper.getAllFields(thisSql);
+        List<String> thisAllFields = SqlSelectHelper.getAllFields(thisSql);
-        List<String> otherAllFields = SqlParserSelectHelper.getAllFields(otherSql);
+        List<String> otherAllFields = SqlSelectHelper.getAllFields(otherSql);
 
         if (!CollectionUtils.isEqualCollection(thisAllFields, otherAllFields)) {
             return false;
         }
 
         //3. where
-        List<FieldExpression> thisFieldExpressions = SqlParserSelectHelper.getFilterExpression(thisSql);
+        List<FieldExpression> thisFieldExpressions = SqlSelectHelper.getFilterExpression(thisSql);
-        List<FieldExpression> otherFieldExpressions = SqlParserSelectHelper.getFilterExpression(otherSql);
+        List<FieldExpression> otherFieldExpressions = SqlSelectHelper.getFilterExpression(otherSql);
 
         if (!CollectionUtils.isEqualCollection(thisFieldExpressions, otherFieldExpressions)) {
             return false;
         }
         //4. tableName
-        if (!SqlParserSelectHelper.getDbTableName(thisSql)
+        if (!SqlSelectHelper.getDbTableName(thisSql)
-                .equalsIgnoreCase(SqlParserSelectHelper.getDbTableName(otherSql))) {
+                .equalsIgnoreCase(SqlSelectHelper.getDbTableName(otherSql))) {
             return false;
         }
         //5. having
-        List<FieldExpression> thisHavingExpressions = SqlParserSelectHelper.getHavingExpressions(thisSql);
+        List<FieldExpression> thisHavingExpressions = SqlSelectHelper.getHavingExpressions(thisSql);
-        List<FieldExpression> otherHavingExpressions = SqlParserSelectHelper.getHavingExpressions(otherSql);
+        List<FieldExpression> otherHavingExpressions = SqlSelectHelper.getHavingExpressions(otherSql);
 
         if (!CollectionUtils.isEqualCollection(thisHavingExpressions, otherHavingExpressions)) {
             return false;
         }
         //6. orderBy
-        List<FieldExpression> thisOrderByExpressions = SqlParserSelectHelper.getOrderByExpressions(thisSql);
+        List<FieldExpression> thisOrderByExpressions = SqlSelectHelper.getOrderByExpressions(thisSql);
-        List<FieldExpression> otherOrderByExpressions = SqlParserSelectHelper.getOrderByExpressions(otherSql);
+        List<FieldExpression> otherOrderByExpressions = SqlSelectHelper.getOrderByExpressions(otherSql);
 
         if (!CollectionUtils.isEqualCollection(thisOrderByExpressions, otherOrderByExpressions)) {
             return false;

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

@@ -37,10 +37,10 @@ import java.util.Objects;
  * Sql Parser remove Helper
  */
 @Slf4j
-public class SqlParserRemoveHelper {
+public class SqlRemoveHelper {
 
     public static String removeSelect(String sql, Set<String> fields) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         if (selectStatement == null) {
             return sql;
         }
@@ -52,7 +52,7 @@ public class SqlParserRemoveHelper {
         selectItems.removeIf(selectItem -> {
             if (selectItem instanceof SelectExpressionItem) {
                 SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
-                String columnName = SqlParserSelectHelper.getColumnName(selectExpressionItem.getExpression());
+                String columnName = SqlSelectHelper.getColumnName(selectExpressionItem.getExpression());
                 return fields.contains(columnName);
             }
             return false;
@@ -61,7 +61,7 @@ public class SqlParserRemoveHelper {
     }
 
     public static String removeWhereCondition(String sql, Set<String> removeFieldNames) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -84,7 +84,7 @@ public class SqlParserRemoveHelper {
     }
 
     public static String removeNumberFilter(String sql) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         if (selectStatement == null) {
             return sql;
         }
@@ -105,7 +105,7 @@ public class SqlParserRemoveHelper {
     }
 
     private static void removeWhereExpression(Expression whereExpression, Set<String> removeFieldNames) {
-        if (SqlParserSelectHelper.isLogicExpression(whereExpression)) {
+        if (SqlSelectHelper.isLogicExpression(whereExpression)) {
             BinaryExpression binaryExpression = (BinaryExpression) whereExpression;
             Expression leftExpression = binaryExpression.getLeftExpression();
             Expression rightExpression = binaryExpression.getRightExpression();
@@ -140,7 +140,7 @@ public class SqlParserRemoveHelper {
                 || expression instanceof MinorThanEquals
                 || expression instanceof MinorThan) {
             ComparisonOperator comparisonOperator = (ComparisonOperator) expression;
-            String columnName = SqlParserSelectHelper.getColumnName(comparisonOperator.getLeftExpression(),
+            String columnName = SqlSelectHelper.getColumnName(comparisonOperator.getLeftExpression(),
                     comparisonOperator.getRightExpression());
             if (!removeFieldNames.contains(columnName)) {
                 return;
@@ -158,7 +158,7 @@ public class SqlParserRemoveHelper {
         }
         if (expression instanceof InExpression) {
             InExpression inExpression = (InExpression) expression;
-            String columnName = SqlParserSelectHelper.getColumnName(inExpression.getLeftExpression(),
+            String columnName = SqlSelectHelper.getColumnName(inExpression.getLeftExpression(),
                     inExpression.getRightExpression());
             if (!removeFieldNames.contains(columnName)) {
                 return;
@@ -175,7 +175,7 @@ public class SqlParserRemoveHelper {
         }
         if (expression instanceof LikeExpression) {
             LikeExpression likeExpression = (LikeExpression) expression;
-            String columnName = SqlParserSelectHelper.getColumnName(likeExpression.getLeftExpression(),
+            String columnName = SqlSelectHelper.getColumnName(likeExpression.getLeftExpression(),
                     likeExpression.getRightExpression());
             if (!removeFieldNames.contains(columnName)) {
                 return;
@@ -192,7 +192,7 @@ public class SqlParserRemoveHelper {
     }
 
     public static String removeHavingCondition(String sql, Set<String> removeFieldNames) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {
@@ -207,26 +207,8 @@ public class SqlParserRemoveHelper {
         return removeNumberFilter(selectStatement.toString());
     }
 
-    public static String removeWhere(String sql, List<String> fields) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
-        SelectBody selectBody = selectStatement.getSelectBody();
-        if (!(selectBody instanceof PlainSelect)) {
-            return sql;
-        }
-        PlainSelect plainSelect = (PlainSelect) selectBody;
-        Expression where = plainSelect.getWhere();
-
-        if (where == null) {
-            return sql;
-        } else {
-            where.accept(new FilterRemoveVisitor(fields));
-            plainSelect.setWhere(where);
-        }
-        return selectStatement.toString();
-    }
-
     public static String removeGroupBy(String sql, Set<String> fields) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         if (selectStatement == null) {
             return sql;
         }
@@ -328,7 +310,7 @@ public class SqlParserRemoveHelper {
             return distinguishNumberFilter(leftExpression, expression);
         }
         if (sqlEditEnum.equals(SqlEditEnum.DATEDIFF)) {
-            return SqlParserReplaceHelper.distinguishDateDiffFilter(leftExpression, expression);
+            return SqlReplaceHelper.distinguishDateDiffFilter(leftExpression, expression);
         }
         return expression;
     }

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

@@ -43,10 +43,10 @@ import org.springframework.util.CollectionUtils;
  * Sql Parser replace Helper
  */
 @Slf4j
-public class SqlParserReplaceHelper {
+public class SqlReplaceHelper {
 
     public static String replaceSelectFields(String sql, Map<String, String> fieldNameMap) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
@@ -84,7 +84,7 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceAggFields(String sql, Map<String, Pair<String, String>> fieldNameToAggMap) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
@@ -122,14 +122,14 @@ public class SqlParserReplaceHelper {
 
     public static String replaceValue(String sql, Map<String, Map<String, String>> filedNameToValueMap,
             boolean exactReplace) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
         }
         List<PlainSelect> plainSelectList = new ArrayList<>();
         plainSelectList.add((PlainSelect) selectBody);
-        List<PlainSelect> plainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+        List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             Expression where = plainSelect.getWhere();
             FieldlValueReplaceVisitor visitor = new FieldlValueReplaceVisitor(exactReplace, filedNameToValueMap);
@@ -141,14 +141,14 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceFieldNameByValue(String sql, Map<String, Set<String>> fieldValueToFieldNames) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
         }
         List<PlainSelect> plainSelectList = new ArrayList<>();
         plainSelectList.add((PlainSelect) selectBody);
-        List<PlainSelect> plainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+        List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             Expression where = plainSelect.getWhere();
             FiledNameReplaceVisitor visitor = new FiledNameReplaceVisitor(fieldValueToFieldNames);
@@ -164,7 +164,7 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceFields(String sql, Map<String, String> fieldNameMap, boolean exactReplace) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         System.out.println(selectStatement.getSelectBody());
         SelectBody selectBody = selectStatement.getSelectBody();
         List<PlainSelect> plainSelectList = new ArrayList<>();
@@ -189,7 +189,7 @@ public class SqlParserReplaceHelper {
         } else {
             return sql;
         }
-        List<PlainSelect> plainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+        List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             replaceFieldsInPlainOneSelect(fieldNameMap, exactReplace, plainSelect);
         }
@@ -238,7 +238,7 @@ public class SqlParserReplaceHelper {
                 SelectBody subSelectBody = ((SubSelect) join.getRightItem()).getSelectBody();
                 List<PlainSelect> plainSelectList = new ArrayList<>();
                 plainSelectList.add((PlainSelect) subSelectBody);
-                List<PlainSelect> subPlainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+                List<PlainSelect> subPlainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
                 for (PlainSelect subPlainSelect : subPlainSelects) {
                     replaceFieldsInPlainOneSelect(fieldNameMap, exactReplace, subPlainSelect);
                 }
@@ -262,14 +262,14 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceFunction(String sql, Map<String, String> functionMap) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
         }
         List<PlainSelect> plainSelectList = new ArrayList<>();
         plainSelectList.add((PlainSelect) selectBody);
-        List<PlainSelect> plainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+        List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             replaceFunction(functionMap, plainSelect);
         }
@@ -303,14 +303,14 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceFunction(String sql) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
         }
         Expression where = ((PlainSelect) selectBody).getWhere();
         try {
-            Expression expression = SqlParserRemoveHelper.filteredExpression(where, SqlEditEnum.DATEDIFF);
+            Expression expression = SqlRemoveHelper.filteredExpression(where, SqlEditEnum.DATEDIFF);
             ((PlainSelect) selectBody).setWhere(expression);
         } catch (Exception e) {
             log.info("replaceFunction has an exception:{}", e.toString());
@@ -384,7 +384,7 @@ public class SqlParserReplaceHelper {
         if (StringUtils.isEmpty(tableName)) {
             return sql;
         }
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (selectBody instanceof PlainSelect) {
             PlainSelect plainSelect = (PlainSelect) selectBody;
@@ -406,7 +406,7 @@ public class SqlParserReplaceHelper {
         // replace table name
         List<PlainSelect> plainSelects = new ArrayList<>();
         plainSelects.add(plainSelect);
-        List<PlainSelect> painSelects = SqlParserSelectHelper.getPlainSelects(plainSelects);
+        List<PlainSelect> painSelects = SqlSelectHelper.getPlainSelects(plainSelects);
         for (PlainSelect painSelect : painSelects) {
             painSelect.accept(
                     new SelectVisitorAdapter() {
@@ -422,7 +422,7 @@ public class SqlParserReplaceHelper {
                         SelectBody subSelectBody = ((SubSelect) join.getRightItem()).getSelectBody();
                         List<PlainSelect> plainSelectList = new ArrayList<>();
                         plainSelectList.add((PlainSelect) subSelectBody);
-                        List<PlainSelect> subPlainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+                        List<PlainSelect> subPlainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
                         for (PlainSelect subPlainSelect : subPlainSelects) {
                             subPlainSelect.getFromItem().accept(new TableNameReplaceVisitor(tableName));
                         }
@@ -436,7 +436,7 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceAlias(String sql) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
@@ -454,7 +454,7 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceHavingValue(String sql, Map<String, Map<String, String>> filedNameToValueMap) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
@@ -523,7 +523,7 @@ public class SqlParserReplaceHelper {
     }
 
     public static String replaceSqlByExpression(String sql, Map<String, String> replace) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
         List<PlainSelect> plainSelectList = new ArrayList<>();
         if (selectBody instanceof PlainSelect) {
@@ -539,7 +539,7 @@ public class SqlParserReplaceHelper {
         } else {
             return sql;
         }
-        List<PlainSelect> plainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+        List<PlainSelect> plainSelects = SqlSelectHelper.getPlainSelects(plainSelectList);
         for (PlainSelect plainSelect : plainSelects) {
             replacePlainSelectByExpr(plainSelect, replace);
         }

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

@@ -23,13 +23,13 @@ import java.util.Set;
  * Sql Parser Select function Helper
  */
 @Slf4j
-public class SqlParserSelectFunctionHelper {
+public class SqlSelectFunctionHelper {
 
     public static boolean hasAggregateFunction(String sql) {
         if (!CollectionUtils.isEmpty(getFunctions(sql))) {
             return true;
         }
-        return SqlParserSelectHelper.hasGroupBy(sql);
+        return SqlSelectHelper.hasGroupBy(sql);
     }
 
     public static void main(String[] args) {
@@ -46,7 +46,7 @@ public class SqlParserSelectFunctionHelper {
     }
 
     public static Set<String> getFunctions(String sql) {
-        Select selectStatement = SqlParserSelectHelper.getSelect(sql);
+        Select selectStatement = SqlSelectHelper.getSelect(sql);
         SelectBody selectBody = selectStatement.getSelectBody();
 
         if (!(selectBody instanceof PlainSelect)) {

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

@@ -13,15 +13,13 @@ import net.sf.jsqlparser.expression.CaseExpression;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
 import net.sf.jsqlparser.expression.Function;
+import net.sf.jsqlparser.expression.LongValue;
 import net.sf.jsqlparser.expression.StringValue;
 import net.sf.jsqlparser.expression.WhenClause;
 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.GreaterThan;
-import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
-import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.schema.Table;
@@ -38,14 +36,13 @@ 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.ImmutablePair;
 import org.springframework.util.CollectionUtils;
 
 /**
  * Sql Parser Select Helper
  */
 @Slf4j
-public class SqlParserSelectHelper {
+public class SqlSelectHelper {
 
     public static List<FieldExpression> getFilterExpression(String sql) {
         List<PlainSelect> plainSelectList = getPlainSelect(sql);
@@ -435,34 +432,16 @@ public class SqlParserSelectHelper {
         return "";
     }
 
-    public static Expression getTimeFilter(List<ImmutablePair<String, String>> times, String columnBegin,
+    public static String getColumValue(Expression expression) {
-            String columnEnd) {
+        if (expression instanceof StringValue) {
-        Expression expression = null;
+            StringValue value = (StringValue) expression;
-        for (ImmutablePair<String, String> t : times) {
+            return value.getValue();
-            Expression expr = null;
-            ComparisonOperator left = new MinorThanEquals();
-            if (t.left.equals(t.right)) {
-                left.setLeftExpression(new Column(columnBegin));
-                left.setRightExpression(new StringValue(t.left));
-                ComparisonOperator right = new GreaterThan();
-                right.setLeftExpression(new Column(columnEnd));
-                right.setRightExpression(new StringValue(t.right));
-                expr = new AndExpression(left, right);
-            } else {
-                left.setLeftExpression(new StringValue(t.left));
-                left.setRightExpression(new Column(columnEnd));
-                ComparisonOperator right = new GreaterThanEquals();
-                right.setLeftExpression(new StringValue(t.right));
-                right.setRightExpression(new Column(columnBegin));
-                expr = new AndExpression(left, right);
-            }
-            if (expression == null) {
-                expression = expr;
-                continue;
-            }
-            expression = new OrExpression(expression, expr);
         }
-        return expression;
+        if (expression instanceof LongValue) {
+            LongValue value = (LongValue) expression;
+            return String.valueOf(value.getValue());
+        }
+        return "";
     }
 
     public static Table getTable(String sql) {
@@ -488,14 +467,6 @@ public class SqlParserSelectHelper {
         return table.getFullyQualifiedName();
     }
 
-    public static String getNormalizedSql(String sql) {
-        Select selectStatement = getSelect(sql);
-        if (selectStatement == null) {
-            return null;
-        }
-        return selectStatement.toString();
-    }
-
     public static Set<String> getColumnFromExpr(String expr) {
         Expression expression = QueryExpressionReplaceVisitor.getExpression(expr);
         Set<String> columns = new HashSet<>();

common/src/test/java/com/tencent/supersonic/common/util/DateUtilsTest.java

@@ -10,7 +10,7 @@ import java.util.List;
 class DateUtilsTest {
 
     @Test
-    void getBeforeDate() {
+    void testGetBeforeDate() {
 
         String dateStr = DateUtils.getBeforeDate("2023-08-10", 1, DatePeriodEnum.DAY);
         Assert.assertEquals(dateStr, "2023-08-09");
@@ -38,18 +38,6 @@ class DateUtilsTest {
 
         dateStr = DateUtils.getBeforeDate("2023-08-10", 0, DatePeriodEnum.YEAR);
         Assert.assertEquals(dateStr, "2023-01-01");
-
-        dateStr = DateUtils.getBeforeDate(0, DatePeriodEnum.DAY);
-        //Assert.assertEquals(dateStr, "2023-09-08");
-
-        dateStr = DateUtils.getBeforeDate(1, DatePeriodEnum.DAY);
-        //Assert.assertEquals(dateStr, "2023-09-07");
-
-        dateStr = DateUtils.getBeforeDate(1, DatePeriodEnum.WEEK);
-        //Assert.assertEquals(dateStr, "2023-09-01");
-
-        dateStr = DateUtils.getBeforeDate(1, DatePeriodEnum.MONTH);
-        //Assert.assertEquals(dateStr, "2023-08-08");
     }
 
     @Test

common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlAddHelperTest.java

@@ -15,26 +15,26 @@ import org.junit.jupiter.api.Test;
 /**
  * SqlParserAddHelperTest Test
  */
-class SqlParserAddHelperTest {
+class SqlAddHelperTest {
 
     @Test
-    void addWhere() throws JSQLParserException {
+    void testAddWhere() throws JSQLParserException {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        sql = SqlParserAddHelper.addWhere(sql, "column_a", 123444555);
+        sql = SqlAddHelper.addWhere(sql, "column_a", 123444555);
-        List<String> selectFields = SqlParserSelectHelper.getAllFields(sql);
+        List<String> selectFields = SqlSelectHelper.getAllFields(sql);
 
         Assert.assertEquals(selectFields.contains("column_a"), true);
 
-        sql = SqlParserAddHelper.addWhere(sql, "column_b", "123456666");
+        sql = SqlAddHelper.addWhere(sql, "column_b", "123456666");
-        selectFields = SqlParserSelectHelper.getAllFields(sql);
+        selectFields = SqlSelectHelper.getAllFields(sql);
 
         Assert.assertEquals(selectFields.contains("column_b"), true);
 
         Expression expression = CCJSqlParserUtil.parseCondExpression(" ( column_c = 111  or column_d = 1111)");
 
-        sql = SqlParserAddHelper.addWhere(
+        sql = SqlAddHelper.addWhere(
                 "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                         + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1",
                 expression);
@@ -42,20 +42,20 @@ class SqlParserAddHelperTest {
         Assert.assertEquals(sql.contains("column_c = 111"), true);
 
         sql = "select 部门,sum (访问次数) from 超音数 where 用户 = alice or 发布日期 ='2023-07-03' group by 部门 limit 1";
-        sql = SqlParserAddHelper.addParenthesisToWhere(sql);
+        sql = SqlAddHelper.addParenthesisToWhere(sql);
-        sql = SqlParserAddHelper.addWhere(sql, "数据日期", "2023-08-08");
+        sql = SqlAddHelper.addWhere(sql, "数据日期", "2023-08-08");
         Assert.assertEquals(sql, "SELECT 部门, sum(访问次数) FROM 超音数 WHERE "
                 + "(用户 = alice OR 发布日期 = '2023-07-03') AND 数据日期 = '2023-08-08' GROUP BY 部门 LIMIT 1");
 
     }
 
     @Test
-    void addFunctionToSelect() {
+    void testAddFunctionToSelect() {
         String sql = "SELECT user_name FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                 + "sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000";
-        List<Expression> havingExpressionList = SqlParserSelectHelper.getHavingExpression(sql);
+        List<Expression> havingExpressionList = SqlSelectHelper.getHavingExpression(sql);
 
-        String replaceSql = SqlParserAddHelper.addFunctionToSelect(sql, havingExpressionList);
+        String replaceSql = SqlAddHelper.addFunctionToSelect(sql, havingExpressionList);
         System.out.println(replaceSql);
         Assert.assertEquals("SELECT user_name, sum(pv) FROM 超音数 WHERE sys_imp_date <= '2023-09-03' "
                         + "AND sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000",
@@ -63,9 +63,9 @@ class SqlParserAddHelperTest {
 
         sql = "SELECT user_name,sum(pv) FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                 + "sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000";
-        havingExpressionList = SqlParserSelectHelper.getHavingExpression(sql);
+        havingExpressionList = SqlSelectHelper.getHavingExpression(sql);
 
-        replaceSql = SqlParserAddHelper.addFunctionToSelect(sql, havingExpressionList);
+        replaceSql = SqlAddHelper.addFunctionToSelect(sql, havingExpressionList);
         System.out.println(replaceSql);
         Assert.assertEquals("SELECT user_name, sum(pv) FROM 超音数 WHERE sys_imp_date <= '2023-09-03' "
                         + "AND sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000",
@@ -73,9 +73,9 @@ class SqlParserAddHelperTest {
 
         sql = "SELECT user_name,sum(pv) FROM 超音数 WHERE (sys_imp_date <= '2023-09-03') AND "
                 + "sys_imp_date = '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000";
-        havingExpressionList = SqlParserSelectHelper.getHavingExpression(sql);
+        havingExpressionList = SqlSelectHelper.getHavingExpression(sql);
 
-        replaceSql = SqlParserAddHelper.addFunctionToSelect(sql, havingExpressionList);
+        replaceSql = SqlAddHelper.addFunctionToSelect(sql, havingExpressionList);
         System.out.println(replaceSql);
         Assert.assertEquals("SELECT user_name, sum(pv) FROM 超音数 WHERE (sys_imp_date <= '2023-09-03') "
                         + "AND sys_imp_date = '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000",
@@ -84,12 +84,12 @@ class SqlParserAddHelperTest {
     }
 
     @Test
-    void addAggregateToField() {
+    void testAddAggregateToField() {
         String sql = "SELECT user_name FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                 + "sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000";
-        List<Expression> havingExpressionList = SqlParserSelectHelper.getHavingExpression(sql);
+        List<Expression> havingExpressionList = SqlSelectHelper.getHavingExpression(sql);
 
-        String replaceSql = SqlParserAddHelper.addFunctionToSelect(sql, havingExpressionList);
+        String replaceSql = SqlAddHelper.addFunctionToSelect(sql, havingExpressionList);
         System.out.println(replaceSql);
         Assert.assertEquals("SELECT user_name, sum(pv) FROM 超音数 WHERE sys_imp_date <= '2023-09-03' "
                         + "AND sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000",
@@ -97,9 +97,9 @@ class SqlParserAddHelperTest {
 
         sql = "SELECT user_name,sum(pv) FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                 + "sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000";
-        havingExpressionList = SqlParserSelectHelper.getHavingExpression(sql);
+        havingExpressionList = SqlSelectHelper.getHavingExpression(sql);
 
-        replaceSql = SqlParserAddHelper.addFunctionToSelect(sql, havingExpressionList);
+        replaceSql = SqlAddHelper.addFunctionToSelect(sql, havingExpressionList);
         System.out.println(replaceSql);
         Assert.assertEquals("SELECT user_name, sum(pv) FROM 超音数 WHERE sys_imp_date <= '2023-09-03' "
                         + "AND sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000",
@@ -107,9 +107,9 @@ class SqlParserAddHelperTest {
 
         sql = "SELECT user_name,sum(pv) FROM 超音数 WHERE (sys_imp_date <= '2023-09-03') AND "
                 + "sys_imp_date = '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000";
-        havingExpressionList = SqlParserSelectHelper.getHavingExpression(sql);
+        havingExpressionList = SqlSelectHelper.getHavingExpression(sql);
 
-        replaceSql = SqlParserAddHelper.addFunctionToSelect(sql, havingExpressionList);
+        replaceSql = SqlAddHelper.addFunctionToSelect(sql, havingExpressionList);
         System.out.println(replaceSql);
         Assert.assertEquals("SELECT user_name, sum(pv) FROM 超音数 WHERE (sys_imp_date <= '2023-09-03') "
                         + "AND sys_imp_date = '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000",
@@ -117,7 +117,7 @@ class SqlParserAddHelperTest {
     }
 
     @Test
-    void addAggregateToMetricField() {
+    void testAddAggregateToMetricField() {
         String sql = "select department, pv from t_1 where sys_imp_date = '2023-09-11' order by pv desc limit 10";
 
         Map<String, String> filedNameToAggregate = new HashMap<>();
@@ -126,8 +126,8 @@ class SqlParserAddHelperTest {
         Set<String> groupByFields = new HashSet<>();
         groupByFields.add("department");
 
-        String replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        String replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -136,8 +136,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, pv from t_1 where sys_imp_date = '2023-09-11' and pv >1  "
                 + "order by pv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -145,8 +145,8 @@ class SqlParserAddHelperTest {
                 replaceSql);
 
         sql = "select department, pv from t_1 where pv >1  order by pv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sum(pv) > 1 "
@@ -154,8 +154,8 @@ class SqlParserAddHelperTest {
                 replaceSql);
 
         sql = "select department, pv from t_1 where sum(pv) >1  order by pv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sum(pv) > 1 "
@@ -164,8 +164,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, sum(pv) from t_1 where sys_imp_date = '2023-09-11' and sum(pv) >1 "
                 + "GROUP BY department order by pv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -174,8 +174,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, pv from t_1 where sys_imp_date = '2023-09-11' and pv >1 "
                 + "GROUP BY department order by pv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -184,8 +184,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, pv from t_1 where sys_imp_date = '2023-09-11' and pv >1 and department = 'HR' "
                 + "GROUP BY department order by pv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' AND sum(pv) > 1 "
@@ -194,8 +194,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, pv from t_1 where (pv >1 and department = 'HR') "
                 + " and sys_imp_date = '2023-09-11' GROUP BY department order by pv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE (sum(pv) > 1 AND department = 'HR') AND "
@@ -204,9 +204,9 @@ class SqlParserAddHelperTest {
 
         sql = "select department, sum(pv) as pv from t_1 where sys_imp_date = '2023-09-11' GROUP BY "
                 + "department order by pv desc limit 10";
-        replaceSql = SqlParserReplaceHelper.replaceAlias(sql);
+        replaceSql = SqlReplaceHelper.replaceAlias(sql);
-        replaceSql = SqlParserAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) AS pv "
@@ -216,7 +216,7 @@ class SqlParserAddHelperTest {
     }
 
     @Test
-    void addAggregateToCountDiscountMetricField() {
+    void testAddAggregateToCountDiscountMetricField() {
         String sql = "select department, uv from t_1 where sys_imp_date = '2023-09-11' order by uv desc limit 10";
 
         Map<String, String> filedNameToAggregate = new HashMap<>();
@@ -225,8 +225,8 @@ class SqlParserAddHelperTest {
         Set<String> groupByFields = new HashSet<>();
         groupByFields.add("department");
 
-        String replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        String replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -235,8 +235,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, uv from t_1 where sys_imp_date = '2023-09-11' and uv >1  "
                 + "order by uv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -244,8 +244,8 @@ class SqlParserAddHelperTest {
                 replaceSql);
 
         sql = "select department, uv from t_1 where uv >1  order by uv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE count(DISTINCT uv) > 1 "
@@ -253,8 +253,8 @@ class SqlParserAddHelperTest {
                 replaceSql);
 
         sql = "select department, uv from t_1 where count(DISTINCT uv) >1  order by uv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE count(DISTINCT uv) > 1 "
@@ -264,8 +264,8 @@ class SqlParserAddHelperTest {
         sql = "select department, count(DISTINCT uv) from t_1 where sys_imp_date = '2023-09-11'"
                 + " and count(DISTINCT uv) >1 "
                 + "GROUP BY department order by count(DISTINCT uv) desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -274,8 +274,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, uv from t_1 where sys_imp_date = '2023-09-11' and uv >1 "
                 + "GROUP BY department order by count(DISTINCT uv) desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -284,8 +284,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, uv from t_1 where sys_imp_date = '2023-09-11' and uv >1 and department = 'HR' "
                 + "GROUP BY department order by uv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE sys_imp_date = "
@@ -295,8 +295,8 @@ class SqlParserAddHelperTest {
 
         sql = "select department, uv from t_1 where (uv >1 and department = 'HR') "
                 + " and sys_imp_date = '2023-09-11' GROUP BY department order by uv desc limit 10";
-        replaceSql = SqlParserAddHelper.addAggregateToField(sql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) FROM t_1 WHERE (count(DISTINCT uv) > "
@@ -307,9 +307,9 @@ class SqlParserAddHelperTest {
 
         sql = "select department, count(DISTINCT uv) as uv from t_1 where sys_imp_date = '2023-09-11' GROUP BY "
                 + "department order by uv desc limit 10";
-        replaceSql = SqlParserReplaceHelper.replaceAlias(sql);
+        replaceSql = SqlReplaceHelper.replaceAlias(sql);
-        replaceSql = SqlParserAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
+        replaceSql = SqlAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
-        replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(replaceSql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, count(DISTINCT uv) AS uv "
@@ -319,14 +319,14 @@ class SqlParserAddHelperTest {
     }
 
     @Test
-    void addGroupBy() {
+    void testAddGroupBy() {
         String sql = "select department, sum(pv) from t_1 where sys_imp_date = '2023-09-11' "
                 + "order by sum(pv) desc limit 10";
 
         Set<String> groupByFields = new HashSet<>();
         groupByFields.add("department");
 
-        String replaceSql = SqlParserAddHelper.addGroupBy(sql, groupByFields);
+        String replaceSql = SqlAddHelper.addGroupBy(sql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -336,7 +336,7 @@ class SqlParserAddHelperTest {
         sql = "select department, sum(pv) from t_1 where (department = 'HR') and sys_imp_date = '2023-09-11' "
                 + "order by sum(pv) desc limit 10";
 
-        replaceSql = SqlParserAddHelper.addGroupBy(sql, groupByFields);
+        replaceSql = SqlAddHelper.addGroupBy(sql, groupByFields);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE (department = 'HR') AND sys_imp_date "
@@ -345,7 +345,7 @@ class SqlParserAddHelperTest {
     }
 
     @Test
-    void addHaving() {
+    void testAddHaving() {
         String sql = "select department, sum(pv) from t_1 where sys_imp_date = '2023-09-11' and "
                 + "sum(pv) > 2000 group by department order by sum(pv) desc limit 10";
         List<String> groupByFields = new ArrayList<>();
@@ -354,7 +354,7 @@ class SqlParserAddHelperTest {
         Set<String> fieldNames = new HashSet<>();
         fieldNames.add("pv");
 
-        String replaceSql = SqlParserAddHelper.addHaving(sql, fieldNames);
+        String replaceSql = SqlAddHelper.addHaving(sql, fieldNames);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -364,7 +364,7 @@ class SqlParserAddHelperTest {
         sql = "select department, sum(pv) from t_1 where (sum(pv) > 2000)  and sys_imp_date = '2023-09-11' "
                 + "group by department order by sum(pv) desc limit 10";
 
-        replaceSql = SqlParserAddHelper.addHaving(sql, fieldNames);
+        replaceSql = SqlAddHelper.addHaving(sql, fieldNames);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM t_1 WHERE sys_imp_date = '2023-09-11' "
@@ -373,12 +373,12 @@ class SqlParserAddHelperTest {
     }
 
     @Test
-    void addParenthesisToWhere() {
+    void testAddParenthesisToWhere() {
         String sql = "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
                 + "and 歌曲名 = '邓紫棋' and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
                 + " order by 播放量 desc limit 11";
 
-        String replaceSql = SqlParserAddHelper.addParenthesisToWhere(sql);
+        String replaceSql = SqlAddHelper.addParenthesisToWhere(sql);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE (datediff('day', 发布日期, '2023-08-09') <= 1 "
@@ -388,10 +388,10 @@ class SqlParserAddHelperTest {
     }
 
     @Test
-    void addFieldsToSelect() {
+    void testAddFieldsToSelect() {
         String correctS2SQL = "SELECT 用户, 页面  FROM 超音数用户部门 GROUP BY 用户, 页面 ORDER BY count(*) DESC";
-        String replaceFields = SqlParserAddHelper.addFieldsToSelect(correctS2SQL,
+        String replaceFields = SqlAddHelper.addFieldsToSelect(correctS2SQL,
-                SqlParserSelectHelper.getOrderByFields(correctS2SQL));
+                SqlSelectHelper.getOrderByFields(correctS2SQL));
 
         Assert.assertEquals(
                 "SELECT 用户, 页面 FROM 超音数用户部门 GROUP BY 用户, 页面 ORDER BY count(*) DESC", replaceFields);

common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlDateSelectHelperTest.java

@@ -0,0 +1,46 @@
+package com.tencent.supersonic.common.util.jsqlparser;
+
+
+import com.tencent.supersonic.common.util.jsqlparser.DateVisitor.DateBoundInfo;
+import org.junit.Assert;
+import org.junit.jupiter.api.Test;
+
+class SqlDateSelectHelperTest {
+
+    @Test
+    void testGetDateBoundInfo() {
+
+        String sql = "SELECT 维度1,sum(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 >= '2023-11-17' GROUP BY 维度1";
+        DateBoundInfo dateBoundInfo = SqlDateSelectHelper.getDateBoundInfo(sql);
+        Assert.assertEquals(dateBoundInfo.getLowerBound(), ">=");
+        Assert.assertEquals(dateBoundInfo.getLowerDate(), "2023-11-17");
+
+        sql = "SELECT 维度1,sum(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 > '2023-11-17' GROUP BY 维度1";
+        dateBoundInfo = SqlDateSelectHelper.getDateBoundInfo(sql);
+        Assert.assertEquals(dateBoundInfo.getLowerBound(), ">");
+        Assert.assertEquals(dateBoundInfo.getLowerDate(), "2023-11-17");
+
+        sql = "SELECT 维度1,sum(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 <= '2023-11-17' GROUP BY 维度1";
+        dateBoundInfo = SqlDateSelectHelper.getDateBoundInfo(sql);
+        Assert.assertEquals(dateBoundInfo.getUpperBound(), "<=");
+        Assert.assertEquals(dateBoundInfo.getUpperDate(), "2023-11-17");
+
+        sql = "SELECT 维度1,sum(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 < '2023-11-17' GROUP BY 维度1";
+        dateBoundInfo = SqlDateSelectHelper.getDateBoundInfo(sql);
+        Assert.assertEquals(dateBoundInfo.getUpperBound(), "<");
+        Assert.assertEquals(dateBoundInfo.getUpperDate(), "2023-11-17");
+
+        sql = "SELECT 维度1,sum(播放量) FROM 数据库 "
+                + "WHERE (歌手名 = '张三') AND 数据日期 >= '2023-10-17' "
+                + "AND 数据日期 <= '2023-11-17' GROUP BY 维度1";
+        dateBoundInfo = SqlDateSelectHelper.getDateBoundInfo(sql);
+        Assert.assertEquals(dateBoundInfo.getUpperBound(), "<=");
+        Assert.assertEquals(dateBoundInfo.getUpperDate(), "2023-11-17");
+        Assert.assertEquals(dateBoundInfo.getLowerBound(), ">=");
+        Assert.assertEquals(dateBoundInfo.getLowerDate(), "2023-10-17");
+    }
+}

common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlEqualHelperTest.java

@@ -8,33 +8,33 @@ import org.junit.jupiter.api.Test;
  * @author lex luo
  * @date 2023/11/15 15:04
  */
-class SqlParserEqualHelperTest {
+class SqlEqualHelperTest {
 
     @Test
     void testEquals() {
         String sql1 = "SELECT * FROM table1 WHERE column1 = 1 AND column2 = 2";
         String sql2 = "SELECT * FROM table1 WHERE column2 = 2 AND column1 = 1";
-        Assert.equals(SqlParserEqualHelper.equals(sql1, sql2), true);
+        Assert.equals(SqlEqualHelper.equals(sql1, sql2), true);
 
         sql1 = "SELECT a,b,c,d FROM table1 WHERE column1 = 1 AND column2 = 2 order by a";
         sql2 = "SELECT d,c,b,a FROM table1 WHERE column2 = 2 AND column1 = 1 order by a";
-        Assert.equals(SqlParserEqualHelper.equals(sql1, sql2), true);
+        Assert.equals(SqlEqualHelper.equals(sql1, sql2), true);
 
         sql1 = "SELECT a,sum(b),sum(c),sum(d) FROM table1 WHERE column1 = 1 AND column2 = 2 group by a order by a";
 
         sql2 = "SELECT sum(d),sum(c),sum(b),a FROM table1 WHERE column2 = 2 AND column1 = 1 group by a order by a";
 
-        Assert.equals(SqlParserEqualHelper.equals(sql1, sql2), true);
+        Assert.equals(SqlEqualHelper.equals(sql1, sql2), true);
 
         sql1 = "SELECT a,sum(b),sum(c),sum(d) FROM table1 WHERE column1 = 1 AND column2 = 2 group by a order by a";
 
         sql2 = "SELECT sum(d),sum(c),sum(b),a FROM table1 WHERE column2 = 2 AND column1 = 1 group by a order by a";
 
-        Assert.equals(SqlParserEqualHelper.equals(sql1, sql2), true);
+        Assert.equals(SqlEqualHelper.equals(sql1, sql2), true);
 
         sql1 = "SELECT a,b,c,d FROM table1 WHERE column1 = 1 AND column2 = 2 order by a";
         sql2 = "SELECT d,c,b,f FROM table1 WHERE column2 = 2 AND column1 = 1 order by a";
-        Assert.equals(SqlParserEqualHelper.equals(sql1, sql2), false);
+        Assert.equals(SqlEqualHelper.equals(sql1, sql2), false);
 
         sql1 = "SELECT\n"
                 + "页面,\n"
@@ -64,6 +64,6 @@ class SqlParserEqualHelperTest {
                 + "LIMIT\n"
                 + "365";
 
-        Assert.equals(SqlParserEqualHelper.equals(sql1, sql2), true);
+        Assert.equals(SqlEqualHelper.equals(sql1, sql2), true);
     }
 }

common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlRemoveHelperTest.java

@@ -8,13 +8,13 @@ import org.junit.jupiter.api.Test;
 /**
  * SqlParser Remove Helper Test
  */
-class SqlParserRemoveHelperTest {
+class SqlRemoveHelperTest {
 
     @Test
-    void removeWhereHavingCondition() {
+    void testRemoveWhereHavingCondition() {
         String sql = "select 歌曲名 from 歌曲库 where sum(粉丝数) > 20000 and  2>1 and "
                 + "sum(播放量) > 20000 and 1=1  HAVING sum(播放量) > 20000 and 3>1";
-        sql = SqlParserRemoveHelper.removeNumberFilter(sql);
+        sql = SqlRemoveHelper.removeNumberFilter(sql);
         System.out.println(sql);
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE sum(粉丝数) > 20000 AND sum(播放量) > 20000 HAVING sum(播放量) > 20000",
@@ -22,7 +22,7 @@ class SqlParserRemoveHelperTest {
         sql = "SELECT 歌曲,sum(播放量) FROM 歌曲库\n"
                 + "WHERE (歌手名 = '张三' AND 2 > 1) AND 数据日期 = '2023-11-07'\n"
                 + "GROUP BY 歌曲名 HAVING sum(播放量) > 100000";
-        sql = SqlParserRemoveHelper.removeNumberFilter(sql);
+        sql = SqlRemoveHelper.removeNumberFilter(sql);
         System.out.println(sql);
         Assert.assertEquals(
                 "SELECT 歌曲, sum(播放量) FROM 歌曲库 WHERE (歌手名 = '张三') "
@@ -31,7 +31,7 @@ class SqlParserRemoveHelperTest {
         sql = "SELECT 歌曲名,sum(播放量) FROM 歌曲库 WHERE (1 = 1 AND 1 = 1 AND 2 > 1 )"
                 + "AND 1 = 1 AND 歌曲类型 IN ('类型一', '类型二') AND 歌手名 IN ('林俊杰', '周杰伦')"
                 + "AND 数据日期 = '2023-11-07' GROUP BY 歌曲名 HAVING 2 > 1 AND SUM(播放量) >= 1000";
-        sql = SqlParserRemoveHelper.removeNumberFilter(sql);
+        sql = SqlRemoveHelper.removeNumberFilter(sql);
         System.out.println(sql);
         Assert.assertEquals(
                 "SELECT 歌曲名, sum(播放量) FROM 歌曲库 WHERE 歌曲类型 IN ('类型一', '类型二') "
@@ -41,7 +41,7 @@ class SqlParserRemoveHelperTest {
 
         sql = "SELECT 品牌名称,法人 FROM 互联网企业 WHERE (2 > 1 AND 1 = 1) AND 数据日期 = '2023-10-31'"
                 + "GROUP BY 品牌名称, 法人 HAVING 2 > 1 AND sum(注册资本) > 100000000 AND sum(营收占比) = 0.5 and 1 = 1";
-        sql = SqlParserRemoveHelper.removeNumberFilter(sql);
+        sql = SqlRemoveHelper.removeNumberFilter(sql);
         System.out.println(sql);
         Assert.assertEquals(
                 "SELECT 品牌名称, 法人 FROM 互联网企业 WHERE 数据日期 = '2023-10-31' GROUP BY "
@@ -50,11 +50,11 @@ class SqlParserRemoveHelperTest {
     }
 
     @Test
-    void removeHavingCondition() {
+    void testRemoveHavingCondition() {
         String sql = "select 歌曲名 from 歌曲库 where 歌手名 = '周杰伦'   HAVING sum(播放量) > 20000";
         Set<String> removeFieldNames = new HashSet<>();
         removeFieldNames.add("播放量");
-        String replaceSql = SqlParserRemoveHelper.removeHavingCondition(sql, removeFieldNames);
+        String replaceSql = SqlRemoveHelper.removeHavingCondition(sql, removeFieldNames);
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE 歌手名 = '周杰伦'",
                 replaceSql);
@@ -62,7 +62,7 @@ class SqlParserRemoveHelperTest {
     }
 
     @Test
-    void removeWhereCondition() {
+    void testRemoveWhereCondition() {
         String sql = "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
                 + "and 歌曲名 = '邓紫棋' and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
                 + " order by 播放量 desc limit 11";
@@ -70,7 +70,7 @@ class SqlParserRemoveHelperTest {
         Set<String> removeFieldNames = new HashSet<>();
         removeFieldNames.add("歌曲名");
 
-        String replaceSql = SqlParserRemoveHelper.removeWhereCondition(sql, removeFieldNames);
+        String replaceSql = SqlRemoveHelper.removeWhereCondition(sql, removeFieldNames);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE datediff('day', 发布日期, '2023-08-09') <= 1 "
@@ -81,7 +81,7 @@ class SqlParserRemoveHelperTest {
         sql = "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
                 + "and 歌曲名 in ('邓紫棋','周杰伦') and 歌曲名 in ('邓紫棋') and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
                 + " order by 播放量 desc limit 11";
-        replaceSql = SqlParserRemoveHelper.removeWhereCondition(sql, removeFieldNames);
+        replaceSql = SqlRemoveHelper.removeWhereCondition(sql, removeFieldNames);
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE datediff('day', 发布日期, '2023-08-09') <= 1 "
                         + "AND 数据日期 = '2023-08-09' AND "
@@ -91,7 +91,7 @@ class SqlParserRemoveHelperTest {
         sql = "select 歌曲名 from 歌曲库 where (datediff('day', 发布日期, '2023-08-09') <= 1 "
                 + "and 歌曲名 in ('邓紫棋','周杰伦') and 歌曲名 in ('邓紫棋')) and 数据日期 = '2023-08-09' "
                 + " order by 播放量 desc limit 11";
-        replaceSql = SqlParserRemoveHelper.removeWhereCondition(sql, removeFieldNames);
+        replaceSql = SqlRemoveHelper.removeWhereCondition(sql, removeFieldNames);
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE (datediff('day', 发布日期, '2023-08-09') <= 1) "
                         + "AND 数据日期 = '2023-08-09' ORDER BY 播放量 DESC LIMIT 11",

common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlReplaceHelperTest.java

@@ -14,16 +14,16 @@ import java.util.Set;
 /**
  * SqlParserReplaceHelperTest
  */
-class SqlParserReplaceHelperTest {
+class SqlReplaceHelperTest {
 
     @Test
-    void replaceSelectField() {
+    void testReplaceSelectField() {
 
         String sql = "SELECT 维度1,sum(播放量) FROM 数据库 "
                 + "WHERE (歌手名 = '张三') AND 数据日期 = '2023-11-17' GROUP BY 维度1";
         Map<String, String> fieldMap = new HashMap<>();
         fieldMap.put("播放量", "播放量1");
-        sql = SqlParserReplaceHelper.replaceSelectFields(sql, fieldMap);
+        sql = SqlReplaceHelper.replaceSelectFields(sql, fieldMap);
         System.out.println(sql);
         Assert.assertEquals("SELECT 维度1, sum(播放量1) FROM 数据库 "
                 + "WHERE (歌手名 = '张三') AND 数据日期 = '2023-11-17' GROUP BY 维度1", sql);
@@ -32,25 +32,25 @@ class SqlParserReplaceHelperTest {
                 + "WHERE (歌手名 = '张三') AND 数据日期 = '2023-11-17' GROUP BY 维度1";
         fieldMap = new HashMap<>();
         fieldMap.put("播放量", "播放量1");
-        sql = SqlParserReplaceHelper.replaceSelectFields(sql, fieldMap);
+        sql = SqlReplaceHelper.replaceSelectFields(sql, fieldMap);
         System.out.println(sql);
         Assert.assertEquals("SELECT 维度1, 播放量1 FROM 数据库 WHERE (歌手名 = '张三') AND 数据日期 = '2023-11-17' GROUP BY 维度1", sql);
     }
 
     @Test
-    void replaceAggField() {
+    void testReplaceAggField() {
         String sql = "SELECT 维度1,sum(播放量) FROM 数据库 "
                 + "WHERE (歌手名 = '张三') AND 数据日期 = '2023-11-17' GROUP BY 维度1";
         Map<String, Pair<String, String>> fieldMap = new HashMap<>();
         fieldMap.put("播放量", Pair.of("收听用户数", AggOperatorEnum.COUNT_DISTINCT.name()));
-        sql = SqlParserReplaceHelper.replaceAggFields(sql, fieldMap);
+        sql = SqlReplaceHelper.replaceAggFields(sql, fieldMap);
         System.out.println(sql);
         Assert.assertEquals("SELECT 维度1, count(DISTINCT 收听用户数) FROM 数据库 "
                 + "WHERE (歌手名 = '张三') AND 数据日期 = '2023-11-17' GROUP BY 维度1", sql);
     }
 
     @Test
-    void replaceValue() {
+    void testReplaceValue() {
 
         String replaceSql = "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
                 + "and 歌手名 = '杰伦' and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
@@ -62,7 +62,7 @@ class SqlParserReplaceHelperTest {
         valueMap.put("杰伦", "周杰伦");
         filedNameToValueMap.put("歌手名", valueMap);
 
-        replaceSql = SqlParserReplaceHelper.replaceValue(replaceSql, filedNameToValueMap);
+        replaceSql = SqlReplaceHelper.replaceValue(replaceSql, filedNameToValueMap);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE datediff('day', 发布日期, '2023-08-09') <= 1 AND "
@@ -81,7 +81,7 @@ class SqlParserReplaceHelperTest {
         valueMap2.put("陈奕迅", "陈奕迅");
         filedNameToValueMap2.put("歌手名", valueMap2);
 
-        replaceSql = SqlParserReplaceHelper.replaceValue(replaceSql, filedNameToValueMap2, false);
+        replaceSql = SqlReplaceHelper.replaceValue(replaceSql, filedNameToValueMap2, false);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE datediff('day', 发布日期, '2023-08-09') <= 1 AND 歌手名 = '周杰伦' "
@@ -92,7 +92,7 @@ class SqlParserReplaceHelperTest {
                 + "and 歌手名 = '周杰' and 歌手名 = '林俊' and 歌手名 = '陈' and 歌曲发布时 = '2023-08-01') and 数据日期 = '2023-08-09' "
                 + " order by 播放量 desc limit 11";
 
-        replaceSql = SqlParserReplaceHelper.replaceValue(replaceSql, filedNameToValueMap2, false);
+        replaceSql = SqlReplaceHelper.replaceValue(replaceSql, filedNameToValueMap2, false);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE (datediff('day', 发布日期, '2023-08-09') <= 1 AND 歌手名 = '周杰伦' "
@@ -105,7 +105,7 @@ class SqlParserReplaceHelperTest {
                 + ") ) and 数据日期 = '2023-08-09' "
                 + " order by 播放量 desc limit 11";
 
-        replaceSql = SqlParserReplaceHelper.replaceValue(replaceSql, filedNameToValueMap2, false);
+        replaceSql = SqlReplaceHelper.replaceValue(replaceSql, filedNameToValueMap2, false);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE (datediff('day', 发布日期, '2023-08-09') <= 1 AND "
@@ -115,7 +115,7 @@ class SqlParserReplaceHelperTest {
     }
 
     @Test
-    void replaceFieldNameByValue() {
+    void testReplaceFieldNameByValue() {
 
         String replaceSql = "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
                 + "and 歌曲名 = '邓紫棋' and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
@@ -124,7 +124,7 @@ class SqlParserReplaceHelperTest {
         Map<String, Set<String>> fieldValueToFieldNames = new HashMap<>();
         fieldValueToFieldNames.put("邓紫棋", Collections.singleton("歌手名"));
 
-        replaceSql = SqlParserReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
+        replaceSql = SqlReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE datediff('day', 发布日期, '2023-08-09') <= 1 AND "
@@ -135,7 +135,7 @@ class SqlParserReplaceHelperTest {
                 + "and 歌曲名 like '%邓紫棋%' and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
                 + " order by 播放量 desc limit 11";
 
-        replaceSql = SqlParserReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
+        replaceSql = SqlReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE datediff('day', 发布日期, '2023-08-09') <= 1 "
@@ -152,7 +152,7 @@ class SqlParserReplaceHelperTest {
                 + "and 歌手名 = '林俊杰' and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
                 + " order by 播放量 desc limit 11";
 
-        replaceSql = SqlParserReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
+        replaceSql = SqlReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE datediff('day', 发布日期, '2023-08-09') <= 1 "
@@ -163,7 +163,7 @@ class SqlParserReplaceHelperTest {
                 + "and 歌手名 = '林俊杰' and 歌曲发布时 = '2023-08-01') and 数据日期 = '2023-08-09'"
                 + " order by 播放量 desc limit 11";
 
-        replaceSql = SqlParserReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
+        replaceSql = SqlReplaceHelper.replaceFieldNameByValue(replaceSql, fieldValueToFieldNames);
 
         Assert.assertEquals(
                 "SELECT 歌曲名 FROM 歌曲库 WHERE (datediff('day', 发布日期, '2023-08-09') <= 1 AND "
@@ -173,37 +173,37 @@ class SqlParserReplaceHelperTest {
     }
 
     @Test
-    void replaceUnionFields() {
+    void testReplaceUnionFields() {
         Map<String, String> fieldToBizName1 = new HashMap<>();
         fieldToBizName1.put("公司成立时间", "company_established_time");
         fieldToBizName1.put("年营业额", "annual_turnover");
         String replaceSql = "SELECT * FROM 互联网企业 ORDER BY 公司成立时间 DESC LIMIT 3 "
                 + "UNION SELECT * FROM 互联网企业 ORDER BY 年营业额 DESC LIMIT 5";
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName1);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName1);
-        replaceSql = SqlParserReplaceHelper.replaceTable(replaceSql, "internet");
+        replaceSql = SqlReplaceHelper.replaceTable(replaceSql, "internet");
         Assert.assertEquals(
                 "SELECT * FROM internet ORDER BY company_established_time DESC LIMIT 3 "
                         + "UNION SELECT * FROM internet ORDER BY annual_turnover DESC LIMIT 5", replaceSql);
     }
 
     @Test
-    void replaceFields() {
+    void testReplaceFields() {
 
         Map<String, String> fieldToBizName = initParams();
         String replaceSql = "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
                 + "and 歌手名 = '邓紫棋' and 数据日期 = '2023-08-09' and 歌曲发布时 = '2023-08-01'"
                 + " order by 播放量 desc limit 11";
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
         Assert.assertEquals(
                 "SELECT song_name FROM 歌曲库 WHERE (publish_date >= '2023-08-08' AND publish_date <= '2023-08-09')"
                         + " AND singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' AND song_publis_date = '2023-08-01'"
                         + " ORDER BY play_count DESC LIMIT 11", replaceSql);
 
         replaceSql = "select 品牌名称 from 互联网企业 where datediff('year', 品牌成立时间, '2023-11-04') > 17 and 注册资本 = 50000000";
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
-        replaceSql = SqlParserRemoveHelper.removeNumberFilter(replaceSql);
+        replaceSql = SqlRemoveHelper.removeNumberFilter(replaceSql);
         Assert.assertEquals(
                 "SELECT 品牌名称 FROM 互联网企业 WHERE 品牌成立时间 < '2006-11-04' AND 注册资本 = 50000000", replaceSql);
 
@@ -211,8 +211,8 @@ class SqlParserReplaceHelperTest {
                 + "where datediff('year', 数据日期, '2023-09-03') <= 0.5 "
                 + "group by MONTH(数据日期) order by sum(访问次数) desc limit 1";
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT MONTH(sys_imp_date), sum(pv) FROM 内容库产品 WHERE (sys_imp_date >= '2023-03-03' "
@@ -223,8 +223,8 @@ class SqlParserReplaceHelperTest {
                 + "where datediff('year', 数据日期, '2023-09-03') <= 0.5 "
                 + "group by MONTH(数据日期) HAVING sum(访问次数) > 1000";
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT MONTH(sys_imp_date), sum(pv) FROM 内容库产品 WHERE (sys_imp_date >= '2023-03-03' AND"
@@ -234,8 +234,8 @@ class SqlParserReplaceHelperTest {
         replaceSql = "select YEAR(发行日期), count(歌曲名) from 歌曲库 where YEAR(发行日期) "
                 + "in (2022, 2023) and 数据日期 = '2023-08-14' group by YEAR(发行日期)";
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT YEAR(publish_date), count(song_name) FROM 歌曲库 "
@@ -247,8 +247,8 @@ class SqlParserReplaceHelperTest {
                 + "where YEAR(发行日期) in (2022, 2023) and 数据日期 = '2023-08-14' "
                 + "group by 发行日期";
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT YEAR(publish_date), count(song_name) FROM 歌曲库 "
@@ -256,11 +256,11 @@ class SqlParserReplaceHelperTest {
                         + " GROUP BY publish_date",
                 replaceSql);
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(
+        replaceSql = SqlReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('year', 发布日期, '2023-08-11') <= 1 "
                         + "and 结算播放量 > 1000000 and datediff('day', 数据日期, '2023-08-11') <= 30",
                 fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT song_name FROM 歌曲库 WHERE (publish_date >= '2022-08-11' "
@@ -268,64 +268,64 @@ class SqlParserReplaceHelperTest {
                         + "(sys_imp_date >= '2023-07-12' AND sys_imp_date <= '2023-08-11')",
                 replaceSql);
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(
+        replaceSql = SqlReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
                         + "and 歌手名 = '邓紫棋' and 数据日期 = '2023-08-09' order by 播放量 desc limit 11",
                 fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT song_name FROM 歌曲库 WHERE (publish_date >= '2023-08-08' AND publish_date <= '2023-08-09')"
                         + " AND singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' ORDER BY play_count DESC LIMIT 11",
                 replaceSql);
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(
+        replaceSql = SqlReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('year', 发布日期, '2023-08-09') = 0 "
                         + "and 歌手名 = '邓紫棋' and 数据日期 = '2023-08-09' order by 播放量 desc limit 11", fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT song_name FROM 歌曲库 WHERE (publish_date >= '2023-01-01' AND publish_date <= '2023-08-09')"
                         + " AND singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' ORDER BY play_count DESC LIMIT 11",
                 replaceSql);
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(
+        replaceSql = SqlReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('year', 发布日期, '2023-08-09') <= 0.5 "
                         + "and 歌手名 = '邓紫棋' and 数据日期 = '2023-08-09' order by 播放量 desc limit 11", fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT song_name FROM 歌曲库 WHERE (publish_date >= '2023-02-09' AND publish_date <= '2023-08-09')"
                         + " AND singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' ORDER BY play_count DESC LIMIT 11",
                 replaceSql);
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(
+        replaceSql = SqlReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('year', 发布日期, '2023-08-09') >= 0.5 "
                         + "and 歌手名 = '邓紫棋' and 数据日期 = '2023-08-09' order by 播放量 desc limit 11", fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
-        replaceSql = SqlParserRemoveHelper.removeNumberFilter(replaceSql);
+        replaceSql = SqlRemoveHelper.removeNumberFilter(replaceSql);
         Assert.assertEquals(
                 "SELECT song_name FROM 歌曲库 WHERE publish_date <= '2023-02-09' AND"
                         + " singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09'"
                         + " ORDER BY play_count DESC LIMIT 11", replaceSql);
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(
+        replaceSql = SqlReplaceHelper.replaceFields(
                 "select 部门,用户 from 超音数 where 数据日期 = '2023-08-08' and 用户 ='alice'"
                         + " and 发布日期 ='11' order by 访问次数 desc limit 1", fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT department, user_id FROM 超音数 WHERE sys_imp_date = '2023-08-08'"
                         + " AND user_id = 'alice' AND publish_date = '11' ORDER BY pv DESC LIMIT 1", replaceSql);
 
-        replaceSql = SqlParserReplaceHelper.replaceTable(replaceSql, "s2");
+        replaceSql = SqlReplaceHelper.replaceTable(replaceSql, "s2");
 
-        replaceSql = SqlParserAddHelper.addFieldsToSelect(replaceSql, Collections.singletonList("field_a"));
+        replaceSql = SqlAddHelper.addFieldsToSelect(replaceSql, Collections.singletonList("field_a"));
 
-        replaceSql = SqlParserReplaceHelper.replaceFields(
+        replaceSql = SqlReplaceHelper.replaceFields(
                 "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                         + "and 用户 ='alice' and 发布日期 ='11' group by 部门 limit 1", fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT department, sum(pv) FROM 超音数 WHERE sys_imp_date = '2023-08-08'"
@@ -333,8 +333,8 @@ class SqlParserReplaceHelperTest {
 
         replaceSql = "select sum(访问次数) from 超音数 where 数据日期 >= '2023-08-06' "
                 + "and 数据日期 <= '2023-08-06' and 部门 = 'hr'";
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT sum(pv) FROM 超音数 WHERE sys_imp_date >= '2023-08-06' "
@@ -342,8 +342,8 @@ class SqlParserReplaceHelperTest {
 
         replaceSql = "SELECT 歌曲名称, sum(评分) FROM CSpider WHERE(1 < 2) AND 数据日期 = '2023-10-15' "
                 + "GROUP BY 歌曲名称 HAVING sum(评分) < ( SELECT min(评分) FROM CSpider WHERE 语种 = '英文')";
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT song_name, sum(user_id) FROM CSpider WHERE (1 < 2) AND "
@@ -353,8 +353,8 @@ class SqlParserReplaceHelperTest {
         replaceSql = "SELECT sum(评分)/ (SELECT sum(评分) FROM CSpider WHERE  数据日期 = '2023-10-15')"
                 + " FROM CSpider WHERE  数据日期 = '2023-10-15' "
                 + "GROUP BY 歌曲名称 HAVING sum(评分) < ( SELECT min(评分) FROM CSpider WHERE 语种 = '英文')";
-        replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
+        replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
-        replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
+        replaceSql = SqlReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
                 "SELECT sum(user_id) / (SELECT sum(user_id) FROM CSpider WHERE sys_imp_date = '2023-10-15') "
@@ -363,25 +363,25 @@ class SqlParserReplaceHelperTest {
     }
 
     @Test
-    void replaceTable() {
+    void testReplaceTable() {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        String replaceSql = SqlParserReplaceHelper.replaceTable(sql, "s2");
+        String replaceSql = SqlReplaceHelper.replaceTable(sql, "s2");
 
         Assert.assertEquals(
                 "SELECT 部门, sum(访问次数) FROM s2 WHERE 数据日期 = '2023-08-08' "
                         + "AND 用户 = alice AND 发布日期 = '11' GROUP BY 部门 LIMIT 1", replaceSql);
 
         sql = "select * from 互联网企业 order by 公司成立时间 desc limit 3 union select * from 互联网企业 order by 年营业额 desc limit 5";
-        replaceSql = SqlParserReplaceHelper.replaceTable(sql, "internet");
+        replaceSql = SqlReplaceHelper.replaceTable(sql, "internet");
         Assert.assertEquals(
                 "SELECT * FROM internet ORDER BY 公司成立时间 DESC LIMIT 3 "
                         + "UNION SELECT * FROM internet ORDER BY 年营业额 DESC LIMIT 5", replaceSql);
 
         sql = "SELECT * FROM CSpider音乐 WHERE (评分 < (SELECT min(评分) "
                 + "FROM CSpider音乐 WHERE 语种 = '英文')) AND 数据日期 = '2023-10-11'";
-        replaceSql = SqlParserReplaceHelper.replaceTable(sql, "cspider");
+        replaceSql = SqlReplaceHelper.replaceTable(sql, "cspider");
 
         Assert.assertEquals(
                 "SELECT * FROM cspider WHERE (评分 < (SELECT min(评分) FROM "
@@ -390,7 +390,7 @@ class SqlParserReplaceHelperTest {
         sql = "SELECT 歌曲名称, sum(评分) FROM CSpider音乐 WHERE(1 < 2) AND 数据日期 = '2023-10-15' "
                 + "GROUP BY 歌曲名称 HAVING sum(评分) < ( SELECT min(评分) FROM CSpider音乐 WHERE 语种 = '英文')";
 
-        replaceSql = SqlParserReplaceHelper.replaceTable(sql, "cspider");
+        replaceSql = SqlReplaceHelper.replaceTable(sql, "cspider");
 
         Assert.assertEquals(
                 "SELECT 歌曲名称, sum(评分) FROM cspider WHERE (1 < 2) AND 数据日期 = "
@@ -400,7 +400,7 @@ class SqlParserReplaceHelperTest {
     }
 
     @Test
-    void replaceFunctionName() {
+    void testReplaceFunctionName() {
 
         String sql = "select 公司名称,平均(注册资本),总部地点 from 互联网企业 where\n"
                 + "年营业额 >= 28800000000 and 最大(注册资本)>10000 \n"
@@ -409,7 +409,7 @@ class SqlParserReplaceHelperTest {
         Map<String, String> map = new HashMap<>();
         map.put("平均", "avg");
         map.put("最大", "max");
-        sql = SqlParserReplaceHelper.replaceFunction(sql, map);
+        sql = SqlReplaceHelper.replaceFunction(sql, map);
         System.out.println(sql);
         Assert.assertEquals("SELECT 公司名称, avg(注册资本), 总部地点 FROM 互联网企业 WHERE 年营业额 >= 28800000000 AND "
                 + "max(注册资本) > 10000 GROUP BY 公司名称 HAVING avg(注册资本) > 10000 ORDER BY avg(注册资本) DESC LIMIT 5", sql);
@@ -418,7 +418,7 @@ class SqlParserReplaceHelperTest {
                 + " datediff('month', 数据日期, '2023-09-02') <= 6 group by MONTH(数据日期)";
         Map<String, String> functionMap = new HashMap<>();
         functionMap.put("MONTH".toLowerCase(), "toMonth");
-        String replaceSql = SqlParserReplaceHelper.replaceFunction(sql, functionMap);
+        String replaceSql = SqlReplaceHelper.replaceFunction(sql, functionMap);
 
         Assert.assertEquals(
                 "SELECT toMonth(数据日期) AS 月份, avg(访问次数) AS 平均访问次数 FROM 内容库产品 WHERE"
@@ -427,7 +427,7 @@ class SqlParserReplaceHelperTest {
 
         sql = "select month(数据日期) as 月份, avg(访问次数) as 平均访问次数 from 内容库产品 where"
                 + " datediff('month', 数据日期, '2023-09-02') <= 6 group by MONTH(数据日期)";
-        replaceSql = SqlParserReplaceHelper.replaceFunction(sql, functionMap);
+        replaceSql = SqlReplaceHelper.replaceFunction(sql, functionMap);
 
         Assert.assertEquals(
                 "SELECT toMonth(数据日期) AS 月份, avg(访问次数) AS 平均访问次数 FROM 内容库产品 WHERE"
@@ -436,7 +436,7 @@ class SqlParserReplaceHelperTest {
 
         sql = "select month(数据日期) as 月份, avg(访问次数) as 平均访问次数 from 内容库产品 where"
                 + " (datediff('month', 数据日期, '2023-09-02') <= 6) and 数据日期 = '2023-10-10' group by MONTH(数据日期)";
-        replaceSql = SqlParserReplaceHelper.replaceFunction(sql, functionMap);
+        replaceSql = SqlReplaceHelper.replaceFunction(sql, functionMap);
 
         Assert.assertEquals(
                 "SELECT toMonth(数据日期) AS 月份, avg(访问次数) AS 平均访问次数 FROM 内容库产品 WHERE"
@@ -446,10 +446,10 @@ class SqlParserReplaceHelperTest {
     }
 
     @Test
-    void replaceAlias() {
+    void testReplaceAlias() {
         String sql = "select 部门, sum(访问次数) as 总访问次数 from 超音数 where "
                 + "datediff('day', 数据日期, '2023-09-05') <= 3 group by 部门 order by 总访问次数 desc limit 10";
-        String replaceSql = SqlParserReplaceHelper.replaceAlias(sql);
+        String replaceSql = SqlReplaceHelper.replaceAlias(sql);
         System.out.println(replaceSql);
         Assert.assertEquals(
                 "SELECT 部门, sum(访问次数) FROM 超音数 WHERE "
@@ -459,7 +459,7 @@ class SqlParserReplaceHelperTest {
         sql = "select 部门, sum(访问次数) as 总访问次数 from 超音数 where "
                 + "(datediff('day', 数据日期, '2023-09-05') <= 3) and 数据日期 = '2023-10-10' "
                 + "group by 部门 order by 总访问次数 desc limit 10";
-        replaceSql = SqlParserReplaceHelper.replaceAlias(sql);
+        replaceSql = SqlReplaceHelper.replaceAlias(sql);
         System.out.println(replaceSql);
         Assert.assertEquals(
                 "SELECT 部门, sum(访问次数) FROM 超音数 WHERE "
@@ -470,7 +470,7 @@ class SqlParserReplaceHelperTest {
         sql = "select 部门, sum(访问次数) as 访问次数 from 超音数 where "
                 + "(datediff('day', 数据日期, '2023-09-05') <= 3) and 数据日期 = '2023-10-10' "
                 + "group by 部门 order by 访问次数 desc limit 10";
-        replaceSql = SqlParserReplaceHelper.replaceAlias(sql);
+        replaceSql = SqlReplaceHelper.replaceAlias(sql);
         System.out.println(replaceSql);
         Assert.assertEquals(
                 "SELECT 部门, sum(访问次数) AS 访问次数 FROM 超音数 WHERE (datediff('day', 数据日期, "

common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectFunctionHelperTest.java

@@ -7,68 +7,68 @@ import org.junit.jupiter.api.Test;
 /**
  * SqlParserSelectHelper Test
  */
-class SqlParserSelectFunctionHelperTest {
+class SqlSelectFunctionHelperTest {
 
     @Test
-    void hasAggregateFunction() throws JSQLParserException {
+    void testHasAggregateFunction() throws JSQLParserException {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        boolean hasAggregateFunction = SqlParserSelectFunctionHelper.hasAggregateFunction(sql);
+        boolean hasAggregateFunction = SqlSelectFunctionHelper.hasAggregateFunction(sql);
 
         Assert.assertEquals(hasAggregateFunction, true);
         sql = "select 部门,count (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        hasAggregateFunction = SqlParserSelectFunctionHelper.hasAggregateFunction(sql);
+        hasAggregateFunction = SqlSelectFunctionHelper.hasAggregateFunction(sql);
         Assert.assertEquals(hasAggregateFunction, true);
 
         sql = "SELECT count(1) FROM s2 WHERE sys_imp_date = '2023-08-08' AND user_id = 'alice'"
                 + " AND publish_date = '11' ORDER BY pv DESC LIMIT 1";
-        hasAggregateFunction = SqlParserSelectFunctionHelper.hasAggregateFunction(sql);
+        hasAggregateFunction = SqlSelectFunctionHelper.hasAggregateFunction(sql);
         Assert.assertEquals(hasAggregateFunction, true);
 
         sql = "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08' "
                 + "AND user_id = 'alice' AND publish_date = '11' ORDER BY pv DESC LIMIT 1";
-        hasAggregateFunction = SqlParserSelectFunctionHelper.hasAggregateFunction(sql);
+        hasAggregateFunction = SqlSelectFunctionHelper.hasAggregateFunction(sql);
         Assert.assertEquals(hasAggregateFunction, false);
 
         sql = "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08'"
                 + " AND user_id = 'alice' AND publish_date = '11'";
-        hasAggregateFunction = SqlParserSelectFunctionHelper.hasAggregateFunction(sql);
+        hasAggregateFunction = SqlSelectFunctionHelper.hasAggregateFunction(sql);
         Assert.assertEquals(hasAggregateFunction, false);
 
         sql = "SELECT user_name, pv FROM t_34 WHERE sys_imp_date <= '2023-09-03' "
                 + "AND sys_imp_date >= '2023-08-04' GROUP BY user_name ORDER BY sum(pv) DESC LIMIT 10";
-        hasAggregateFunction = SqlParserSelectFunctionHelper.hasAggregateFunction(sql);
+        hasAggregateFunction = SqlSelectFunctionHelper.hasAggregateFunction(sql);
         Assert.assertEquals(hasAggregateFunction, true);
     }
 
     @Test
-    void hasFunction() throws JSQLParserException {
+    void testHasFunction() throws JSQLParserException {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        boolean hasFunction = SqlParserSelectFunctionHelper.hasFunction(sql, "sum");
+        boolean hasFunction = SqlSelectFunctionHelper.hasFunction(sql, "sum");
 
         Assert.assertEquals(hasFunction, true);
         sql = "select 部门,count (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        hasFunction = SqlParserSelectFunctionHelper.hasFunction(sql, "count");
+        hasFunction = SqlSelectFunctionHelper.hasFunction(sql, "count");
         Assert.assertEquals(hasFunction, true);
 
         sql = "select 部门,count (*) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        hasFunction = SqlParserSelectFunctionHelper.hasFunction(sql, "count");
+        hasFunction = SqlSelectFunctionHelper.hasFunction(sql, "count");
         Assert.assertEquals(hasFunction, true);
 
         sql = "SELECT user_name, pv FROM t_34 WHERE sys_imp_date <= '2023-09-03' "
                 + "AND sys_imp_date >= '2023-08-04' GROUP BY user_name ORDER BY sum(pv) DESC LIMIT 10";
-        hasFunction = SqlParserSelectFunctionHelper.hasFunction(sql, "sum");
+        hasFunction = SqlSelectFunctionHelper.hasFunction(sql, "sum");
         Assert.assertEquals(hasFunction, false);
 
         sql = "select 部门,min (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        hasFunction = SqlParserSelectFunctionHelper.hasFunction(sql, "min");
+        hasFunction = SqlSelectFunctionHelper.hasFunction(sql, "min");
 
         Assert.assertEquals(hasFunction, true);
     }

common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectHelperTest.java

@@ -9,23 +9,23 @@ import org.junit.jupiter.api.Test;
 /**
  * SqlParserSelectHelper Test
  */
-class SqlParserSelectHelperTest {
+class SqlSelectHelperTest {
 
     @Test
-    void getWhereFilterExpression() {
+    void testGetWhereFilterExpression() {
 
-        Select selectStatement = SqlParserSelectHelper.getSelect(
+        Select selectStatement = SqlSelectHelper.getSelect(
                 "select 用户名, 访问次数 from 超音数 where 用户名 in ('alice', 'lucy')");
         System.out.println(selectStatement);
 
-        List<FieldExpression> fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        List<FieldExpression> fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE "
                         + "sys_imp_date = '2023-08-08' AND YEAR(publish_date) = 2023 "
                         + " AND user_id = 'alice'  ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08' "
                         + " AND YEAR(publish_date) = 2023 "
                         + " AND MONTH(publish_date) = 8"
@@ -33,64 +33,64 @@ class SqlParserSelectHelperTest {
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08'"
                         + " AND YEAR(publish_date) = 2023 "
                         + " AND MONTH(publish_date) = 8 AND DAY(publish_date) =20 "
                         + " AND user_id = 'alice'  ORDER BY pv DESC LIMIT 1");
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08' "
                         + " AND user_id = 'alice' AND publish_date = '11' ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08' "
                         + "AND user_id = 'alice' AND publish_date = '11' ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08' "
                         + "AND user_id = 'alice' AND publish_date = '11' ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE "
                         + "user_id = 'alice' AND publish_date = '11'   ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE "
                         + "user_id = 'alice' AND  publish_date > 10000   ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, user_id, field_a FROM s2 WHERE "
                         + "user_id like '%alice%' AND  publish_date > 10000   ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, pv FROM s2 WHERE "
                         + "user_id like '%alice%' AND  publish_date > 10000  "
                         + "group by department having sum(pv) > 2000 ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, pv FROM s2 WHERE "
                         + "(user_id like '%alice%' AND  publish_date > 10000)  and sys_imp_date = '2023-08-08' "
                         + "group by department having sum(pv) > 2000 ORDER BY pv DESC LIMIT 1");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, pv FROM s2 WHERE "
                         + "(user_id like '%alice%' AND  publish_date > 10000) and song_name in "
                         + "('七里香','晴天') and sys_imp_date = '2023-08-08' "
@@ -98,7 +98,7 @@ class SqlParserSelectHelperTest {
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, pv FROM s2 WHERE "
                         + "(user_id like '%alice%' AND  publish_date > 10000) and song_name in (1,2) "
                         + "and sys_imp_date = '2023-08-08' "
@@ -106,7 +106,7 @@ class SqlParserSelectHelperTest {
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "SELECT department, pv FROM s2 WHERE "
                         + "(user_id like '%alice%' AND  publish_date > 10000) and 1 in (1) "
                         + "and sys_imp_date = '2023-08-08' "
@@ -114,12 +114,12 @@ class SqlParserSelectHelperTest {
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression("SELECT sum(销量) / (SELECT sum(销量) FROM 营销月模型 "
+        fieldExpression = SqlSelectHelper.getFilterExpression("SELECT sum(销量) / (SELECT sum(销量) FROM 营销月模型 "
                 + "WHERE MONTH(数据日期) = 9) FROM 营销月模型 WHERE 国家中文名 = '肯尼亚' AND MONTH(数据日期) = 9");
 
         System.out.println(fieldExpression);
 
-        fieldExpression = SqlParserSelectHelper.getFilterExpression(
+        fieldExpression = SqlSelectHelper.getFilterExpression(
                 "select 等级, count(*) from 歌手 where 别名 = '港台' or 活跃区域 = '港台' and"
                         + " datediff('day', 数据日期, '2023-12-24') <= 0 group by 等级");
 
@@ -128,79 +128,79 @@ class SqlParserSelectHelperTest {
     }
 
     @Test
-    void getAllFields() {
+    void testGetAllFields() {
 
-        List<String> allFields = SqlParserSelectHelper.getAllFields(
+        List<String> allFields = SqlSelectHelper.getAllFields(
                 "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date = '2023-08-08'"
                         + " AND user_id = 'alice' AND publish_date = '11' ORDER BY pv DESC LIMIT 1");
 
         Assert.assertEquals(allFields.size(), 6);
 
-        allFields = SqlParserSelectHelper.getAllFields(
+        allFields = SqlSelectHelper.getAllFields(
                 "SELECT department, user_id, field_a FROM s2 WHERE sys_imp_date >= '2023-08-08'"
                         + " AND user_id = 'alice' AND publish_date = '11' ORDER BY pv DESC LIMIT 1");
 
         Assert.assertEquals(allFields.size(), 6);
 
-        allFields = SqlParserSelectHelper.getAllFields(
+        allFields = SqlSelectHelper.getAllFields(
                 "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' and 用户 = 'alice'"
                         + " and 发布日期 ='11' group by 部门 limit 1");
 
         Assert.assertEquals(allFields.size(), 5);
 
-        allFields = SqlParserSelectHelper.getAllFields(
+        allFields = SqlSelectHelper.getAllFields(
                 "SELECT user_name FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                         + "sys_imp_date >= '2023-08-04' GROUP BY user_name ORDER BY sum(pv) DESC LIMIT 10 ");
 
         Assert.assertEquals(allFields.size(), 3);
 
-        allFields = SqlParserSelectHelper.getAllFields(
+        allFields = SqlSelectHelper.getAllFields(
                 "SELECT user_name FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                         + "sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000");
 
         Assert.assertEquals(allFields.size(), 3);
 
-        allFields = SqlParserSelectHelper.getAllFields(
+        allFields = SqlSelectHelper.getAllFields(
                 "SELECT department, user_id, field_a FROM s2 WHERE "
                         + "(user_id = 'alice' AND publish_date = '11') and sys_imp_date "
                         + "= '2023-08-08' ORDER BY pv DESC LIMIT 1");
 
         Assert.assertEquals(allFields.size(), 6);
 
-        allFields = SqlParserSelectHelper.getAllFields(
+        allFields = SqlSelectHelper.getAllFields(
                 "SELECT * FROM CSpider  WHERE (评分 < (SELECT min(评分) FROM CSpider WHERE 语种 = '英文' ))"
                         + " AND 数据日期 = '2023-10-12'");
 
         Assert.assertEquals(allFields.size(), 3);
 
-        allFields = SqlParserSelectHelper.getAllFields("SELECT sum(销量) / (SELECT sum(销量) FROM 营销 "
+        allFields = SqlSelectHelper.getAllFields("SELECT sum(销量) / (SELECT sum(销量) FROM 营销 "
                 + "WHERE MONTH(数据日期) = 9) FROM 营销 WHERE 国家中文名 = '中国' AND MONTH(数据日期) = 9");
 
         Assert.assertEquals(allFields.size(), 3);
 
-        allFields = SqlParserSelectHelper.getAllFields(
+        allFields = SqlSelectHelper.getAllFields(
                 "SELECT 用户, 页面  FROM 超音数用户部门 GROUP BY 用户, 页面 ORDER BY count(*) DESC");
 
         Assert.assertEquals(allFields.size(), 2);
     }
 
     @Test
-    void getSelectFields() {
+    void testGetSelectFields() {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08' "
                 + "and 用户 =alice and 发布日期 ='11' group by 部门 limit 1";
-        List<String> selectFields = SqlParserSelectHelper.getSelectFields(sql);
+        List<String> selectFields = SqlSelectHelper.getSelectFields(sql);
 
         Assert.assertEquals(selectFields.contains("访问次数"), true);
         Assert.assertEquals(selectFields.contains("部门"), true);
     }
 
     @Test
-    void getWhereFields() {
+    void testGetWhereFields() {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08'"
                 + " and 用户 = 'alice' and 发布日期 ='11' group by 部门 limit 1";
-        List<String> selectFields = SqlParserSelectHelper.getWhereFields(sql);
+        List<String> selectFields = SqlSelectHelper.getWhereFields(sql);
 
         Assert.assertEquals(selectFields.contains("发布日期"), true);
         Assert.assertEquals(selectFields.contains("数据日期"), true);
@@ -208,7 +208,7 @@ class SqlParserSelectHelperTest {
 
         sql = "select 部门,用户 from 超音数 where 数据日期 = '2023-08-08'"
                 + " and 用户 = 'alice' and 发布日期 ='11' order by 访问次数 limit 1";
-        selectFields = SqlParserSelectHelper.getWhereFields(sql);
+        selectFields = SqlSelectHelper.getWhereFields(sql);
 
         Assert.assertEquals(selectFields.contains("发布日期"), true);
         Assert.assertEquals(selectFields.contains("数据日期"), true);
@@ -217,7 +217,7 @@ class SqlParserSelectHelperTest {
         sql = "select 部门,用户 from 超音数 where"
                 + " (用户 = 'alice' and 发布日期 ='11') and 数据日期 = '2023-08-08' "
                 + "order by 访问次数 limit 1";
-        selectFields = SqlParserSelectHelper.getWhereFields(sql);
+        selectFields = SqlSelectHelper.getWhereFields(sql);
 
         Assert.assertEquals(selectFields.contains("发布日期"), true);
         Assert.assertEquals(selectFields.contains("数据日期"), true);
@@ -225,49 +225,49 @@ class SqlParserSelectHelperTest {
     }
 
     @Test
-    void getOrderByFields() {
+    void testGetOrderByFields() {
 
         String sql = "select 部门,用户 from 超音数 where 数据日期 = '2023-08-08'"
                 + " and 用户 = 'alice' and 发布日期 ='11' order by 访问次数 limit 1";
-        List<String> selectFields = SqlParserSelectHelper.getOrderByFields(sql);
+        List<String> selectFields = SqlSelectHelper.getOrderByFields(sql);
 
         Assert.assertEquals(selectFields.contains("访问次数"), true);
 
         sql = "SELECT user_name FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                 + "sys_imp_date >= '2023-08-04' GROUP BY user_name ORDER BY sum(pv) DESC LIMIT 10 ";
-        selectFields = SqlParserSelectHelper.getOrderByFields(sql);
+        selectFields = SqlSelectHelper.getOrderByFields(sql);
 
         Assert.assertEquals(selectFields.contains("pv"), true);
     }
 
     @Test
-    void getGroupByFields() {
+    void testGetGroupByFields() {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08'"
                 + " and 用户 = 'alice' and 发布日期 ='11' group by 部门 limit 1";
-        List<String> selectFields = SqlParserSelectHelper.getGroupByFields(sql);
+        List<String> selectFields = SqlSelectHelper.getGroupByFields(sql);
 
         Assert.assertEquals(selectFields.contains("部门"), true);
 
     }
 
     @Test
-    void getHavingExpression() {
+    void testGetHavingExpression() {
 
         String sql = "SELECT user_name FROM 超音数 WHERE sys_imp_date <= '2023-09-03' AND "
                 + "sys_imp_date >= '2023-08-04' GROUP BY user_name HAVING sum(pv) > 1000";
-        List<Expression> leftExpressionList = SqlParserSelectHelper.getHavingExpression(sql);
+        List<Expression> leftExpressionList = SqlSelectHelper.getHavingExpression(sql);
 
         Assert.assertEquals(leftExpressionList.get(0).toString(), "sum(pv)");
 
     }
 
     @Test
-    void getAggregateFields() {
+    void testGetAggregateFields() {
 
         String sql = "select 部门,sum (访问次数) from 超音数 where 数据日期 = '2023-08-08'"
                 + " and 用户 = 'alice' and 发布日期 ='11' group by 部门 limit 1";
-        List<String> selectFields = SqlParserSelectHelper.getAggregateFields(sql);
+        List<String> selectFields = SqlSelectHelper.getAggregateFields(sql);
         Assert.assertEquals(selectFields.contains("访问次数"), true);
 
     }

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

@@ -11,7 +11,7 @@ import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.util.ContextUtils;
 import com.tencent.supersonic.common.util.DateModeUtils;
 import com.tencent.supersonic.common.util.SqlFilterUtils;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
 import lombok.Data;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.JSQLParserException;
@@ -156,7 +156,7 @@ public class QueryStructReq extends SemanticQueryReq {
     }
 
     /**
-     * convert queryStructReq to QueryS2QLReq
+     * convert queryStructReq to QueryS2SQLReq
      *
      * @param queryStructReq
      * @return
@@ -261,7 +261,7 @@ public class QueryStructReq extends SemanticQueryReq {
         String sql = select.toString();
         if (StringUtils.isNotBlank(whereClause)) {
             Expression expression = CCJSqlParserUtil.parseCondExpression(whereClause);
-            sql = SqlParserAddHelper.addWhere(sql, expression);
+            sql = SqlAddHelper.addWhere(sql, expression);
         }
 
         //7.Set DateInfo
@@ -269,7 +269,7 @@ public class QueryStructReq extends SemanticQueryReq {
         String dateWhereStr = dateModeUtils.getDateWhereStr(queryStructReq.getDateInfo());
         if (StringUtils.isNotBlank(dateWhereStr)) {
             Expression expression = CCJSqlParserUtil.parseCondExpression(dateWhereStr);
-            sql = SqlParserAddHelper.addWhere(sql, expression);
+            sql = SqlAddHelper.addWhere(sql, expression);
         }
         return sql;
     }

headless/core/src/main/java/com/tencent/supersonic/headless/core/adaptor/db/ClickHouseAdaptor.java

@@ -1,6 +1,6 @@
 package com.tencent.supersonic.headless.core.adaptor.db;
 
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
 import com.tencent.supersonic.common.pojo.Constants;
 import java.util.HashMap;
@@ -49,7 +49,7 @@ public class ClickHouseAdaptor extends DbAdaptor {
         functionMap.put("MONTH".toLowerCase(), "toMonth");
         functionMap.put("DAY".toLowerCase(), "toDayOfMonth");
         functionMap.put("YEAR".toLowerCase(), "toYear");
-        return SqlParserReplaceHelper.replaceFunction(sql, functionMap);
+        return SqlReplaceHelper.replaceFunction(sql, functionMap);
     }
 
     @Override

headless/core/src/main/java/com/tencent/supersonic/headless/core/adaptor/db/PostgresqlAdaptor.java

@@ -2,7 +2,7 @@ package com.tencent.supersonic.headless.core.adaptor.db;
 
 import com.tencent.supersonic.common.pojo.Constants;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -47,7 +47,7 @@ public class PostgresqlAdaptor extends DbAdaptor {
         functionMap.put("MONTH".toLowerCase(), "toMonth");
         functionMap.put("DAY".toLowerCase(), "toDayOfMonth");
         functionMap.put("YEAR".toLowerCase(), "toYear");
-        return SqlParserReplaceHelper.replaceFunction(sql, functionMap);
+        return SqlReplaceHelper.replaceFunction(sql, functionMap);
     }
 
     @Override

headless/core/src/main/java/com/tencent/supersonic/headless/core/utils/SqlGenerateUtils.java

@@ -8,8 +8,8 @@ import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
 import com.tencent.supersonic.common.util.DateModeUtils;
 import com.tencent.supersonic.common.util.SqlFilterUtils;
 import com.tencent.supersonic.common.util.StringUtil;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import com.tencent.supersonic.headless.api.pojo.enums.AggOption;
 import com.tencent.supersonic.headless.api.pojo.enums.EngineType;
 import com.tencent.supersonic.headless.api.pojo.enums.MetricDefineType;
@@ -279,7 +279,7 @@ public class SqlGenerateUtils {
                                         Set<String> visitedMetric,
                                         Set<String> measures,
                                         Set<String> dimensions) {
-        Set<String> fields = SqlParserSelectHelper.getColumnFromExpr(expression);
+        Set<String> fields = SqlSelectHelper.getColumnFromExpr(expression);
         if (!CollectionUtils.isEmpty(fields)) {
             Map<String, String> replace = new HashMap<>();
             for (String field : fields) {
@@ -321,7 +321,7 @@ public class SqlGenerateUtils {
                 }
             }
             if (!CollectionUtils.isEmpty(replace)) {
-                String expr = SqlParserReplaceHelper.replaceExpression(expression, replace);
+                String expr = SqlReplaceHelper.replaceExpression(expression, replace);
                 log.info("derived measure {}->{}", expression, expr);
                 return expr;
             }

headless/server/src/main/java/com/tencent/supersonic/headless/server/aspect/DimValueAspect.java

@@ -7,8 +7,8 @@ import com.tencent.supersonic.common.pojo.enums.FilterOperatorEnum;
 import com.tencent.supersonic.common.pojo.exception.InvalidArgumentException;
 import com.tencent.supersonic.common.util.JsonUtil;
 import com.tencent.supersonic.common.util.jsqlparser.FieldExpression;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import com.tencent.supersonic.headless.api.pojo.DimValueMap;
 import com.tencent.supersonic.headless.api.pojo.SchemaItem;
 import com.tencent.supersonic.headless.api.pojo.request.QuerySqlReq;
@@ -90,7 +90,7 @@ public class DimValueAspect {
         MetaFilter metaFilter = new MetaFilter(Lists.newArrayList(querySqlReq.getModelIds()));
         String sql = querySqlReq.getSql();
         log.info("correctorSql before replacing:{}", sql);
-        List<FieldExpression> fieldExpressionList = SqlParserSelectHelper.getWhereExpressions(sql);
+        List<FieldExpression> fieldExpressionList = SqlSelectHelper.getWhereExpressions(sql);
         List<DimensionResp> dimensions = dimensionService.getDimensions(metaFilter);
         Set<String> fieldNames = dimensions.stream().map(SchemaItem::getName).collect(Collectors.toSet());
         Map<String, Map<String, String>> filedNameToValueMap = new HashMap<>();
@@ -117,7 +117,7 @@ public class DimValueAspect {
                 replaceInCondition(expression, dimension, filedNameToValueMap);
             }
         }
-        sql = SqlParserReplaceHelper.replaceValue(sql, filedNameToValueMap);
+        sql = SqlReplaceHelper.replaceValue(sql, filedNameToValueMap);
         log.info("correctorSql after replacing:{}", sql);
         querySqlReq.setSql(sql);
         Map<String, Map<String, String>> techNameToBizName = getTechNameToBizName(dimensions);

headless/server/src/main/java/com/tencent/supersonic/headless/server/aspect/S2DataPermissionAspect.java

@@ -9,7 +9,7 @@ import com.tencent.supersonic.common.pojo.Filter;
 import com.tencent.supersonic.common.pojo.enums.FilterOperatorEnum;
 import com.tencent.supersonic.common.pojo.exception.InvalidArgumentException;
 import com.tencent.supersonic.common.pojo.exception.InvalidPermissionException;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserAddHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlAddHelper;
 import com.tencent.supersonic.headless.api.pojo.request.QuerySqlReq;
 import com.tencent.supersonic.headless.api.pojo.request.QueryStructReq;
 import com.tencent.supersonic.headless.api.pojo.request.SchemaFilterReq;
@@ -283,7 +283,7 @@ public class S2DataPermissionAspect extends AuthCheckBaseAspect {
         try {
             Expression expression = CCJSqlParserUtil.parseCondExpression(" ( " + joiner + " ) ");
             if (StringUtils.isNotEmpty(joiner.toString())) {
-                String sql = SqlParserAddHelper.addWhere(querySqlReq.getSql(), expression);
+                String sql = SqlAddHelper.addWhere(querySqlReq.getSql(), expression);
                 log.info("before doRowPermission, queryS2SQLReq:{}", querySqlReq.getSql());
                 querySqlReq.setSql(sql);
                 log.info("after doRowPermission, queryS2SQLReq:{}", querySqlReq.getSql());

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

@@ -1,7 +1,7 @@
 package com.tencent.supersonic.headless.server.utils;
 
 import com.tencent.supersonic.common.pojo.exception.InvalidArgumentException;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectFunctionHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectFunctionHelper;
 import com.tencent.supersonic.headless.api.pojo.enums.MetricDefineType;
 import com.tencent.supersonic.headless.api.pojo.MetricDefineByFieldParams;
 import com.tencent.supersonic.headless.api.pojo.MetricDefineByMeasureParams;
@@ -63,7 +63,7 @@ public class MetricCheckUtils {
 
     private static boolean hasAggregateFunction(String expr) {
         String sql = String.format("select %s from table", expr);
-        return SqlParserSelectFunctionHelper.hasAggregateFunction(sql);
+        return SqlSelectFunctionHelper.hasAggregateFunction(sql);
     }
 
 }

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

@@ -6,9 +6,9 @@ import com.tencent.supersonic.common.pojo.Constants;
 import com.tencent.supersonic.common.pojo.enums.AggOperatorEnum;
 import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserReplaceHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlReplaceHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectFunctionHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectFunctionHelper;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import com.tencent.supersonic.headless.api.pojo.Measure;
 import com.tencent.supersonic.headless.api.pojo.MetricTable;
 import com.tencent.supersonic.headless.api.pojo.SchemaItem;
@@ -72,12 +72,12 @@ public class QueryReqConverter {
         //3.correct tableName
         correctTableName(querySQLReq);
 
-        String tableName = SqlParserSelectHelper.getTableName(querySQLReq.getSql());
+        String tableName = SqlSelectHelper.getTableName(querySQLReq.getSql());
         if (StringUtils.isEmpty(tableName)) {
             return new QueryStatement();
         }
         //4.build MetricTables
-        List<String> allFields = SqlParserSelectHelper.getAllFields(querySQLReq.getSql());
+        List<String> allFields = SqlSelectHelper.getAllFields(querySQLReq.getSql());
         List<String> metrics = getMetrics(semanticSchemaResp, allFields);
         QueryStructReq queryStructReq = new QueryStructReq();
         MetricTable metricTable = new MetricTable();
@@ -135,9 +135,9 @@ public class QueryReqConverter {
         // if there is no group by in S2SQL,set MetricTable's aggOption to "NATIVE"
         // if there is count() in S2SQL,set MetricTable's aggOption to "NATIVE"
         String sql = databaseReq.getSql();
-        if (!SqlParserSelectHelper.hasGroupBy(sql)
+        if (!SqlSelectHelper.hasGroupBy(sql)
-                || SqlParserSelectFunctionHelper.hasFunction(sql, "count")
+                || SqlSelectFunctionHelper.hasFunction(sql, "count")
-                || SqlParserSelectFunctionHelper.hasFunction(sql, "count_distinct")) {
+                || SqlSelectFunctionHelper.hasFunction(sql, "count_distinct")) {
             return AggOption.NATIVE;
         }
         return AggOption.DEFAULT;
@@ -147,7 +147,7 @@ public class QueryReqConverter {
         Map<String, String> fieldNameToBizNameMap = getFieldNameToBizNameMap(semanticSchemaResp);
         String sql = databaseReq.getSql();
         log.info("convert name to bizName before:{}", sql);
-        String replaceFields = SqlParserReplaceHelper.replaceFields(sql, fieldNameToBizNameMap, true);
+        String replaceFields = SqlReplaceHelper.replaceFields(sql, fieldNameToBizNameMap, true);
         log.info("convert name to bizName after:{}", replaceFields);
         databaseReq.setSql(replaceFields);
     }
@@ -214,7 +214,7 @@ public class QueryReqConverter {
 
     public void correctTableName(QuerySqlReq querySqlReq) {
         String sql = querySqlReq.getSql();
-        sql = SqlParserReplaceHelper.replaceTable(sql,
+        sql = SqlReplaceHelper.replaceTable(sql,
                 Constants.TABLE_PREFIX + querySqlReq.getViewId());
         querySqlReq.setSql(sql);
     }
@@ -239,7 +239,7 @@ public class QueryReqConverter {
                     measures, replaces);
             if (!CollectionUtils.isEmpty(replaces)) {
                 // metricTable sql use measures replace metric
-                sql = SqlParserReplaceHelper.replaceSqlByExpression(sql, replaces);
+                sql = SqlReplaceHelper.replaceSqlByExpression(sql, replaces);
                 metricTable.setAggOption(AggOption.NATIVE);
                 // metricTable use measures replace metric
                 if (!CollectionUtils.isEmpty(measures)) {

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

@@ -8,7 +8,7 @@ import com.tencent.supersonic.common.pojo.enums.TypeEnums;
 import com.tencent.supersonic.common.util.DateModeUtils;
 import com.tencent.supersonic.common.util.SqlFilterUtils;
 import com.tencent.supersonic.common.util.jsqlparser.FieldExpression;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import com.tencent.supersonic.headless.api.pojo.ItemDateFilter;
 import com.tencent.supersonic.headless.api.pojo.SchemaItem;
 import com.tencent.supersonic.headless.api.pojo.request.QuerySqlReq;
@@ -126,7 +126,7 @@ public class QueryStructUtils {
     }
 
     public Set<String> getResName(QuerySqlReq querySqlReq) {
-        Set<String> resNameSet = SqlParserSelectHelper.getAllFields(querySqlReq.getSql())
+        Set<String> resNameSet = SqlSelectHelper.getAllFields(querySqlReq.getSql())
                 .stream().collect(Collectors.toSet());
         return resNameSet;
     }
@@ -170,7 +170,7 @@ public class QueryStructUtils {
 
     public Set<String> getFilterResNameEnExceptInternalCol(QuerySqlReq querySqlReq) {
         String sql = querySqlReq.getSql();
-        Set<String> resNameEnSet = SqlParserSelectHelper.getWhereFields(sql).stream().collect(Collectors.toSet());
+        Set<String> resNameEnSet = SqlSelectHelper.getWhereFields(sql).stream().collect(Collectors.toSet());
         return resNameEnSet.stream().filter(res -> !internalCols.contains(res)).collect(Collectors.toSet());
     }
 
@@ -235,7 +235,7 @@ public class QueryStructUtils {
     }
 
     public DateConf getDateConfBySql(String sql) {
-        List<FieldExpression> fieldExpressions = SqlParserSelectHelper.getFilterExpression(sql);
+        List<FieldExpression> fieldExpressions = SqlSelectHelper.getFilterExpression(sql);
         if (!CollectionUtils.isEmpty(fieldExpressions)) {
             Set<String> dateList = new HashSet<>();
             String startDate = "";

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

@@ -6,7 +6,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.common.pojo.enums.TaskStatusEnum;
 import com.tencent.supersonic.common.util.SqlFilterUtils;
-import com.tencent.supersonic.common.util.jsqlparser.SqlParserSelectHelper;
+import com.tencent.supersonic.common.util.jsqlparser.SqlSelectHelper;
 import com.tencent.supersonic.headless.api.pojo.QueryStat;
 import com.tencent.supersonic.headless.api.pojo.SchemaItem;
 import com.tencent.supersonic.headless.api.pojo.enums.QueryOptMode;
@@ -100,8 +100,8 @@ public class StatUtils {
 
     public void initSqlStatInfo(QuerySqlReq querySqlReq, User facadeUser) {
         QueryStat queryStatInfo = new QueryStat();
-        List<String> aggFields = SqlParserSelectHelper.getAggregateFields(querySqlReq.getSql());
+        List<String> aggFields = SqlSelectHelper.getAggregateFields(querySqlReq.getSql());
-        List<String> allFields = SqlParserSelectHelper.getAllFields(querySqlReq.getSql());
+        List<String> allFields = SqlSelectHelper.getAllFields(querySqlReq.getSql());
         List<String> dimensions = allFields.stream().filter(aggFields::contains).collect(Collectors.toList());
 
         String userName = getUserName(facadeUser);

launchers/chat/src/main/resources/META-INF/spring.factories

@@ -13,6 +13,7 @@ com.tencent.supersonic.chat.core.parser.SemanticParser=\
 
 com.tencent.supersonic.chat.core.corrector.SemanticCorrector=\
     com.tencent.supersonic.chat.core.corrector.SchemaCorrector, \
+    com.tencent.supersonic.chat.core.corrector.TimeCorrector, \
     com.tencent.supersonic.chat.core.corrector.SelectCorrector, \
     com.tencent.supersonic.chat.core.corrector.WhereCorrector, \
     com.tencent.supersonic.chat.core.corrector.GroupByCorrector, \

launchers/standalone/src/main/resources/META-INF/spring.factories

@@ -13,6 +13,7 @@ com.tencent.supersonic.chat.core.parser.SemanticParser=\
 
 com.tencent.supersonic.chat.core.corrector.SemanticCorrector=\
     com.tencent.supersonic.chat.core.corrector.SchemaCorrector, \
+    com.tencent.supersonic.chat.core.corrector.TimeCorrector, \
     com.tencent.supersonic.chat.core.corrector.SelectCorrector, \
     com.tencent.supersonic.chat.core.corrector.WhereCorrector, \
     com.tencent.supersonic.chat.core.corrector.GroupByCorrector, \