topdog/supersonic
1
0
Fork 0
mirror of https://github.com/tencentmusic/supersonic.git synced 2025-12-12 12:37:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
jerryjzhang
2024-09-21 13:14:47 +08:00
parent 26ca5300f4
commit b6765387f5
7 changed files with 138 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
common/src/main/java/com/tencent/supersonic/common/pojo/enums/TimeMode.java
View File

@@ -2,7 +2,10 @@ package com.tencent.supersonic.common.pojo.enums;
public enum TimeMode { public enum TimeMode {
/** date mode LAST - a certain time RECENT - a period time */ // a specific date at N days ago
LAST, 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
} }

61
common/src/main/java/com/tencent/supersonic/common/util/DateUtils.java
View File

@@ -6,6 +6,7 @@ import com.tencent.supersonic.common.pojo.enums.DatePeriodEnum;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import java.text.DateFormat; import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.time.LocalDate; import java.time.LocalDate;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@@ -16,7 +17,6 @@ import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters; import java.time.temporal.TemporalAdjusters;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Calendar;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
import java.util.Objects; import java.util.Objects;
@@ -27,14 +27,8 @@ public class DateUtils {
public static final String DATE_FORMAT = "yyyy-MM-dd"; 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 TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static final String FORMAT = "yyyyMMddHHmmss"; public static final String FORMAT = "yyyyMMddHHmmss";
private static final DateTimeFormatter dateTimeFormatter =
public static Integer currentYear() { DateTimeFormatter.ofPattern(DATE_FORMAT);
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;
}
public static DateTimeFormatter getDateFormatter(String date, String[] formats) { public static DateTimeFormatter getDateFormatter(String date, String[] formats) {
for (int i = 0; i < formats.length; i++) { for (int i = 0; i < formats.length; i++) {
@@ -43,8 +37,8 @@ public class DateUtils {
try { try {
dateFormat.parse(date); dateFormat.parse(date);
return DateTimeFormatter.ofPattern(format); return DateTimeFormatter.ofPattern(format);
} catch (Exception e) { } catch (ParseException e) {
log.info("date parse has a exception:{}", e.toString()); log.warn("date parse has a exception:{}", e.toString());
} }
} }
return DateTimeFormatter.ofPattern(formats[0]); return DateTimeFormatter.ofPattern(formats[0]);
@@ -57,41 +51,53 @@ public class DateUtils {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format); DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
LocalDateTime.parse(date, dateTimeFormatter); LocalDateTime.parse(date, dateTimeFormatter);
return dateTimeFormatter; return dateTimeFormatter;
} catch (Exception e) { } catch (DateTimeParseException e) {
log.info("date parse has a exception:{}", e.toString()); log.warn("date parse has a exception:{}", e.toString());
} }
} }
return DateTimeFormatter.ofPattern(formats[0]); return DateTimeFormatter.ofPattern(formats[0]);
} }
public static String getBeforeDate(int intervalDay) { public static String getBeforeDate(int intervalDay) {
Calendar calendar = Calendar.getInstance(); return getBeforeDate(intervalDay, DatePeriodEnum.DAY);
calendar.setTime(new Date());
calendar.add(Calendar.DAY_OF_MONTH, -intervalDay);
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
return dateFormat.format(calendar.getTime());
} }
public static String getBeforeDate(int intervalDay, DatePeriodEnum datePeriodEnum) { public static String getBeforeDate(int intervalDay, DatePeriodEnum datePeriodEnum) {
if (Objects.isNull(datePeriodEnum)) { if (Objects.isNull(datePeriodEnum)) {
return getBeforeDate(intervalDay); datePeriodEnum = DatePeriodEnum.DAY;
} }
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT); SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
String currentDate = dateFormat.format(new Date()); String currentDate = dateFormat.format(new Date());
return getBeforeDate(currentDate, intervalDay, datePeriodEnum); 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( public static String getBeforeDate(
String date, int intervalDay, DatePeriodEnum datePeriodEnum) { String currentDate, int intervalDay, DatePeriodEnum datePeriodEnum) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DATE_FORMAT); LocalDate specifiedDate = LocalDate.parse(currentDate, dateTimeFormatter);
LocalDate currentDate = LocalDate.parse(date, dateTimeFormatter);
LocalDate result = null; LocalDate result = null;
switch (datePeriodEnum) { switch (datePeriodEnum) {
case DAY: case DAY:
result = currentDate.minusDays(intervalDay); result = specifiedDate.minusDays(intervalDay);
break; break;
case WEEK: case WEEK:
result = currentDate.minusWeeks(intervalDay); result = specifiedDate.minusWeeks(intervalDay);
if (intervalDay == 0) { if (intervalDay == 0) {
result = result =
result.with( result.with(
@@ -99,13 +105,13 @@ public class DateUtils {
} }
break; break;
case MONTH: case MONTH:
result = currentDate.minusMonths(intervalDay); result = specifiedDate.minusMonths(intervalDay);
if (intervalDay == 0) { if (intervalDay == 0) {
result = result.with(TemporalAdjusters.firstDayOfMonth()); result = result.with(TemporalAdjusters.firstDayOfMonth());
} }
break; break;
case QUARTER: case QUARTER:
result = currentDate.minusMonths(intervalDay * 3L); result = specifiedDate.minusMonths(intervalDay * 3L);
if (intervalDay == 0) { if (intervalDay == 0) {
TemporalAdjuster firstDayOfQuarter = TemporalAdjuster firstDayOfQuarter =
temporal -> { temporal -> {
@@ -119,7 +125,7 @@ public class DateUtils {
} }
break; break;
case YEAR: case YEAR:
result = currentDate.minusYears(intervalDay); result = specifiedDate.minusYears(intervalDay);
if (intervalDay == 0) { if (intervalDay == 0) {
result = result.with(TemporalAdjusters.firstDayOfYear()); result = result.with(TemporalAdjusters.firstDayOfYear());
} }
@@ -129,6 +135,7 @@ public class DateUtils {
if (Objects.nonNull(result)) { if (Objects.nonNull(result)) {
return result.format(DateTimeFormatter.ofPattern(DATE_FORMAT)); return result.format(DateTimeFormatter.ofPattern(DATE_FORMAT));
} }
return null; return null;
} }

10
headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/SemanticSchema.java
View File

@@ -118,16 +118,6 @@ public class SemanticSchema implements Serializable {
return tags; 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() { public List<SchemaElement> getTerms() {
List<SchemaElement> terms = new ArrayList<>(); List<SchemaElement> terms = new ArrayList<>();
dataSetSchemaList.stream().forEach(d -> terms.addAll(d.getTerms())); dataSetSchemaList.stream().forEach(d -> terms.addAll(d.getTerms()));

94
headless/chat/src/main/java/com/tencent/supersonic/headless/chat/corrector/S2SqlDateHelper.java
View File

@@ -1,95 +1,65 @@
package com.tencent.supersonic.headless.chat.corrector; package com.tencent.supersonic.headless.chat.corrector;
import com.tencent.supersonic.common.pojo.enums.DatePeriodEnum; 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.pojo.enums.TimeMode;
import com.tencent.supersonic.common.util.DateUtils; 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.api.pojo.TimeDefaultConfig;
import com.tencent.supersonic.headless.chat.ChatQueryContext;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair; import org.apache.commons.lang3.tuple.Pair;
import java.text.ParseException;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.util.Date; import java.util.Date;
import java.util.Objects;
public class S2SqlDateHelper { public class S2SqlDateHelper {
public static String getReferenceDate(ChatQueryContext chatQueryContext, Long dataSetId) { public static Pair<String, String> calculateDateRange(
String defaultDate = DateUtils.getBeforeDate(0); TimeDefaultConfig timeConfig, String timeFormat) {
if (Objects.isNull(dataSetId)) { return calculateDateRange(DateUtils.getBeforeDate(0), timeConfig, timeFormat);
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> getStartEndDate( public static Pair<String, String> calculateDateRange(
ChatQueryContext chatQueryContext, Long dataSetId, QueryType queryType) { String currentDate, TimeDefaultConfig timeConfig, String timeFormat) {
String defaultDate = DateUtils.getBeforeDate(0); Integer unit = timeConfig.getUnit();
if (Objects.isNull(dataSetId)) { if (timeConfig == null || unit == null || unit < 0) {
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) {
return Pair.of(null, null); return Pair.of(null, null);
} }
String period = defaultConfig.getPeriod(); TimeMode timeMode = timeConfig.getTimeMode();
TimeMode timeMode = defaultConfig.getTimeMode(); DatePeriodEnum datePeriod = DatePeriodEnum.get(timeConfig.getPeriod());
DatePeriodEnum datePeriodEnum = DatePeriodEnum.get(period); String startDate;
String endDate;
String startDate = DateUtils.getBeforeDate(unit, datePeriodEnum); switch (timeMode) {
String endDate = DateUtils.getBeforeDate(0, DatePeriodEnum.DAY); case CURRENT:
startDate = DateUtils.getBeforeDate(currentDate, datePeriod);
if (unit == 0 || TimeMode.LAST.equals(timeMode)) { endDate = currentDate;
endDate = startDate; 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); if (StringUtils.isNotBlank(timeFormat)) {
endDate = formatDate(endDate, partitionTimeFormat); startDate = reformatDate(startDate, timeFormat);
endDate = reformatDate(endDate, timeFormat);
} }
return Pair.of(startDate, endDate); return Pair.of(startDate, endDate);
} }
private static String formatDate(String dateStr, String format) { private static String reformatDate(String dateStr, String format) {
try { try {
// Assuming the input date format is "yyyy-MM-dd" // Assuming the input date format is "yyyy-MM-dd"
SimpleDateFormat inputFormat = new SimpleDateFormat(DateUtils.DATE_FORMAT); SimpleDateFormat inputFormat = new SimpleDateFormat(DateUtils.DATE_FORMAT);
Date date = inputFormat.parse(dateStr); Date date = inputFormat.parse(dateStr);
SimpleDateFormat outputFormat = new SimpleDateFormat(format); SimpleDateFormat outputFormat = new SimpleDateFormat(format);
return outputFormat.format(date); return outputFormat.format(date);
} catch (Exception e) { } catch (ParseException e) {
// Handle the exception, maybe log it and return the original dateStr // Handle the exception, maybe log it and return the original dateStr
return dateStr; return dateStr;
} }

25
headless/chat/src/main/java/com/tencent/supersonic/headless/chat/corrector/TimeCorrector.java
View File

@@ -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.SqlAddHelper;
import com.tencent.supersonic.common.jsqlparser.SqlDateSelectHelper; import com.tencent.supersonic.common.jsqlparser.SqlDateSelectHelper;
import com.tencent.supersonic.common.jsqlparser.SqlSelectHelper; 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.common.pojo.enums.TimeDimensionEnum;
import com.tencent.supersonic.headless.api.pojo.DataSetSchema; 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.SemanticParseInfo;
import com.tencent.supersonic.headless.api.pojo.TimeDefaultConfig;
import com.tencent.supersonic.headless.chat.ChatQueryContext; import com.tencent.supersonic.headless.chat.ChatQueryContext;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.JSQLParserException;
@@ -27,10 +30,10 @@ public class TimeCorrector extends BaseSemanticCorrector {
public void doCorrect(ChatQueryContext chatQueryContext, SemanticParseInfo semanticParseInfo) { public void doCorrect(ChatQueryContext chatQueryContext, SemanticParseInfo semanticParseInfo) {
if (containsPartitionDimensions(chatQueryContext, semanticParseInfo)) { if (containsPartitionDimensions(chatQueryContext, semanticParseInfo)) {
addDateIfNotExist(chatQueryContext, semanticParseInfo); addDateIfNotExist(chatQueryContext, semanticParseInfo);
addLowerBoundDate(semanticParseInfo);
} else { } else {
removeDateIfExist(chatQueryContext, semanticParseInfo); removeDateIfExist(chatQueryContext, semanticParseInfo);
} }
addLowerBoundDate(semanticParseInfo);
} }
private void addDateIfNotExist( private void addDateIfNotExist(
@@ -48,15 +51,21 @@ public class TimeCorrector extends BaseSemanticCorrector {
} }
String partitionDimension = dataSetSchema.getPartitionDimension().getName(); String partitionDimension = dataSetSchema.getPartitionDimension().getName();
if (CollectionUtils.isEmpty(whereFields) || !whereFields.contains(partitionDimension)) { if (CollectionUtils.isEmpty(whereFields) || !whereFields.contains(partitionDimension)) {
Pair<String, String> startEndDate = TimeDefaultConfig timeConfig;
S2SqlDateHelper.getStartEndDate( QueryConfig queryConfig = dataSetSchema.getQueryConfig();
chatQueryContext, dataSetId, semanticParseInfo.getQueryType()); 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); correctS2SQL = SqlAddHelper.addParenthesisToWhere(correctS2SQL);
String startDateLeft = startEndDate.getLeft(); String startDateLeft = dateRange.getLeft();
String endDateRight = startEndDate.getRight(); String endDateRight = dateRange.getRight();
String condExpr = String condExpr =
String.format( String.format(
" ( %s >= '%s' and %s <= '%s' )", " ( %s >= '%s' and %s <= '%s' )",

155
headless/chat/src/test/java/com/tencent/supersonic/headless/chat/utils/S2SqlDateHelperTest.java
View File

@@ -1,134 +1,79 @@
package com.tencent.supersonic.headless.chat.utils; package com.tencent.supersonic.headless.chat.utils;
import com.tencent.supersonic.common.pojo.Constants; 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.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.api.pojo.TimeDefaultConfig;
import com.tencent.supersonic.headless.chat.ChatQueryContext;
import com.tencent.supersonic.headless.chat.corrector.S2SqlDateHelper; import com.tencent.supersonic.headless.chat.corrector.S2SqlDateHelper;
import org.apache.commons.lang3.tuple.Pair; import org.apache.commons.lang3.tuple.Pair;
import org.junit.Assert;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
@Disabled
class S2SqlDateHelperTest { class S2SqlDateHelperTest {
@Test @Test
void getReferenceDate() { void testCurrentTimeMode() {
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();
TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig(); TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig();
timeDefaultConfig.setTimeMode(TimeMode.LAST); timeDefaultConfig.setTimeMode(TimeMode.CURRENT);
timeDefaultConfig.setPeriod(Constants.DAY); timeDefaultConfig.setPeriod(Constants.MONTH);
timeDefaultConfig.setUnit(20);
queryConfig.getTagTypeDefaultConfig().setTimeDefaultConfig(timeDefaultConfig);
referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, dataSetId); Pair<String, String> dateRange =
Assert.assertEquals(referenceDate, DateUtils.getBeforeDate(20)); 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); timeDefaultConfig.setPeriod(Constants.YEAR);
referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, dataSetId); dateRange =
Assert.assertEquals(referenceDate, DateUtils.getBeforeDate(1)); S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
assert dateRange.getLeft().equals("2024-01-01");
timeDefaultConfig.setUnit(-1); assert dateRange.getRight().equals("2024-09-21");
referenceDate = S2SqlDateHelper.getReferenceDate(chatQueryContext, dataSetId);
Assert.assertNull(referenceDate);
} }
@Test @Test
void getStartEndDate() { void testRecentTimeMode() {
Long dataSetId = 1L; TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig();
ChatQueryContext chatQueryContext = buildQueryContext(dataSetId); timeDefaultConfig.setTimeMode(TimeMode.RECENT);
timeDefaultConfig.setUnit(3);
timeDefaultConfig.setPeriod(Constants.DAY);
Pair<String, String> startEndDate = Pair<String, String> dateRange =
S2SqlDateHelper.getStartEndDate(chatQueryContext, null, QueryType.DETAIL); S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(0)); assert dateRange.getLeft().equals("2024-09-18");
Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(0)); assert dateRange.getRight().equals("2024-09-21");
startEndDate = timeDefaultConfig.setPeriod(Constants.MONTH);
S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.DETAIL); dateRange =
Assert.assertNotNull(startEndDate.getLeft()); S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
Assert.assertNotNull(startEndDate.getRight()); assert dateRange.getLeft().equals("2024-06-21");
assert dateRange.getRight().equals("2024-09-21");
DataSetSchema dataSetSchema = timeDefaultConfig.setPeriod(Constants.YEAR);
chatQueryContext.getSemanticSchema().getDataSetSchemaMap().get(dataSetId); dateRange =
QueryConfig queryConfig = dataSetSchema.getQueryConfig(); 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 timeDefaultConfig = new TimeDefaultConfig();
timeDefaultConfig.setTimeMode(TimeMode.LAST); timeDefaultConfig.setTimeMode(TimeMode.LAST);
timeDefaultConfig.setUnit(3);
timeDefaultConfig.setPeriod(Constants.DAY); timeDefaultConfig.setPeriod(Constants.DAY);
timeDefaultConfig.setUnit(20);
queryConfig.getTagTypeDefaultConfig().setTimeDefaultConfig(timeDefaultConfig);
queryConfig.getMetricTypeDefaultConfig().setTimeDefaultConfig(timeDefaultConfig);
startEndDate = Pair<String, String> dateRange =
S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.DETAIL); S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(20)); assert dateRange.getLeft().equals("2024-09-18");
Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(20)); assert dateRange.getRight().equals("2024-09-18");
startEndDate = timeDefaultConfig.setPeriod(Constants.MONTH);
S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.METRIC); dateRange =
Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(20)); S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
Assert.assertEquals(startEndDate.getRight(), DateUtils.getBeforeDate(20)); assert dateRange.getLeft().equals("2024-06-21");
assert dateRange.getRight().equals("2024-06-21");
timeDefaultConfig.setUnit(2); timeDefaultConfig.setPeriod(Constants.YEAR);
timeDefaultConfig.setTimeMode(TimeMode.RECENT); dateRange =
startEndDate = S2SqlDateHelper.calculateDateRange("2024-09-21", timeDefaultConfig, "yyyy-MM-dd");
S2SqlDateHelper.getStartEndDate(chatQueryContext, dataSetId, QueryType.METRIC); assert dateRange.getLeft().equals("2021-09-21");
Assert.assertEquals(startEndDate.getLeft(), DateUtils.getBeforeDate(2)); assert dateRange.getRight().equals("2021-09-21");
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;
} }
} }

10
launchers/standalone/src/main/java/com/tencent/supersonic/demo/S2ArtistDemo.java
View File

@@ -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.LLMParserTool;
import com.tencent.supersonic.chat.server.agent.RuleParserTool; import com.tencent.supersonic.chat.server.agent.RuleParserTool;
import com.tencent.supersonic.common.pojo.enums.StatusEnum; 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.common.pojo.enums.TypeEnums;
import com.tencent.supersonic.headless.api.pojo.DataSetDetail; import com.tencent.supersonic.headless.api.pojo.DataSetDetail;
import com.tencent.supersonic.headless.api.pojo.DataSetModelConfig; 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.ModelDetail;
import com.tencent.supersonic.headless.api.pojo.QueryConfig; import com.tencent.supersonic.headless.api.pojo.QueryConfig;
import com.tencent.supersonic.headless.api.pojo.TagTypeDefaultConfig; 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.DimensionType;
import com.tencent.supersonic.headless.api.pojo.enums.IdentifyType; import com.tencent.supersonic.headless.api.pojo.enums.IdentifyType;
import com.tencent.supersonic.headless.api.pojo.enums.TagDefineType; import com.tencent.supersonic.headless.api.pojo.enums.TagDefineType;
@@ -166,20 +164,12 @@ public class S2ArtistDemo extends S2BaseDemo {
dataSetReq.setTypeEnum(TypeEnums.DATASET); dataSetReq.setTypeEnum(TypeEnums.DATASET);
QueryConfig queryConfig = new QueryConfig(); QueryConfig queryConfig = new QueryConfig();
TagTypeDefaultConfig tagTypeDefaultConfig = new TagTypeDefaultConfig(); TagTypeDefaultConfig tagTypeDefaultConfig = new TagTypeDefaultConfig();
TimeDefaultConfig tagTimeDefaultConfig = new TimeDefaultConfig();
tagTimeDefaultConfig.setTimeMode(TimeMode.LAST);
tagTimeDefaultConfig.setUnit(7);
tagTypeDefaultConfig.setTimeDefaultConfig(tagTimeDefaultConfig);
DefaultDisplayInfo defaultDisplayInfo = new DefaultDisplayInfo(); DefaultDisplayInfo defaultDisplayInfo = new DefaultDisplayInfo();
defaultDisplayInfo.setDimensionIds(dataSetModelConfigs.get(0).getDimensions()); defaultDisplayInfo.setDimensionIds(dataSetModelConfigs.get(0).getDimensions());
MetricResp jsPlayCntMetric = getMetric("js_play_cnt", singerModel); MetricResp jsPlayCntMetric = getMetric("js_play_cnt", singerModel);
defaultDisplayInfo.setMetricIds(Lists.newArrayList(jsPlayCntMetric.getId())); defaultDisplayInfo.setMetricIds(Lists.newArrayList(jsPlayCntMetric.getId()));
tagTypeDefaultConfig.setDefaultDisplayInfo(defaultDisplayInfo); tagTypeDefaultConfig.setDefaultDisplayInfo(defaultDisplayInfo);
MetricTypeDefaultConfig metricTypeDefaultConfig = new MetricTypeDefaultConfig(); MetricTypeDefaultConfig metricTypeDefaultConfig = new MetricTypeDefaultConfig();
TimeDefaultConfig timeDefaultConfig = new TimeDefaultConfig();
timeDefaultConfig.setTimeMode(TimeMode.RECENT);
timeDefaultConfig.setUnit(7);
metricTypeDefaultConfig.setTimeDefaultConfig(timeDefaultConfig);
queryConfig.setTagTypeDefaultConfig(tagTypeDefaultConfig); queryConfig.setTagTypeDefaultConfig(tagTypeDefaultConfig);
queryConfig.setMetricTypeDefaultConfig(metricTypeDefaultConfig); queryConfig.setMetricTypeDefaultConfig(metricTypeDefaultConfig);
dataSetReq.setQueryConfig(queryConfig); dataSetReq.setQueryConfig(queryConfig);