(improvement)(chat) rewrite datediff logic and perfect sql style (#461)

chat/core/src/main/java/com/tencent/supersonic/chat/processor/MetricCheckProcessor.java

@@ -215,7 +215,7 @@ public class MetricCheckProcessor implements ParseResultProcessor {
         sql = SqlParserRemoveHelper.removeSelect(sql, metricToRemove);
         sql = SqlParserRemoveHelper.removeSelect(sql, dimensionByToRemove);
         sql = SqlParserRemoveHelper.removeGroupBy(sql, dimensionByToRemove);
-        sql = SqlParserRemoveHelper.removeNumberCondition(sql);
+        sql = SqlParserRemoveHelper.removeNumberFilter(sql);
         return sql;
     }
 

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

@@ -2,6 +2,12 @@ package com.tencent.supersonic.common.util.jsqlparser;
 
 import lombok.extern.slf4j.Slf4j;
 
+import java.util.AbstractMap;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toMap;
+
 @Slf4j
 public class JsqlConstants {
 
@@ -9,14 +15,31 @@ public class JsqlConstants {
     public static final double HALF_YEAR = 0.5d;
     public static final int SIX_MONTH = 6;
     public static final String EQUAL = "=";
+    public static final String MINOR_THAN = "<";
+    public static final String MINOR_THAN_EQUALS = "<=";
+    public static final String GREATER_THAN = ">";
+    public static final String GREATER_THAN_EQUALS = ">=";
     public static final String MINOR_THAN_CONSTANT = " 1 < 2 ";
     public static final String MINOR_THAN_EQUALS_CONSTANT = " 1 <= 1 ";
     public static final String GREATER_THAN_CONSTANT = " 2 > 1 ";
     public static final String GREATER_THAN_EQUALS_CONSTANT = " 1 >= 1 ";
     public static final String EQUAL_CONSTANT = " 1 = 1 ";
-
     public static final String IN_CONSTANT = " 1 in (1) ";
     public static final String LIKE_CONSTANT = "1 like 1";
     public static final String IN = "IN";
+    public static final Map<String, String> rightMap = Stream.of(
+                    new AbstractMap.SimpleEntry<>("<=", "<="),
+                    new AbstractMap.SimpleEntry<>("<", "<"),
+                    new AbstractMap.SimpleEntry<>(">=", "<="),
+                    new AbstractMap.SimpleEntry<>(">", "<"),
+                    new AbstractMap.SimpleEntry<>("=", "<="))
+            .collect(toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
+    public static final Map<String, String> leftMap = Stream.of(
+                    new AbstractMap.SimpleEntry<>("<=", ">="),
+                    new AbstractMap.SimpleEntry<>("<", ">"),
+                    new AbstractMap.SimpleEntry<>(">=", "<="),
+                    new AbstractMap.SimpleEntry<>(">", "<"),
+                    new AbstractMap.SimpleEntry<>("=", ">="))
+            .collect(toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
 
 }

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

@@ -0,0 +1,6 @@
+package com.tencent.supersonic.common.util.jsqlparser;
+
+public enum SqlEditEnum {
+    NUMBER_FILTER,
+    DATEDIFF
+}

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

@@ -342,8 +342,7 @@ public class SqlParserAddHelper {
                 }
             }
         }
-        sql = SqlParserRemoveHelper.removeNumberCondition(selectStatement.toString());
+        return SqlParserRemoveHelper.removeNumberFilter(selectStatement.toString());
-        return sql;
     }
 
     public static String addHaving(String sql, List<Expression> expressionList) {

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

@@ -10,6 +10,7 @@ import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
 import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
 import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
 import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
+import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
 import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
@@ -17,7 +18,6 @@ import net.sf.jsqlparser.expression.operators.relational.InExpression;
 import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
 import net.sf.jsqlparser.expression.operators.relational.MinorThan;
 import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
-import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.statement.select.GroupByElement;
@@ -30,8 +30,8 @@ import net.sf.jsqlparser.statement.select.SelectVisitorAdapter;
 import org.springframework.util.CollectionUtils;
 
 import java.util.List;
-import java.util.Objects;
 import java.util.Set;
+import java.util.Objects;
 
 /**
  * Sql Parser remove Helper
@@ -73,8 +73,7 @@ public class SqlParserRemoveHelper {
                 removeWhereCondition(plainSelect.getWhere(), removeFieldNames);
             }
         });
-        sql = removeNumberCondition(selectStatement.toString());
+        return removeNumberFilter(selectStatement.toString());
-        return sql;
     }
 
     private static void removeWhereCondition(Expression whereExpression, Set<String> removeFieldNames) {
@@ -84,7 +83,7 @@ public class SqlParserRemoveHelper {
         removeWhereExpression(whereExpression, removeFieldNames);
     }
 
-    public static String removeNumberCondition(String sql) {
+    public static String removeNumberFilter(String sql) {
         Select selectStatement = SqlParserSelectHelper.getSelect(sql);
         if (selectStatement == null) {
             return sql;
@@ -96,10 +95,12 @@ public class SqlParserRemoveHelper {
         }
         Expression where = ((PlainSelect) selectBody).getWhere();
         Expression having = ((PlainSelect) selectBody).getHaving();
-        where = filteredWhereExpression(where);
+        try {
-        having = filteredWhereExpression(having);
+            ((PlainSelect) selectBody).setWhere(filteredExpression(where, SqlEditEnum.NUMBER_FILTER));
-        ((PlainSelect) selectBody).setWhere(where);
+            ((PlainSelect) selectBody).setHaving(filteredExpression(having, SqlEditEnum.NUMBER_FILTER));
-        ((PlainSelect) selectBody).setHaving(having);
+        } catch (Exception e) {
+            log.info("replaceFunction has an exception:{}", e.toString());
+        }
         return selectStatement.toString();
     }
 
@@ -203,8 +204,7 @@ public class SqlParserRemoveHelper {
                 removeWhereCondition(plainSelect.getHaving(), removeFieldNames);
             }
         });
-        sql = removeNumberCondition(selectStatement.toString());
+        return removeNumberFilter(selectStatement.toString());
-        return sql;
     }
 
     public static String removeWhere(String sql, List<String> fields) {
@@ -252,12 +252,12 @@ public class SqlParserRemoveHelper {
         return selectStatement.toString();
     }
 
-    private static Expression filteredWhereExpression(Expression where) {
+    public static Expression filteredExpression(Expression where, SqlEditEnum sqlEditEnum) throws Exception {
         if (Objects.isNull(where)) {
             return null;
         }
         if (where instanceof Parenthesis) {
-            Expression expression = filteredWhereExpression(((Parenthesis) where).getExpression());
+            Expression expression = filteredExpression(((Parenthesis) where).getExpression(), sqlEditEnum);
             if (expression != null) {
                 try {
                     Expression parseExpression = CCJSqlParserUtil.parseExpression("(" + expression + ")");
@@ -270,19 +270,20 @@ public class SqlParserRemoveHelper {
             }
         } else if (where instanceof AndExpression) {
             AndExpression andExpression = (AndExpression) where;
-            return filteredNumberExpression(andExpression);
+            return filteredLogicExpression(andExpression, sqlEditEnum);
         } else if (where instanceof OrExpression) {
             OrExpression orExpression = (OrExpression) where;
-            return filteredNumberExpression(orExpression);
+            return filteredLogicExpression(orExpression, sqlEditEnum);
         } else {
-            return replaceComparisonOperatorFunction(where);
+            return dealComparisonOperatorFilter(where, sqlEditEnum);
         }
         return where;
     }
 
-    private static <T extends BinaryExpression> Expression filteredNumberExpression(T binaryExpression) {
+    private static <T extends BinaryExpression> Expression filteredLogicExpression(
-        Expression leftExpression = filteredWhereExpression(binaryExpression.getLeftExpression());
+            T binaryExpression, SqlEditEnum sqlEditEnum) throws Exception {
-        Expression rightExpression = filteredWhereExpression(binaryExpression.getRightExpression());
+        Expression leftExpression = filteredExpression(binaryExpression.getLeftExpression(), sqlEditEnum);
+        Expression rightExpression = filteredExpression(binaryExpression.getRightExpression(), sqlEditEnum);
         if (leftExpression != null && rightExpression != null) {
             binaryExpression.setLeftExpression(leftExpression);
             binaryExpression.setRightExpression(rightExpression);
@@ -296,40 +297,43 @@ public class SqlParserRemoveHelper {
         }
     }
 
-    private static Expression replaceComparisonOperatorFunction(Expression expression) {
+    private static Expression dealComparisonOperatorFilter(Expression expression, SqlEditEnum sqlEditEnum) {
         if (Objects.isNull(expression)) {
             return null;
         }
-        if (expression instanceof GreaterThanEquals) {
+        if (expression instanceof GreaterThanEquals || expression instanceof GreaterThan
-            return removeSingleFilter((GreaterThanEquals) expression);
+                || expression instanceof MinorThan || expression instanceof MinorThanEquals
-        } else if (expression instanceof GreaterThan) {
+                || expression instanceof EqualsTo || expression instanceof NotEqualsTo) {
-            return removeSingleFilter((GreaterThan) expression);
+            return removeSingleFilter((ComparisonOperator) expression, sqlEditEnum);
-        } else if (expression instanceof MinorThan) {
-            return removeSingleFilter((MinorThan) expression);
-        } else if (expression instanceof MinorThanEquals) {
-            return removeSingleFilter((MinorThanEquals) expression);
-        } else if (expression instanceof EqualsTo) {
-            return removeSingleFilter((EqualsTo) expression);
-        } else if (expression instanceof NotEqualsTo) {
-            return removeSingleFilter((NotEqualsTo) expression);
         } else if (expression instanceof InExpression) {
             InExpression inExpression = (InExpression) expression;
             Expression leftExpression = inExpression.getLeftExpression();
-            return distinguishNumberCondition(leftExpression, expression);
+            return recursionBase(leftExpression, expression, sqlEditEnum);
         } else if (expression instanceof LikeExpression) {
             LikeExpression likeExpression = (LikeExpression) expression;
             Expression leftExpression = likeExpression.getLeftExpression();
-            return distinguishNumberCondition(leftExpression, expression);
+            return recursionBase(leftExpression, expression, sqlEditEnum);
         }
         return expression;
     }
 
-    private static <T extends ComparisonOperator> Expression removeSingleFilter(T comparisonExpression) {
+    private static Expression removeSingleFilter(
+            ComparisonOperator comparisonExpression, SqlEditEnum sqlEditEnum) {
         Expression leftExpression = comparisonExpression.getLeftExpression();
-        return distinguishNumberCondition(leftExpression, comparisonExpression);
+        return recursionBase(leftExpression, comparisonExpression, sqlEditEnum);
     }
 
-    public static Expression distinguishNumberCondition(Expression leftExpression, Expression expression) {
+    private static Expression recursionBase(Expression leftExpression, Expression expression, SqlEditEnum sqlEditEnum) {
+        if (sqlEditEnum.equals(SqlEditEnum.NUMBER_FILTER)) {
+            return distinguishNumberFilter(leftExpression, expression);
+        }
+        if (sqlEditEnum.equals(SqlEditEnum.DATEDIFF)) {
+            return SqlParserReplaceHelper.distinguishDateDiffFilter(leftExpression, expression);
+        }
+        return expression;
+    }
+
+    private static Expression distinguishNumberFilter(Expression leftExpression, Expression expression) {
         if (leftExpression instanceof LongValue) {
             return null;
         } else {

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

@@ -6,7 +6,9 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.ArrayList;
 
+import com.tencent.supersonic.common.util.StringUtil;
 import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.expression.Alias;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.Function;
@@ -19,6 +21,7 @@ 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.expression.operators.relational.NotEqualsTo;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Column;
 import net.sf.jsqlparser.statement.select.GroupByElement;
 import net.sf.jsqlparser.statement.select.Join;
@@ -267,29 +270,17 @@ public class SqlParserReplaceHelper {
         if (!(selectBody instanceof PlainSelect)) {
             return sql;
         }
-        List<PlainSelect> plainSelectList = new ArrayList<>();
+        Expression where = ((PlainSelect) selectBody).getWhere();
-        plainSelectList.add((PlainSelect) selectBody);
+        try {
-        List<PlainSelect> plainSelects = SqlParserSelectHelper.getPlainSelects(plainSelectList);
+            Expression expression = SqlParserRemoveHelper.filteredExpression(where, SqlEditEnum.DATEDIFF);
-        for (PlainSelect plainSelect : plainSelects) {
+            ((PlainSelect) selectBody).setWhere(expression);
-            replaceFunction(plainSelect);
+        } catch (Exception e) {
+            log.info("replaceFunction has an exception:{}", e.toString());
         }
+
         return selectStatement.toString();
     }
 
-    private static void replaceFunction(PlainSelect selectBody) {
-        PlainSelect plainSelect = selectBody;
-
-        //1. replace where dataDiff function
-        Expression where = plainSelect.getWhere();
-        FunctionReplaceVisitor visitor = new FunctionReplaceVisitor();
-        if (Objects.nonNull(where)) {
-            where.accept(visitor);
-        }
-        //2. add Waiting Expression
-        List<Expression> waitingForAdds = visitor.getWaitingForAdds();
-        addWaitingExpression(plainSelect, where, waitingForAdds);
-    }
-
     private static void replaceHavingFunction(Map<String, String> functionMap, Expression having) {
         if (Objects.nonNull(having)) {
             if (having instanceof AndExpression) {
@@ -351,21 +342,6 @@ public class SqlParserReplaceHelper {
         }
     }
 
-    private static void addWaitingExpression(PlainSelect plainSelect, Expression where,
-                                             List<Expression> waitingForAdds) {
-        if (CollectionUtils.isEmpty(waitingForAdds)) {
-            return;
-        }
-        for (Expression expression : waitingForAdds) {
-            if (where == null) {
-                plainSelect.setWhere(expression);
-            } else {
-                where = new AndExpression(where, expression);
-            }
-        }
-        plainSelect.setWhere(where);
-    }
-
     public static String replaceTable(String sql, String tableName) {
         if (StringUtils.isEmpty(tableName)) {
             return sql;
@@ -448,5 +424,46 @@ public class SqlParserReplaceHelper {
         }
         return selectStatement.toString();
     }
+
+    public static Expression distinguishDateDiffFilter(Expression leftExpression, Expression expression) {
+        if (leftExpression instanceof Function) {
+            Function function = (Function) leftExpression;
+            if (function.getName().equals(JsqlConstants.DATE_FUNCTION)) {
+                ComparisonOperator comparisonOperator = (ComparisonOperator) expression;
+                List<Expression> leftExpressions = function.getParameters().getExpressions();
+                Column field = (Column) function.getParameters().getExpressions().get(1);
+                String columnName = field.getColumnName();
+                try {
+                    String startDateValue = DateFunctionHelper.getStartDateStr(comparisonOperator, leftExpressions);
+                    String endDateValue = DateFunctionHelper.getEndDateValue(leftExpressions);
+                    String dateOperator = comparisonOperator.getStringExpression();
+                    String endDateOperator = JsqlConstants.rightMap.get(dateOperator);
+                    String startDateOperator = JsqlConstants.leftMap.get(dateOperator);
+
+                    String endDateCondExpr = columnName + endDateOperator + StringUtil.getCommaWrap(endDateValue);
+                    ComparisonOperator rightExpression = (ComparisonOperator)
+                            CCJSqlParserUtil.parseCondExpression(endDateCondExpr);
+
+                    String startDateCondExpr = columnName + StringUtil.getSpaceWrap(startDateOperator)
+                            + StringUtil.getCommaWrap(startDateValue);
+                    ComparisonOperator newLeftExpression = (ComparisonOperator)
+                            CCJSqlParserUtil.parseCondExpression(startDateCondExpr);
+
+                    AndExpression andExpression = new AndExpression(newLeftExpression, rightExpression);
+                    if (JsqlConstants.GREATER_THAN.equals(dateOperator)
+                            || JsqlConstants.GREATER_THAN_EQUALS.equals(dateOperator)) {
+                        return newLeftExpression;
+                    } else {
+                        return CCJSqlParserUtil.parseCondExpression("(" + andExpression.toString() + ")");
+                    }
+                } catch (JSQLParserException e) {
+                    log.error("JSQLParserException", e);
+                }
+            }
+            return expression;
+        } else {
+            return expression;
+        }
+    }
 }
 

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

@@ -14,7 +14,7 @@ class SqlParserRemoveHelperTest {
     void removeWhereHavingCondition() {
         String sql = "select 歌曲名 from 歌曲库 where sum(粉丝数) > 20000 and  2>1 and "
                 + "sum(播放量) > 20000 and 1=1  HAVING sum(播放量) > 20000 and 3>1";
-        sql = SqlParserRemoveHelper.removeNumberCondition(sql);
+        sql = SqlParserRemoveHelper.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.removeNumberCondition(sql);
+        sql = SqlParserRemoveHelper.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.removeNumberCondition(sql);
+        sql = SqlParserRemoveHelper.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.removeNumberCondition(sql);
+        sql = SqlParserRemoveHelper.removeNumberFilter(sql);
         System.out.println(sql);
         Assert.assertEquals(
                 "SELECT 品牌名称, 法人 FROM 互联网企业 WHERE 数据日期 = '2023-10-31' GROUP BY "

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

@@ -182,18 +182,16 @@ class SqlParserReplaceHelperTest {
 
         replaceSql = SqlParserReplaceHelper.replaceFields(replaceSql, fieldToBizName);
         replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
-
         Assert.assertEquals(
-                "SELECT song_name FROM 歌曲库 WHERE publish_date <= '2023-08-09' "
+                "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 "
+                        + " AND singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' AND song_publis_date = '2023-08-01'"
-                        + "song_publis_date = '2023-08-01' AND publish_date >= '2023-08-08' "
                         + " 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.removeNumberCondition(replaceSql);
+        replaceSql = SqlParserRemoveHelper.removeNumberFilter(replaceSql);
         Assert.assertEquals(
-                "SELECT 品牌名称 FROM 互联网企业 WHERE 注册资本 = 50000000 AND 品牌成立时间 < '2006-11-04'", replaceSql);
+                "SELECT 品牌名称 FROM 互联网企业 WHERE 品牌成立时间 < '2006-11-04' AND 注册资本 = 50000000", replaceSql);
 
         replaceSql = "select MONTH(数据日期), sum(访问次数) from 内容库产品 "
                 + "where datediff('year', 数据日期, '2023-09-03') <= 0.5 "
@@ -203,8 +201,8 @@ class SqlParserReplaceHelperTest {
         replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
-                "SELECT MONTH(sys_imp_date), sum(pv) FROM 内容库产品 WHERE sys_imp_date <= '2023-09-03' "
+                "SELECT MONTH(sys_imp_date), sum(pv) FROM 内容库产品 WHERE (sys_imp_date >= '2023-03-03' "
-                        + "AND sys_imp_date >= '2023-03-03' "
+                        + "AND sys_imp_date <= '2023-09-03')"
                         + " GROUP BY MONTH(sys_imp_date) ORDER BY sum(pv) DESC LIMIT 1", replaceSql);
 
         replaceSql = "select MONTH(数据日期), sum(访问次数) from 内容库产品 "
@@ -215,8 +213,8 @@ class SqlParserReplaceHelperTest {
         replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
-                "SELECT MONTH(sys_imp_date), sum(pv) FROM 内容库产品 WHERE sys_imp_date <= '2023-09-03' "
+                "SELECT MONTH(sys_imp_date), sum(pv) FROM 内容库产品 WHERE (sys_imp_date >= '2023-03-03' AND"
-                        + "AND sys_imp_date >= '2023-03-03' GROUP BY MONTH(sys_imp_date) HAVING sum(pv) > 1000",
+                        + " sys_imp_date <= '2023-09-03') GROUP BY MONTH(sys_imp_date) HAVING sum(pv) > 1000",
                 replaceSql);
 
         replaceSql = "select YEAR(发行日期), count(歌曲名) from 歌曲库 where YEAR(发行日期) "
@@ -251,9 +249,10 @@ class SqlParserReplaceHelperTest {
         replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
-                "SELECT song_name FROM 歌曲库 WHERE publish_date <= '2023-08-11' "
+                "SELECT song_name FROM 歌曲库 WHERE (publish_date >= '2022-08-11' "
-                        + "AND play_count > 1000000 AND sys_imp_date <= '2023-08-11' AND "
+                        + "AND publish_date <= '2023-08-11') AND play_count > 1000000 AND "
-                        + "publish_date >= '2022-08-11' AND sys_imp_date >= '2023-07-12'", replaceSql);
+                        + "(sys_imp_date >= '2023-07-12' AND sys_imp_date <= '2023-08-11')",
+                replaceSql);
 
         replaceSql = SqlParserReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('day', 发布日期, '2023-08-09') <= 1 "
@@ -262,9 +261,9 @@ class SqlParserReplaceHelperTest {
         replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
-                "SELECT song_name FROM 歌曲库 WHERE publish_date <= '2023-08-09' "
+                "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 singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' ORDER BY play_count DESC LIMIT 11",
-                        + "AND publish_date >= '2023-08-08' ORDER BY play_count DESC LIMIT 11", replaceSql);
+                replaceSql);
 
         replaceSql = SqlParserReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('year', 发布日期, '2023-08-09') = 0 "
@@ -272,9 +271,9 @@ class SqlParserReplaceHelperTest {
         replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
-                "SELECT song_name FROM 歌曲库 WHERE 1 = 1 AND singer_name = '邓紫棋'"
+                "SELECT song_name FROM 歌曲库 WHERE (publish_date >= '2023-01-01' AND publish_date <= '2023-08-09')"
-                        + " AND sys_imp_date = '2023-08-09' AND publish_date <= '2023-08-09' "
+                        + " AND singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' ORDER BY play_count DESC LIMIT 11",
-                        + "AND publish_date >= '2023-01-01' ORDER BY play_count DESC LIMIT 11", replaceSql);
+                replaceSql);
 
         replaceSql = SqlParserReplaceHelper.replaceFields(
                 "select 歌曲名 from 歌曲库 where datediff('year', 发布日期, '2023-08-09') <= 0.5 "
@@ -282,18 +281,18 @@ class SqlParserReplaceHelperTest {
         replaceSql = SqlParserReplaceHelper.replaceFunction(replaceSql);
 
         Assert.assertEquals(
-                "SELECT song_name FROM 歌曲库 WHERE publish_date <= '2023-08-09' "
+                "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' "
+                        + " AND singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09' ORDER BY play_count DESC LIMIT 11",
-                        + "AND publish_date >= '2023-02-09' ORDER BY play_count DESC LIMIT 11", replaceSql);
+                replaceSql);
 
         replaceSql = SqlParserReplaceHelper.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.removeNumberCondition(replaceSql);
+        replaceSql = SqlParserRemoveHelper.removeNumberFilter(replaceSql);
         Assert.assertEquals(
-                "SELECT song_name FROM 歌曲库 WHERE singer_name = '邓紫棋' "
+                "SELECT song_name FROM 歌曲库 WHERE publish_date <= '2023-02-09' AND"
-                        + "AND sys_imp_date = '2023-08-09' AND publish_date <= '2023-02-09'"
+                        + " singer_name = '邓紫棋' AND sys_imp_date = '2023-08-09'"
                         + " ORDER BY play_count DESC LIMIT 11", replaceSql);
 
         replaceSql = SqlParserReplaceHelper.replaceFields(