API: Simplify sanitization of literals in predicates (#15224)

Author: Kontinuation

api/src/main/java/org/apache/iceberg/expressions/ExpressionUtil.java

@@ -36,7 +36,6 @@
 import org.apache.iceberg.relocated.com.google.common.collect.ImmutableSet;
 import org.apache.iceberg.relocated.com.google.common.collect.Lists;
 import org.apache.iceberg.transforms.Transforms;
-import org.apache.iceberg.types.Type;
 import org.apache.iceberg.types.Types;
 import org.apache.iceberg.util.DateTimeUtil;
 import org.apache.iceberg.variants.PhysicalType;
@@ -305,15 +304,13 @@ public <T> Expression predicate(BoundPredicate<T> pred) {
       } else if (pred.isLiteralPredicate()) {
         BoundLiteralPredicate<T> bound = (BoundLiteralPredicate<T>) pred;
         return new UnboundPredicate<>(
-            pred.op(),
-            unbind(pred.term()),
-            (T) sanitize(bound.term().type(), bound.literal(), now, today));
+            pred.op(), unbind(pred.term()), (T) sanitize(bound.literal(), now, today));
       } else if (pred.isSetPredicate()) {
         BoundSetPredicate<T> bound = (BoundSetPredicate<T>) pred;
         Iterable<T> iter =
             () ->
                 bound.literalSet().stream()
-                    .map(lit -> (T) sanitize(bound.term().type(), lit, now, today))
+                    .map(lit -> (T) sanitize((Literal<?>) lit, now, today))
                     .iterator();
         return new UnboundPredicate<>(pred.op(), unbind(pred.term()), iter);
       }
@@ -390,7 +387,7 @@ public String or(String leftResult, String rightResult) {
     }
 
     private String value(BoundLiteralPredicate<?> pred) {
-      return sanitize(pred.term().type(), pred.literal().value(), nowMicros, today);
+      return sanitize(pred.literal(), nowMicros, today);
     }
 
     @Override
@@ -422,7 +419,7 @@ public <T> String predicate(BoundPredicate<T> pred) {
               + " IN "
               + abbreviateValues(
                       pred.asSetPredicate().literalSet().stream()
-                          .map(lit -> sanitize(pred.term().type(), lit, nowMicros, today))
+                          .map(lit -> sanitize((Literal<?>) lit, nowMicros, today))
                           .collect(Collectors.toList()))
                   .stream()
                   .collect(Collectors.joining(", ", "(", ")"));
@@ -431,7 +428,7 @@ public <T> String predicate(BoundPredicate<T> pred) {
               + " NOT IN "
               + abbreviateValues(
                       pred.asSetPredicate().literalSet().stream()
-                          .map(lit -> sanitize(pred.term().type(), lit, nowMicros, today))
+                          .map(lit -> sanitize((Literal<?>) lit, nowMicros, today))
                           .collect(Collectors.toList()))
                   .stream()
                   .collect(Collectors.joining(", ", "(", ")"));
@@ -518,44 +515,6 @@ private static List<String> abbreviateValues(List<String> sanitizedValues) {
     return sanitizedValues;
   }
 
-  private static String sanitize(Type type, Literal<?> lit, long now, int today) {
-    return sanitize(type, lit.value(), now, today);
-  }
-
-  private static String sanitize(Type type, Object value, long now, int today) {
-    switch (type.typeId()) {
-      case INTEGER:
-      case LONG:
-        return sanitizeNumber((Number) value, "int");
-      case FLOAT:
-      case DOUBLE:
-        return sanitizeNumber((Number) value, "float");
-      case DATE:
-        return sanitizeDate((int) value, today);
-      case TIME:
-        return "(time)";
-      case TIMESTAMP:
-        return sanitizeTimestamp((long) value, now);
-      case TIMESTAMP_NANO:
-        return sanitizeTimestamp(DateTimeUtil.nanosToMicros((long) value / 1000), now);
-      case STRING:
-        return sanitizeString((CharSequence) value, now, today);
-      case VARIANT:
-        return sanitizeVariant((Variant) value, now, today);
-      case UNKNOWN:
-        return "(unknown)";
-      case BOOLEAN:
-      case UUID:
-      case DECIMAL:
-      case FIXED:
-      case BINARY:
-        // for boolean, uuid, decimal, fixed, unknown, and binary, match the string result
-        return sanitizeSimpleString(value.toString());
-    }
-    throw new UnsupportedOperationException(
-        String.format("Cannot sanitize value for unsupported type %s: %s", type, value));
-  }
-
   private static String sanitize(Literal<?> literal, long now, int today) {
     if (literal instanceof Literals.StringLiteral) {
       return sanitizeString(((Literals.StringLiteral) literal).value(), now, today);