[BugFix] Fix oom problem in complex type prune (backport #49113) (#49133

)

Co-authored-by: Smith Cruise <[email protected]>

fe/fe-core/src/main/java/com/starrocks/catalog/ComplexTypeAccessGroup.java

@@ -14,25 +14,19 @@
 
 package com.starrocks.catalog;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 
+// Record ColumnRefOperator's each ComplexTypeAccessPaths
+// We have to use HashSet to deduplicate same ComplexTypeAccessPaths, it can avoid oom problem
 public class ComplexTypeAccessGroup {
-    private final List<ComplexTypeAccessPaths> accessPaths = new ArrayList<>();
-
-    public int size() {
-        return accessPaths.size();
-    }
-
-    public ComplexTypeAccessPaths get(int idx) {
-        return accessPaths.get(idx);
-    }
+    private final Set<ComplexTypeAccessPaths> accessPaths = new HashSet<>();
 
     public void addAccessPaths(ComplexTypeAccessPaths complexTypeAccessPaths) {
         accessPaths.add(complexTypeAccessPaths);
     }
 
-    public List<ComplexTypeAccessPaths> getAccessGroup() {
+    public Set<ComplexTypeAccessPaths> getAccessGroup() {
         return accessPaths;
     }
 }

fe/fe-core/src/main/java/com/starrocks/catalog/ComplexTypeAccessPath.java

@@ -14,6 +14,8 @@
 
 package com.starrocks.catalog;
 
+import java.util.Objects;
+
 public class ComplexTypeAccessPath {
     private final ComplexTypeAccessPathType accessPathType;
 
@@ -36,4 +38,25 @@ public ComplexTypeAccessPathType getAccessPathType() {
     public String getStructSubfieldName() {
         return this.structSubfieldName;
     }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof ComplexTypeAccessPath)) {
+            return false;
+        }
+
+        ComplexTypeAccessPath that = (ComplexTypeAccessPath) o;
+        return accessPathType == that.accessPathType &&
+                Objects.equals(structSubfieldName, that.structSubfieldName);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Objects.hashCode(accessPathType);
+        result = 31 * result + Objects.hashCode(structSubfieldName);
+        return result;
+    }
 }

fe/fe-core/src/main/java/com/starrocks/catalog/ComplexTypeAccessPaths.java

@@ -14,12 +14,16 @@
 
 package com.starrocks.catalog;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 
+import java.util.Objects;
+
 public class ComplexTypeAccessPaths {
     private final ImmutableList<ComplexTypeAccessPath> accessPaths;
 
     public ComplexTypeAccessPaths(ImmutableList<ComplexTypeAccessPath> accessPaths) {
+        Preconditions.checkNotNull(accessPaths, "accessPaths can't be null");
         this.accessPaths = accessPaths;
     }
 
@@ -38,4 +42,22 @@ public boolean isEmpty() {
     public ImmutableList<ComplexTypeAccessPath> getAccessPaths() {
         return accessPaths;
     }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof ComplexTypeAccessPaths)) {
+            return false;
+        }
+
+        ComplexTypeAccessPaths that = (ComplexTypeAccessPaths) o;
+        return Objects.equals(accessPaths, that.accessPaths);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(accessPaths);
+    }
 }

fe/fe-core/src/main/java/com/starrocks/sql/optimizer/rule/tree/PruneComplexTypeUtil.java

@@ -94,10 +94,11 @@ public void addAccessPaths(ColumnRefOperator columnRefOperator, ComplexTypeAcces
         public void addAccessPaths(ColumnRefOperator columnRefOperator,
                                    ComplexTypeAccessPaths curAccessPaths,
                                    ComplexTypeAccessGroup visitedAccessGroup) {
-            int size = visitedAccessGroup.size();
-            // We should we below loop to avoid ConcurrentModificationException
-            for (int i = 0; i < size; i++) {
-                addAccessPaths(columnRefOperator, concatAccessPaths(curAccessPaths, visitedAccessGroup.get(i)));
+            // We should copy it first to avoid ConcurrentModificationException
+            ImmutableList<ComplexTypeAccessPaths> accessGroup = ImmutableList.<ComplexTypeAccessPaths>builder().addAll(
+                    visitedAccessGroup.getAccessGroup()).build();
+            for (ComplexTypeAccessPaths complexTypeAccessPaths : accessGroup) {
+                addAccessPaths(columnRefOperator, concatAccessPaths(curAccessPaths, complexTypeAccessPaths));
             }
         }