branch-4.1: [fix](planner) align legacy literal compareLiteral with Nereids ComparableLiteral semantics (#63481) (#63874)

pick from master #63481

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: csun5285

fe/fe-core/src/main/java/org/apache/doris/analysis/IPv4Literal.java

@@ -127,7 +127,36 @@ public boolean isMinValue() {
 
     @Override
     public int compareLiteral(LiteralExpr expr) {
-        return 0;
+        if (expr instanceof PlaceHolderExpr) {
+            return this.compareLiteral(((PlaceHolderExpr) expr).getLiteral());
+        }
+        if (expr instanceof NullLiteral) {
+            return 1;
+        }
+        if (expr == MaxLiteral.MAX_VALUE) {
+            return -1;
+        }
+        if (expr instanceof IPv4Literal) {
+            return Long.compare(this.value, ((IPv4Literal) expr).value);
+        }
+        throw new RuntimeException("Cannot compare two values with different data types: "
+                + this + " (" + this.type + ") vs " + expr + " (" + expr.type + ")");
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof IPv4Literal)) {
+            return false;
+        }
+        return this.value == ((IPv4Literal) obj).value;
+    }
+
+    @Override
+    public int hashCode() {
+        return 31 * super.hashCode() + Long.hashCode(value);
     }
 
     @Override

fe/fe-core/src/main/java/org/apache/doris/analysis/IPv6Literal.java

@@ -27,6 +27,7 @@
 import org.apache.doris.thrift.TIPv6Literal;
 
 import com.google.gson.annotations.SerializedName;
+import com.googlecode.ipv6.IPv6Address;
 
 import java.util.regex.Pattern;
 
@@ -108,7 +109,49 @@ public boolean isMinValue() {
 
     @Override
     public int compareLiteral(LiteralExpr expr) {
-        return 0;
+        if (expr instanceof PlaceHolderExpr) {
+            return this.compareLiteral(((PlaceHolderExpr) expr).getLiteral());
+        }
+        if (expr instanceof NullLiteral) {
+            return 1;
+        }
+        if (expr == MaxLiteral.MAX_VALUE) {
+            return -1;
+        }
+        if (expr instanceof IPv6Literal) {
+            return parseAddress(this.value).compareTo(parseAddress(((IPv6Literal) expr).value));
+        }
+        throw new RuntimeException("Cannot compare two values with different data types: "
+                + this + " (" + this.type + ") vs " + expr + " (" + expr.type + ")");
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof IPv6Literal)) {
+            return false;
+        }
+        return parseAddress(this.value).equals(parseAddress(((IPv6Literal) obj).value));
+    }
+
+    @Override
+    public int hashCode() {
+        return 31 * super.hashCode() + parseAddress(this.value).hashCode();
+    }
+
+    // IPv6Address keeps the full 128-bit value for IPv4-mapped literals
+    // (e.g. ::ffff:0.0.0.1, ::ffff:0:1) and matches the canonicalization used by
+    // the Nereids IPv6Literal, so dedup/range logic stays consistent across both
+    // planners. InetAddress.getByName would otherwise collapse mapped forms to a
+    // 4-byte Inet4Address and hash-collide with addresses like ::1.
+    private static IPv6Address parseAddress(String ipv6) {
+        try {
+            return IPv6Address.fromString(ipv6);
+        } catch (Exception e) {
+            throw new IllegalStateException("Invalid IPv6 literal: " + ipv6, e);
+        }
     }
 
     @Override

fe/fe-core/src/main/java/org/apache/doris/analysis/MapLiteral.java

@@ -143,7 +143,7 @@ public boolean isMinValue() {
 
     @Override
     public int compareLiteral(LiteralExpr expr) {
-        return 0;
+        throw new RuntimeException("Not support comparison between MAP literals");
     }
 
     @Override

fe/fe-core/src/main/java/org/apache/doris/analysis/StructLiteral.java

@@ -163,7 +163,7 @@ public boolean isMinValue() {
 
     @Override
     public int compareLiteral(LiteralExpr expr) {
-        return 0;
+        throw new RuntimeException("Not support comparison between STRUCT literals");
     }
 
     @Override

fe/fe-core/src/main/java/org/apache/doris/analysis/TimeV2Literal.java

@@ -103,7 +103,27 @@ public boolean isMinValue() {
 
     @Override
     public int compareLiteral(LiteralExpr expr) {
-        return 0;
+        throw new RuntimeException("Not support comparison between TIMEV2 literals");
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof TimeV2Literal)) {
+            return false;
+        }
+        return Double.compare(this.getValue(), ((TimeV2Literal) obj).getValue()) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        // Must mirror equals(), which only compares getValue(). super.hashCode()
+        // mixes in the ScalarType, so TIMEV2(0) and TIMEV2(6) would otherwise
+        // produce different hashes for the same logical time value and break the
+        // equals/hashCode contract — predicate dedup would bucket them apart.
+        return Double.hashCode(getValue());
     }
 
     @Override