prepare version 0.48.8-public

Author: dingxin-tech

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.48.8-public] - 2024-08-12
+
+### Enhancement
+- Introduced internal validation of compound predicate expressions, fixed logic when handling
+  invalid or always true/false predicates, enhanced test coverage, and ensured stability and
+  accuracy in complex query optimization.
+
 ## [0.48.7-public] - 2024-08-07
 ### Enhancements
 - **TableTunnel Configuration Optimization**: Introduced the `tags` attribute to `TableTunnel Configuration`, enabling users to attach custom tags to tunnel operations for enhanced logging and management. These tags are recorded in the tenant-level `information schema`.

CHANGELOG_CN.md

@@ -1,4 +1,8 @@
 # 更新日志
+## [0.48.8-public] - 2024-08-12
+### 增强
+- 引入了对复合谓词表达式的内部验证，修复了处理无效或总是真/假谓词时的逻辑，增强了测试覆盖，确保了在复杂查询优化中的稳定性和准确性。
+
 
 ## [0.48.7-public] - 2024-08-07
 

odps-sdk/odps-sdk-table-api/src/main/java/com/aliyun/odps/table/optimizer/predicate/CompoundPredicate.java

@@ -5,7 +5,6 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import com.aliyun.odps.utils.StringUtils;
 import com.google.common.collect.ImmutableList;
 
 /**
@@ -41,8 +40,7 @@ public CompoundPredicate(Operator logicalOperator) {
   public CompoundPredicate(Operator logicalOperator, List<Predicate> predicates) {
     super(PredicateType.COMPOUND);
     this.logicalOperator = logicalOperator;
-    this.predicates =
-        predicates.stream().filter(this::validatePredicate).collect(Collectors.toList());
+    this.predicates = predicates;
     if (logicalOperator == Operator.NOT && predicates.size() > 1) {
       throw new IllegalArgumentException("NOT operator should only have one operand");
     }
@@ -63,9 +61,7 @@ public static CompoundPredicate not(Predicate predicates) {
   }
 
   public void addPredicate(Predicate predicate) {
-    if (validatePredicate(predicate)) {
-      predicates.add(predicate);
-    }
+    predicates.add(predicate);
   }
 
   @Override
@@ -79,8 +75,11 @@ public String toString() {
 
     // 对于 NOT 运算符，我们确保只有一个操作数
     if (logicalOperator == Operator.NOT) {
-      sb.append(opStr).append(" ");
       Predicate predicate = predicates.get(0);
+      if (!validatePredicate(predicate)) {
+        return Predicate.NO_PREDICATE.toString();
+      }
+      sb.append(opStr).append(" ");
       if (predicate instanceof CompoundPredicate) {
         sb.append('(').append(predicate).append(')');
       } else {
@@ -91,6 +90,17 @@ public String toString() {
 
     for (int i = 0; i < predicates.size(); i++) {
       Predicate currentPredicate = predicates.get(i);
+      if (!validatePredicate(currentPredicate)) {
+        if (logicalOperator == Operator.OR) {
+          // A or true = true
+          // 对于 or 谓词，如果有任意谓词是 true，则结果为 true
+          return Predicate.NO_PREDICATE.toString();
+        } else {
+          // A and true = A
+          // 对于 and 谓词，跳过子谓词为 true 的谓词
+          continue;
+        }
+      }
       if (currentPredicate instanceof CompoundPredicate
           && ((CompoundPredicate) currentPredicate).logicalOperator != this.logicalOperator) {
         sb.append('(').append(currentPredicate).append(')');