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

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

Browse Source
This commit is contained in:
lexluo09
2024-02-01 15:29:07 +08:00
committed by GitHub
parent 2c1c443b3e
commit 491c76368c
43 changed files with 749 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/DateVisitor.java Normal file
View File

@@ -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;
}
}

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

@@ -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;
}

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

@@ -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()

38
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserAddHelper.java → common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlAddHelper.java
View File

@@ -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)) {

35
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlDateSelectHelper.java Normal file
View File

@@ -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();
}
}

26
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserEqualHelper.java → common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlEqualHelper.java
View File

@@ -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> otherSelectFields = SqlParserSelectHelper.getSelectFields(otherSql);
List<String> thisSelectFields = SqlSelectHelper.getSelectFields(thisSql);
List<String> otherSelectFields = SqlSelectHelper.getSelectFields(otherSql);
if (!CollectionUtils.isEqualCollection(thisSelectFields, otherSelectFields)) {
return false;
}
//2. all fields
List<String> thisAllFields = SqlParserSelectHelper.getAllFields(thisSql);
List<String> otherAllFields = SqlParserSelectHelper.getAllFields(otherSql);
List<String> thisAllFields = SqlSelectHelper.getAllFields(thisSql);
List<String> otherAllFields = SqlSelectHelper.getAllFields(otherSql);
if (!CollectionUtils.isEqualCollection(thisAllFields, otherAllFields)) {
return false;
}
//3. where
List<FieldExpression> thisFieldExpressions = SqlParserSelectHelper.getFilterExpression(thisSql);
List<FieldExpression> otherFieldExpressions = SqlParserSelectHelper.getFilterExpression(otherSql);
List<FieldExpression> thisFieldExpressions = SqlSelectHelper.getFilterExpression(thisSql);
List<FieldExpression> otherFieldExpressions = SqlSelectHelper.getFilterExpression(otherSql);
if (!CollectionUtils.isEqualCollection(thisFieldExpressions, otherFieldExpressions)) {
return false;
}
//4. tableName
if (!SqlParserSelectHelper.getDbTableName(thisSql)
.equalsIgnoreCase(SqlParserSelectHelper.getDbTableName(otherSql))) {
if (!SqlSelectHelper.getDbTableName(thisSql)
.equalsIgnoreCase(SqlSelectHelper.getDbTableName(otherSql))) {
return false;
}
//5. having
List<FieldExpression> thisHavingExpressions = SqlParserSelectHelper.getHavingExpressions(thisSql);
List<FieldExpression> otherHavingExpressions = SqlParserSelectHelper.getHavingExpressions(otherSql);
List<FieldExpression> thisHavingExpressions = SqlSelectHelper.getHavingExpressions(thisSql);
List<FieldExpression> otherHavingExpressions = SqlSelectHelper.getHavingExpressions(otherSql);
if (!CollectionUtils.isEqualCollection(thisHavingExpressions, otherHavingExpressions)) {
return false;
}
//6. orderBy
List<FieldExpression> thisOrderByExpressions = SqlParserSelectHelper.getOrderByExpressions(thisSql);
List<FieldExpression> otherOrderByExpressions = SqlParserSelectHelper.getOrderByExpressions(otherSql);
List<FieldExpression> thisOrderByExpressions = SqlSelectHelper.getOrderByExpressions(thisSql);
List<FieldExpression> otherOrderByExpressions = SqlSelectHelper.getOrderByExpressions(otherSql);
if (!CollectionUtils.isEqualCollection(thisOrderByExpressions, otherOrderByExpressions)) {
return false;

42
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserRemoveHelper.java → common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlRemoveHelper.java
View File

@@ -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;
}

42
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserReplaceHelper.java → common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlReplaceHelper.java
View File

@@ -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);
}

6
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserSelectFunctionHelper.java → common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectFunctionHelper.java
View File

@@ -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)) {

51
common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserSelectHelper.java → common/src/main/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectHelper.java
View File

@@ -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,
String columnEnd) {
Expression expression = null;
for (ImmutablePair<String, String> t : times) {
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);
public static String getColumValue(Expression expression) {
if (expression instanceof StringValue) {
StringValue value = (StringValue) expression;
return value.getValue();
}
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<>();

14
common/src/test/java/com/tencent/supersonic/common/util/DateUtilsTest.java
View File

@@ -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

148
common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserAddHelperTest.java → common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlAddHelperTest.java
View File

@@ -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);
List<String> selectFields = SqlParserSelectHelper.getAllFields(sql);
sql = SqlAddHelper.addWhere(sql, "column_a", 123444555);
List<String> selectFields = SqlSelectHelper.getAllFields(sql);
Assert.assertEquals(selectFields.contains("column_a"), true);
sql = SqlParserAddHelper.addWhere(sql, "column_b", "123456666");
selectFields = SqlParserSelectHelper.getAllFields(sql);
sql = SqlAddHelper.addWhere(sql, "column_b", "123456666");
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 = SqlParserAddHelper.addWhere(sql, "数据日期", "2023-08-08");
sql = SqlAddHelper.addParenthesisToWhere(sql);
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);
replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
String replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlReplaceHelper.replaceAlias(sql);
replaceSql = SqlAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
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);
replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
String replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlAddHelper.addAggregateToField(sql, filedNameToAggregate);
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 = SqlParserAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
replaceSql = SqlParserAddHelper.addGroupBy(replaceSql, groupByFields);
replaceSql = SqlReplaceHelper.replaceAlias(sql);
replaceSql = SqlAddHelper.addAggregateToField(replaceSql, filedNameToAggregate);
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,
SqlParserSelectHelper.getOrderByFields(correctS2SQL));
String replaceFields = SqlAddHelper.addFieldsToSelect(correctS2SQL,
SqlSelectHelper.getOrderByFields(correctS2SQL));
Assert.assertEquals(
"SELECT 用户, 页面 FROM 超音数用户部门 GROUP BY 用户, 页面 ORDER BY count(*) DESC", replaceFields);

46
common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlDateSelectHelperTest.java Normal file
View File

@@ -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");
}
}

14
common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserEqualHelperTest.java → common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlEqualHelperTest.java
View File

@@ -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);
}
}

24
common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserRemoveHelperTest.java → common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlRemoveHelperTest.java
View File

@@ -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",

138
common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserReplaceHelperTest.java → common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlReplaceHelperTest.java
View File

@@ -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 = SqlParserReplaceHelper.replaceTable(replaceSql, "internet");
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName1);
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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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 = SqlParserRemoveHelper.removeNumberFilter(replaceSql);
replaceSql = SqlReplaceHelper.replaceFunction(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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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 = SqlParserRemoveHelper.removeNumberFilter(replaceSql);
replaceSql = SqlReplaceHelper.replaceFunction(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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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 = SqlParserReplaceHelper.replaceFunction(replaceSql);
replaceSql = SqlReplaceHelper.replaceFields(replaceSql, fieldToBizName);
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', 数据日期, "

28
common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserSelectFunctionHelperTest.java → common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectFunctionHelperTest.java
View File

@@ -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);
}

88
common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlParserSelectHelperTest.java → common/src/test/java/com/tencent/supersonic/common/util/jsqlparser/SqlSelectHelperTest.java
View File

@@ -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);
}