[improvement][headless]Introduce new time mode CURRENT. #1692

2025-12-10 19:51:00 +00:00 · 2024-09-21 13:14:47 +08:00
parent 26ca5300f4
commit b6765387f5
7 changed files with 138 additions and 224 deletions
--- a/common/src/main/java/com/tencent/supersonic/common/pojo/enums/TimeMode.java
+++ b/common/src/main/java/com/tencent/supersonic/common/pojo/enums/TimeMode.java
@@ -2,7 +2,10 @@ package com.tencent.supersonic.common.pojo.enums;

 public enum TimeMode {

-    /** date mode LAST - a certain time RECENT - a period time */
+    // a specific date at N days ago
    LAST,
-    RECENT
+    // a period of time from N days ago to today
+    RECENT,
+    // a period of time from the first day of current month/year to today
+    CURRENT
 }
--- a/common/src/main/java/com/tencent/supersonic/common/util/DateUtils.java
+++ b/common/src/main/java/com/tencent/supersonic/common/util/DateUtils.java
@@ -6,6 +6,7 @@ import com.tencent.supersonic.common.pojo.enums.DatePeriodEnum;
 import lombok.extern.slf4j.Slf4j;

 import java.text.DateFormat;
+import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -16,7 +17,6 @@ import java.time.temporal.TemporalAdjuster;
 import java.time.temporal.TemporalAdjusters;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
 import java.util.Objects;
@@ -27,14 +27,8 @@ public class DateUtils {
    public static final String DATE_FORMAT = "yyyy-MM-dd";
    public static final String TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String FORMAT = "yyyyMMddHHmmss";
-
-    public static Integer currentYear() {
-        Date date = new Date();
-        SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
-        String time = dateFormat.format(date).replaceAll("-", "");
-        int year = Integer.parseInt(time.substring(0, 4));
-        return year;
-    }
+    private static final DateTimeFormatter dateTimeFormatter =
+            DateTimeFormatter.ofPattern(DATE_FORMAT);

    public static DateTimeFormatter getDateFormatter(String date, String[] formats) {
        for (int i = 0; i < formats.length; i++) {
@@ -43,8 +37,8 @@ public class DateUtils {
            try {
                dateFormat.parse(date);
                return DateTimeFormatter.ofPattern(format);
-            } catch (Exception e) {
-                log.info("date parse has a exception:{}", e.toString());
+            } catch (ParseException e) {
+                log.warn("date parse has a exception:{}", e.toString());
            }
        }
        return DateTimeFormatter.ofPattern(formats[0]);
@@ -57,41 +51,53 @@ public class DateUtils {
                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
                LocalDateTime.parse(date, dateTimeFormatter);
                return dateTimeFormatter;
-            } catch (Exception e) {
-                log.info("date parse has a exception:{}", e.toString());
+            } catch (DateTimeParseException e) {
+                log.warn("date parse has a exception:{}", e.toString());
            }
        }
        return DateTimeFormatter.ofPattern(formats[0]);
    }

    public static String getBeforeDate(int intervalDay) {
-        Calendar calendar = Calendar.getInstance();
-        calendar.setTime(new Date());
-        calendar.add(Calendar.DAY_OF_MONTH, -intervalDay);
-        SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
-        return dateFormat.format(calendar.getTime());
+        return getBeforeDate(intervalDay, DatePeriodEnum.DAY);
    }

    public static String getBeforeDate(int intervalDay, DatePeriodEnum datePeriodEnum) {
        if (Objects.isNull(datePeriodEnum)) {
-            return getBeforeDate(intervalDay);
+            datePeriodEnum = DatePeriodEnum.DAY;
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
        String currentDate = dateFormat.format(new Date());
        return getBeforeDate(currentDate, intervalDay, datePeriodEnum);
    }

+    public static String getBeforeDate(String currentDate, DatePeriodEnum datePeriodEnum) {
+        LocalDate specifiedDate = LocalDate.parse(currentDate, dateTimeFormatter);
+        LocalDate startDate;
+        switch (datePeriodEnum) {
+            case MONTH:
+                startDate = specifiedDate.withDayOfMonth(1);
+                break;
+            case YEAR:
+                startDate = specifiedDate.withDayOfYear(1);
+                break;
+            default:
+                startDate = specifiedDate;
+        }
+
+        return startDate.format(dateTimeFormatter);
+    }
+
    public static String getBeforeDate(
-            String date, int intervalDay, DatePeriodEnum datePeriodEnum) {
-        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DATE_FORMAT);
-        LocalDate currentDate = LocalDate.parse(date, dateTimeFormatter);
+            String currentDate, int intervalDay, DatePeriodEnum datePeriodEnum) {
+        LocalDate specifiedDate = LocalDate.parse(currentDate, dateTimeFormatter);
        LocalDate result = null;
        switch (datePeriodEnum) {
            case DAY:
-                result = currentDate.minusDays(intervalDay);
+                result = specifiedDate.minusDays(intervalDay);
                break;
            case WEEK:
-                result = currentDate.minusWeeks(intervalDay);
+                result = specifiedDate.minusWeeks(intervalDay);
                if (intervalDay == 0) {
                    result =
                            result.with(
@@ -99,13 +105,13 @@ public class DateUtils {
                }
                break;
            case MONTH:
-                result = currentDate.minusMonths(intervalDay);
+                result = specifiedDate.minusMonths(intervalDay);
                if (intervalDay == 0) {
                    result = result.with(TemporalAdjusters.firstDayOfMonth());
                }
                break;
            case QUARTER:
-                result = currentDate.minusMonths(intervalDay * 3L);
+                result = specifiedDate.minusMonths(intervalDay * 3L);
                if (intervalDay == 0) {
                    TemporalAdjuster firstDayOfQuarter =
                            temporal -> {
@@ -119,7 +125,7 @@ public class DateUtils {
                }
                break;
            case YEAR:
-                result = currentDate.minusYears(intervalDay);
+                result = specifiedDate.minusYears(intervalDay);
                if (intervalDay == 0) {
                    result = result.with(TemporalAdjusters.firstDayOfYear());
                }
@@ -129,6 +135,7 @@ public class DateUtils {
        if (Objects.nonNull(result)) {
            return result.format(DateTimeFormatter.ofPattern(DATE_FORMAT));
        }
+
        return null;
    }

--- a/headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/SemanticSchema.java
+++ b/headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/SemanticSchema.java
@@ -118,16 +118,6 @@ public class SemanticSchema implements Serializable {
        return tags;
    }

-    public List<SchemaElement> getTags(Long dataSetId) {
-        List<SchemaElement> tags = new ArrayList<>();
-        dataSetSchemaList.stream()
-                .filter(
-                        schemaElement ->
-                                dataSetId.equals(schemaElement.getDataSet().getDataSetId()))
-                .forEach(d -> tags.addAll(d.getTags()));
-        return tags;
-    }
-
    public List<SchemaElement> getTerms() {
        List<SchemaElement> terms = new ArrayList<>();
        dataSetSchemaList.stream().forEach(d -> terms.addAll(d.getTerms()));
--- a/headless/chat/src/main/java/com/tencent/supersonic/headless/chat/corrector/S2SqlDateHelper.java
+++ b/headless/chat/src/main/java/com/tencent/supersonic/headless/chat/corrector/S2SqlDateHelper.java
@@ -1,95 +1,65 @@
 package com.tencent.supersonic.headless.chat.corrector;

 import com.tencent.supersonic.common.pojo.enums.DatePeriodEnum;
-import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.pojo.enums.TimeMode;
 import com.tencent.supersonic.common.util.DateUtils;
-import com.tencent.supersonic.headless.api.pojo.DataSetSchema;
 import com.tencent.supersonic.headless.api.pojo.TimeDefaultConfig;
-import com.tencent.supersonic.headless.chat.ChatQueryContext;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.Pair;

+import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
-import java.util.Objects;

 public class S2SqlDateHelper {

-    public static String getReferenceDate(ChatQueryContext chatQueryContext, Long dataSetId) {
-        String defaultDate = DateUtils.getBeforeDate(0);
-        if (Objects.isNull(dataSetId)) {
-            return defaultDate;
-        }
-        DataSetSchema dataSetSchema =
-                chatQueryContext.getSemanticSchema().getDataSetSchemaMap().get(dataSetId);
-        if (dataSetSchema == null || dataSetSchema.getTagTypeTimeDefaultConfig() == null) {
-            return defaultDate;
-        }
-        TimeDefaultConfig tagTypeTimeDefaultConfig = dataSetSchema.getTagTypeTimeDefaultConfig();
-        String partitionTimeFormat = dataSetSchema.getPartitionTimeFormat();
-        return getDefaultDate(defaultDate, tagTypeTimeDefaultConfig, partitionTimeFormat).getLeft();
+    public static Pair<String, String> calculateDateRange(
+            TimeDefaultConfig timeConfig, String timeFormat) {
+        return calculateDateRange(DateUtils.getBeforeDate(0), timeConfig, timeFormat);
    }

-    public static Pair<String, String> getStartEndDate(
-            ChatQueryContext chatQueryContext, Long dataSetId, QueryType queryType) {
-        String defaultDate = DateUtils.getBeforeDate(0);
-        if (Objects.isNull(dataSetId)) {
-            return Pair.of(defaultDate, defaultDate);
-        }
-        DataSetSchema dataSetSchema =
-                chatQueryContext.getSemanticSchema().getDataSetSchemaMap().get(dataSetId);
-        if (Objects.isNull(dataSetSchema)) {
-            return Pair.of(defaultDate, defaultDate);
-        }
-        TimeDefaultConfig defaultConfig = dataSetSchema.getMetricTypeTimeDefaultConfig();
-        if (QueryType.DETAIL.equals(queryType) && defaultConfig.getUnit() >= 0) {
-            defaultConfig = dataSetSchema.getTagTypeTimeDefaultConfig();
-        }
-        String partitionTimeFormat = dataSetSchema.getPartitionTimeFormat();
-        return getDefaultDate(defaultDate, defaultConfig, partitionTimeFormat);
-    }
-
-    private static Pair<String, String> getDefaultDate(
-            String defaultDate, TimeDefaultConfig defaultConfig, String partitionTimeFormat) {
-        if (defaultConfig == null) {
-            return Pair.of(null, null);
-        }
-        Integer unit = defaultConfig.getUnit();
-        if (unit == null) {
-            return Pair.of(defaultDate, defaultDate);
-        }
-
-        // If the unit is set to less than 0, then do not add relative date.
-        if (unit < 0) {
+    public static Pair<String, String> calculateDateRange(
+            String currentDate, TimeDefaultConfig timeConfig, String timeFormat) {
+        Integer unit = timeConfig.getUnit();
+        if (timeConfig == null || unit == null || unit < 0) {
            return Pair.of(null, null);
        }

-        String period = defaultConfig.getPeriod();
-        TimeMode timeMode = defaultConfig.getTimeMode();
-        DatePeriodEnum datePeriodEnum = DatePeriodEnum.get(period);
-
-        String startDate = DateUtils.getBeforeDate(unit, datePeriodEnum);
-        String endDate = DateUtils.getBeforeDate(0, DatePeriodEnum.DAY);
-
-        if (unit == 0 || TimeMode.LAST.equals(timeMode)) {
-            endDate = startDate;
+        TimeMode timeMode = timeConfig.getTimeMode();
+        DatePeriodEnum datePeriod = DatePeriodEnum.get(timeConfig.getPeriod());
+        String startDate;
+        String endDate;
+        switch (timeMode) {
+            case CURRENT:
+                startDate = DateUtils.getBeforeDate(currentDate, datePeriod);
+                endDate = currentDate;
+                break;
+            case RECENT:
+                startDate = DateUtils.getBeforeDate(currentDate, unit, datePeriod);
+                endDate = currentDate;
+                break;
+            case LAST:
+            default:
+                startDate = DateUtils.getBeforeDate(currentDate, unit, datePeriod);
+                endDate = DateUtils.getBeforeDate(currentDate, unit, datePeriod);
+                break;
        }
-        if (StringUtils.isNotBlank(partitionTimeFormat)) {
-            startDate = formatDate(startDate, partitionTimeFormat);
-            endDate = formatDate(endDate, partitionTimeFormat);
+
+        if (StringUtils.isNotBlank(timeFormat)) {
+            startDate = reformatDate(startDate, timeFormat);
+            endDate = reformatDate(endDate, timeFormat);
        }
        return Pair.of(startDate, endDate);
    }

-    private static String formatDate(String dateStr, String format) {
+    private static String reformatDate(String dateStr, String format) {
        try {
            // Assuming the input date format is "yyyy-MM-dd"
            SimpleDateFormat inputFormat = new SimpleDateFormat(DateUtils.DATE_FORMAT);
            Date date = inputFormat.parse(dateStr);
            SimpleDateFormat outputFormat = new SimpleDateFormat(format);
            return outputFormat.format(date);
-        } catch (Exception e) {
+        } catch (ParseException e) {
            // Handle the exception, maybe log it and return the original dateStr
            return dateStr;
        }
--- a/headless/chat/src/main/java/com/tencent/supersonic/headless/chat/corrector/TimeCorrector.java
+++ b/headless/chat/src/main/java/com/tencent/supersonic/headless/chat/corrector/TimeCorrector.java
@@ -4,9 +4,12 @@ import com.tencent.supersonic.common.jsqlparser.DateVisitor.DateBoundInfo;
 import com.tencent.supersonic.common.jsqlparser.SqlAddHelper;
 import com.tencent.supersonic.common.jsqlparser.SqlDateSelectHelper;
 import com.tencent.supersonic.common.jsqlparser.SqlSelectHelper;
+import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
 import com.tencent.supersonic.headless.api.pojo.DataSetSchema;
+import com.tencent.supersonic.headless.api.pojo.QueryConfig;
 import com.tencent.supersonic.headless.api.pojo.SemanticParseInfo;
+import com.tencent.supersonic.headless.api.pojo.TimeDefaultConfig;
 import com.tencent.supersonic.headless.chat.ChatQueryContext;
 import lombok.extern.slf4j.Slf4j;
 import net.sf.jsqlparser.JSQLParserException;
@@ -27,10 +30,10 @@ public class TimeCorrector extends BaseSemanticCorrector {
    public void doCorrect(ChatQueryContext chatQueryContext, SemanticParseInfo semanticParseInfo) {
        if (containsPartitionDimensions(chatQueryContext, semanticParseInfo)) {
            addDateIfNotExist(chatQueryContext, semanticParseInfo);
+            addLowerBoundDate(semanticParseInfo);
        } else {
            removeDateIfExist(chatQueryContext, semanticParseInfo);
        }
-        addLowerBoundDate(semanticParseInfo);
    }

    private void addDateIfNotExist(
@@ -48,15 +51,21 @@ public class TimeCorrector extends BaseSemanticCorrector {
        }
        String partitionDimension = dataSetSchema.getPartitionDimension().getName();
        if (CollectionUtils.isEmpty(whereFields) || !whereFields.contains(partitionDimension)) {
-            Pair<String, String> startEndDate =
-                    S2SqlDateHelper.getStartEndDate(
-                            chatQueryContext, dataSetId, semanticParseInfo.getQueryType());
+            TimeDefaultConfig timeConfig;
+            QueryConfig queryConfig = dataSetSchema.getQueryConfig();
+            if (QueryType.METRIC.equals(semanticParseInfo.getQueryType())) {
+                timeConfig = queryConfig.getMetricTypeDefaultConfig().getTimeDefaultConfig();
+            } else {
+                timeConfig = queryConfig.getTagTypeDefaultConfig().getTimeDefaultConfig();
+            }

-            if (isValidDateRange(startEndDate)) {
+            String timeFormat = dataSetSchema.getPartitionTimeFormat();
+            Pair<String, String> dateRange =
+                    S2SqlDateHelper.calculateDateRange(timeConfig, timeFormat);
+            if (isValidDateRange(dateRange)) {
                correctS2SQL = SqlAddHelper.addParenthesisToWhere(correctS2SQL);
-                String startDateLeft = startEndDate.getLeft();
-                String endDateRight = startEndDate.getRight();
-
+                String startDateLeft = dateRange.getLeft();
+                String endDateRight = dateRange.getRight();
                String condExpr =
                        String.format(
                                " ( %s >= '%s'  and %s <= '%s' )",
--- a/headless/chat/src/test/java/com/tencent/supersonic/headless/chat/utils/S2SqlDateHelperTest.java
+++ b/headless/chat/src/test/java/com/tencent/supersonic/headless/chat/utils/S2SqlDateHelperTest.java
@@ -1,134 +1,79 @@
 package com.tencent.supersonic.headless.chat.utils;

 import com.tencent.supersonic.common.pojo.Constants;
-import com.tencent.supersonic.common.pojo.enums.QueryType;
 import com.tencent.supersonic.common.pojo.enums.TimeMode;
-import com.tencent.supersonic.common.util.DateUtils;
-import com.tencent.supersonic.headless.api.pojo.DataSetSchema;
-import com.tencent.supersonic.headless.api.pojo.QueryConfig;
-import com.tencent.supersonic.headless.api.pojo.SchemaElement;
-import com.tencent.supersonic.headless.api.pojo.SemanticSchema;
 import com.tencent.supersonic.headless.api.pojo.TimeDefaultConfig;
-import com.tencent.supersonic.headless.chat.ChatQueryContext;
 import com.tencent.supersonic.headless.chat.corrector.S2SqlDateHelper;
 import org.apache.commons.lang3.tuple.Pair;
-import org.junit.Assert;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;

-import java.util.ArrayList;
-import java.util.List;
-
-@Disabled
 class S2SqlDateHelperTest {

    @Test
-    void getReferenceDate() {
-        Long dataSetId = 1L;
-        ChatQueryContext chatQueryContext = buildQueryContext(dataSetId);
-
-        String referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, null);
-        Assert.assertEquals(referenceDate, DateUtils.getBeforeDate(0));
-
-        referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, dataSetId);
-        Assert.assertEquals(referenceDate, DateUtils.getBeforeDate(0));
-
-        DataSetSchema dataSetSchema =
-                chatQueryContext.getSemanticSchema().getDataSetSchemaMap().get(dataSetId);
-        QueryConfig queryConfig = dataSetSchema.getQueryConfig();
+    void testCurrentTimeMode() {
        TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig();
-        timeDefaultConfig.setTimeMode(TimeMode.LAST);
-        timeDefaultConfig.setPeriod(Constants.DAY);
-        timeDefaultConfig.setUnit(20);
-        queryConfig.getTagTypeDefaultConfig().setTimeDefaultConfig(timeDefaultConfig);
+        timeDefaultConfig.setTimeMode(TimeMode.CURRENT);
+        timeDefaultConfig.setPeriod(Constants.MONTH);

-        referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, dataSetId);
-        Assert.assertEquals(referenceDate, DateUtils.getBeforeDate(20));
+        Pair<String, String> dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2024-09-01");
+        assert dateRange.getRight().equals("2024-09-21");

-        timeDefaultConfig.setUnit(1);
-        referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, dataSetId);
-        Assert.assertEquals(referenceDate, DateUtils.getBeforeDate(1));
-
-        timeDefaultConfig.setUnit(-1);
-        referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, dataSetId);
-        Assert.assertNull(referenceDate);
+        timeDefaultConfig.setPeriod(Constants.YEAR);
+        dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2024-01-01");
+        assert dateRange.getRight().equals("2024-09-21");
    }

    @Test
-    void getStartEndDate() {
-        Long dataSetId = 1L;
-        ChatQueryContext chatQueryContext = buildQueryContext(dataSetId);
+    void testRecentTimeMode() {
+        TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig();
+        timeDefaultConfig.setTimeMode(TimeMode.RECENT);
+        timeDefaultConfig.setUnit(3);
+        timeDefaultConfig.setPeriod(Constants.DAY);

-        Pair<String, String> startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, null, QueryType.DETAIL);
-        Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(0));
-        Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(0));
+        Pair<String, String> dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2024-09-18");
+        assert dateRange.getRight().equals("2024-09-21");

-        startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.DETAIL);
-        Assert.assertNotNull(startEndDate.getLeft());
-        Assert.assertNotNull(startEndDate.getRight());
+        timeDefaultConfig.setPeriod(Constants.MONTH);
+        dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2024-06-21");
+        assert dateRange.getRight().equals("2024-09-21");

-        DataSetSchema dataSetSchema =
-                chatQueryContext.getSemanticSchema().getDataSetSchemaMap().get(dataSetId);
-        QueryConfig queryConfig = dataSetSchema.getQueryConfig();
+        timeDefaultConfig.setPeriod(Constants.YEAR);
+        dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2021-09-21");
+        assert dateRange.getRight().equals("2024-09-21");
+    }
+
+    @Test
+    void testLastTimeMode() {
        TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig();
        timeDefaultConfig.setTimeMode(TimeMode.LAST);
+        timeDefaultConfig.setUnit(3);
        timeDefaultConfig.setPeriod(Constants.DAY);
-        timeDefaultConfig.setUnit(20);
-        queryConfig.getTagTypeDefaultConfig().setTimeDefaultConfig(timeDefaultConfig);
-        queryConfig.getMetricTypeDefaultConfig().setTimeDefaultConfig(timeDefaultConfig);

-        startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.DETAIL);
-        Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(20));
-        Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(20));
+        Pair<String, String> dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2024-09-18");
+        assert dateRange.getRight().equals("2024-09-18");

-        startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.METRIC);
-        Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(20));
-        Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(20));
+        timeDefaultConfig.setPeriod(Constants.MONTH);
+        dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2024-06-21");
+        assert dateRange.getRight().equals("2024-06-21");

-        timeDefaultConfig.setUnit(2);
-        timeDefaultConfig.setTimeMode(TimeMode.RECENT);
-        startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.METRIC);
-        Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(2));
-        Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(1));
-
-        startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.DETAIL);
-        Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(2));
-        Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(1));
-
-        timeDefaultConfig.setUnit(-1);
-        startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.METRIC);
-        Assert.assertNull(startEndDate.getLeft());
-        Assert.assertNull(startEndDate.getRight());
-
-        timeDefaultConfig.setTimeMode(TimeMode.LAST);
-        timeDefaultConfig.setPeriod(Constants.DAY);
-        timeDefaultConfig.setUnit(5);
-        startEndDate =
-                S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.METRIC);
-        Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(5));
-        Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(5));
-    }
-
-    private ChatQueryContext buildQueryContext(Long dataSetId) {
-        ChatQueryContext chatQueryContext = new ChatQueryContext();
-        List<DataSetSchema> dataSetSchemaList = new ArrayList<>();
-        DataSetSchema dataSetSchema = new DataSetSchema();
-        QueryConfig queryConfig = new QueryConfig();
-        dataSetSchema.setQueryConfig(queryConfig);
-        SchemaElement schemaElement = new SchemaElement();
-        schemaElement.setDataSetId(dataSetId);
-        dataSetSchema.setDataSet(schemaElement);
-        dataSetSchemaList.add(dataSetSchema);
-
-        SemanticSchema semanticSchema = new SemanticSchema(dataSetSchemaList);
-        chatQueryContext.setSemanticSchema(semanticSchema);
-        return chatQueryContext;
+        timeDefaultConfig.setPeriod(Constants.YEAR);
+        dateRange =
+                S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
+        assert dateRange.getLeft().equals("2021-09-21");
+        assert dateRange.getRight().equals("2021-09-21");
    }
 }
--- a/launchers/standalone/src/main/java/com/tencent/supersonic/demo/S2ArtistDemo.java
+++ b/launchers/standalone/src/main/java/com/tencent/supersonic/demo/S2ArtistDemo.java
@@ -9,7 +9,6 @@ import com.tencent.supersonic.chat.server.agent.AgentToolType;
 import com.tencent.supersonic.chat.server.agent.LLMParserTool;
 import com.tencent.supersonic.chat.server.agent.RuleParserTool;
 import com.tencent.supersonic.common.pojo.enums.StatusEnum;
-import com.tencent.supersonic.common.pojo.enums.TimeMode;
 import com.tencent.supersonic.common.pojo.enums.TypeEnums;
 import com.tencent.supersonic.headless.api.pojo.DataSetDetail;
 import com.tencent.supersonic.headless.api.pojo.DataSetModelConfig;
@@ -21,7 +20,6 @@ import com.tencent.supersonic.headless.api.pojo.MetricTypeDefaultConfig;
 import com.tencent.supersonic.headless.api.pojo.ModelDetail;
 import com.tencent.supersonic.headless.api.pojo.QueryConfig;
 import com.tencent.supersonic.headless.api.pojo.TagTypeDefaultConfig;
-import com.tencent.supersonic.headless.api.pojo.TimeDefaultConfig;
 import com.tencent.supersonic.headless.api.pojo.enums.DimensionType;
 import com.tencent.supersonic.headless.api.pojo.enums.IdentifyType;
 import com.tencent.supersonic.headless.api.pojo.enums.TagDefineType;
@@ -166,20 +164,12 @@ public class S2ArtistDemo extends S2BaseDemo {
        dataSetReq.setTypeEnum(TypeEnums.DATASET);
        QueryConfig queryConfig = new QueryConfig();
        TagTypeDefaultConfig tagTypeDefaultConfig = new TagTypeDefaultConfig();
-        TimeDefaultConfig tagTimeDefaultConfig = new TimeDefaultConfig();
-        tagTimeDefaultConfig.setTimeMode(TimeMode.LAST);
-        tagTimeDefaultConfig.setUnit(7);
-        tagTypeDefaultConfig.setTimeDefaultConfig(tagTimeDefaultConfig);
        DefaultDisplayInfo defaultDisplayInfo = new DefaultDisplayInfo();
        defaultDisplayInfo.setDimensionIds(dataSetModelConfigs.get(0).getDimensions());
        MetricResp jsPlayCntMetric = getMetric("js_play_cnt", singerModel);
        defaultDisplayInfo.setMetricIds(Lists.newArrayList(jsPlayCntMetric.getId()));
        tagTypeDefaultConfig.setDefaultDisplayInfo(defaultDisplayInfo);
        MetricTypeDefaultConfig metricTypeDefaultConfig = new MetricTypeDefaultConfig();
-        TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig();
-        timeDefaultConfig.setTimeMode(TimeMode.RECENT);
-        timeDefaultConfig.setUnit(7);
-        metricTypeDefaultConfig.setTimeDefaultConfig(timeDefaultConfig);
        queryConfig.setTagTypeDefaultConfig(tagTypeDefaultConfig);
        queryConfig.setMetricTypeDefaultConfig(metricTypeDefaultConfig);
        dataSetReq.setQueryConfig(queryConfig);