.github/workflows/open-api.yml

@@ -50,5 +50,5 @@ jobs:
         working-directory: ./open-api
         run: openapi-spec-validator rest-catalog-open-api.yaml
       - name: Validate S3 REST Signer spec
-        working-directory: ./open-api
+        working-directory: ./aws/src/main/resources
         run: openapi-spec-validator s3-signer-open-api.yaml

api/src/main/java/org/apache/iceberg/PartitionField.java

@@ -73,7 +73,7 @@ public boolean equals(Object other) {
     return sourceId == that.sourceId
         && fieldId == that.fieldId
         && name.equals(that.name)
-        && transform.equals(that.transform);
+        && transform.toString().equals(that.transform.toString());
   }
 
   @Override

api/src/main/java/org/apache/iceberg/PartitionSpec.java

@@ -419,7 +419,10 @@ Builder identity(String sourceName, String targetName) {
       checkAndAddPartitionName(targetName, sourceColumn.fieldId());
       PartitionField field =
           new PartitionField(
-              sourceColumn.fieldId(), nextFieldId(), targetName, Transforms.identity());
+              sourceColumn.fieldId(),
+              nextFieldId(),
+              targetName,
+              Transforms.identity(sourceColumn.type()));
       checkForRedundantPartitions(field);
       fields.add(field);
       return this;
@@ -433,7 +436,11 @@ public Builder year(String sourceName, String targetName) {
       checkAndAddPartitionName(targetName);
       Types.NestedField sourceColumn = findSourceColumn(sourceName);
       PartitionField field =
-          new PartitionField(sourceColumn.fieldId(), nextFieldId(), targetName, Transforms.year());
+          new PartitionField(
+              sourceColumn.fieldId(),
+              nextFieldId(),
+              targetName,
+              Transforms.year(sourceColumn.type()));
       checkForRedundantPartitions(field);
       fields.add(field);
       return this;
@@ -447,7 +454,11 @@ public Builder month(String sourceName, String targetName) {
       checkAndAddPartitionName(targetName);
       Types.NestedField sourceColumn = findSourceColumn(sourceName);
       PartitionField field =
-          new PartitionField(sourceColumn.fieldId(), nextFieldId(), targetName, Transforms.month());
+          new PartitionField(
+              sourceColumn.fieldId(),
+              nextFieldId(),
+              targetName,
+              Transforms.month(sourceColumn.type()));
       checkForRedundantPartitions(field);
       fields.add(field);
       return this;
@@ -461,7 +472,11 @@ public Builder day(String sourceName, String targetName) {
       checkAndAddPartitionName(targetName);
       Types.NestedField sourceColumn = findSourceColumn(sourceName);
       PartitionField field =
-          new PartitionField(sourceColumn.fieldId(), nextFieldId(), targetName, Transforms.day());
+          new PartitionField(
+              sourceColumn.fieldId(),
+              nextFieldId(),
+              targetName,
+              Transforms.day(sourceColumn.type()));
       checkForRedundantPartitions(field);
       fields.add(field);
       return this;
@@ -475,7 +490,11 @@ public Builder hour(String sourceName, String targetName) {
       checkAndAddPartitionName(targetName);
       Types.NestedField sourceColumn = findSourceColumn(sourceName);
       PartitionField field =
-          new PartitionField(sourceColumn.fieldId(), nextFieldId(), targetName, Transforms.hour());
+          new PartitionField(
+              sourceColumn.fieldId(),
+              nextFieldId(),
+              targetName,
+              Transforms.hour(sourceColumn.type()));
       checkForRedundantPartitions(field);
       fields.add(field);
       return this;
@@ -490,7 +509,10 @@ public Builder bucket(String sourceName, int numBuckets, String targetName) {
       Types.NestedField sourceColumn = findSourceColumn(sourceName);
       fields.add(
           new PartitionField(
-              sourceColumn.fieldId(), nextFieldId(), targetName, Transforms.bucket(numBuckets)));
+              sourceColumn.fieldId(),
+              nextFieldId(),
+              targetName,
+              Transforms.bucket(sourceColumn.type(), numBuckets)));
       return this;
     }
 
@@ -503,7 +525,10 @@ public Builder truncate(String sourceName, int width, String targetName) {
       Types.NestedField sourceColumn = findSourceColumn(sourceName);
       fields.add(
           new PartitionField(
-              sourceColumn.fieldId(), nextFieldId(), targetName, Transforms.truncate(width)));
+              sourceColumn.fieldId(),
+              nextFieldId(),
+              targetName,
+              Transforms.truncate(sourceColumn.type(), width)));
       return this;
     }
 

api/src/main/java/org/apache/iceberg/SortField.java

@@ -96,7 +96,7 @@ public boolean equals(Object other) {
     }
 
     SortField that = (SortField) other;
-    return transform.equals(that.transform)
+    return transform.toString().equals(that.transform.toString())
         && sourceId == that.sourceId
         && direction == that.direction
         && nullOrder == that.nullOrder;

api/src/main/java/org/apache/iceberg/UnboundPartitionSpec.java

@@ -22,6 +22,7 @@
 import org.apache.iceberg.relocated.com.google.common.collect.Lists;
 import org.apache.iceberg.transforms.Transform;
 import org.apache.iceberg.transforms.Transforms;
+import org.apache.iceberg.types.Type;
 
 public class UnboundPartitionSpec {
 
@@ -53,10 +54,17 @@ private PartitionSpec.Builder copyToBuilder(Schema schema) {
     PartitionSpec.Builder builder = PartitionSpec.builderFor(schema).withSpecId(specId);
 
     for (UnboundPartitionField field : fields) {
+      Type fieldType = schema.findType(field.sourceId);
+      Transform<?, ?> transform;
+      if (fieldType != null) {
+        transform = Transforms.fromString(fieldType, field.transform.toString());
+      } else {
+        transform = Transforms.fromString(field.transform.toString());
+      }
       if (field.partitionId != null) {
-        builder.add(field.sourceId, field.partitionId, field.name, field.transform);
+        builder.add(field.sourceId, field.partitionId, field.name, transform);
       } else {
-        builder.add(field.sourceId, field.name, field.transform);
+        builder.add(field.sourceId, field.name, transform);
       }
     }
 

api/src/main/java/org/apache/iceberg/transforms/Dates.java

@@ -18,9 +18,6 @@
  */
 package org.apache.iceberg.transforms;
 
-import java.time.Instant;
-import java.time.LocalDate;
-import java.time.ZoneOffset;
 import java.time.temporal.ChronoUnit;
 import org.apache.iceberg.expressions.BoundPredicate;
 import org.apache.iceberg.expressions.BoundTransform;
@@ -30,6 +27,7 @@
 import org.apache.iceberg.relocated.com.google.common.base.Preconditions;
 import org.apache.iceberg.types.Type;
 import org.apache.iceberg.types.Types;
+import org.apache.iceberg.util.DateTimeUtil;
 import org.apache.iceberg.util.SerializableFunction;
 
 enum Dates implements Transform<Integer, Integer> {
@@ -50,24 +48,19 @@ public Integer apply(Integer days) {
         return null;
       }
 
-      if (granularity == ChronoUnit.DAYS) {
-        return days;
-      }
-
-      if (days >= 0) {
-        LocalDate date = EPOCH.plusDays(days);
-        return (int) granularity.between(EPOCH, date);
-      } else {
-        // add 1 day to the value to account for the case where there is exactly 1 unit between the
-        // date and epoch because the result will always be decremented.
-        LocalDate date = EPOCH.plusDays(days + 1);
-        return (int) granularity.between(EPOCH, date) - 1;
+      switch (granularity) {
+        case YEARS:
+          return DateTimeUtil.daysToYears(days);
+        case MONTHS:
+          return DateTimeUtil.daysToMonths(days);
+        case DAYS:
+          return days;
+        default:
+          throw new UnsupportedOperationException("Unsupported time unit: " + granularity);
       }
     }
   }
 
-  private static final LocalDate EPOCH =
-      Instant.ofEpochSecond(0).atOffset(ZoneOffset.UTC).toLocalDate();
   private final ChronoUnit granularity;
   private final String name;
   private final Apply apply;

api/src/main/java/org/apache/iceberg/transforms/ProjectionUtil.java

@@ -231,7 +231,9 @@ static <S, T> UnboundPredicate<T> truncateArrayStrict(
   static <T> UnboundPredicate<T> projectTransformPredicate(
       Transform<?, T> transform, String partitionName, BoundPredicate<?> pred) {
     if (pred.term() instanceof BoundTransform
-        && transform.equals(((BoundTransform<?, ?>) pred.term()).transform())) {
+        && transform
+            .toString()
+            .equals(((BoundTransform<?, ?>) pred.term()).transform().toString())) {
       // the bound value must be a T because the transform matches
       return (UnboundPredicate<T>) removeTransform(partitionName, pred);
     }

api/src/main/java/org/apache/iceberg/transforms/Timestamps.java

@@ -18,9 +18,6 @@
  */
 package org.apache.iceberg.transforms;
 
-import java.time.Instant;
-import java.time.OffsetDateTime;
-import java.time.ZoneOffset;
 import java.time.temporal.ChronoUnit;
 import org.apache.iceberg.expressions.BoundPredicate;
 import org.apache.iceberg.expressions.BoundTransform;
@@ -30,6 +27,7 @@
 import org.apache.iceberg.relocated.com.google.common.base.Preconditions;
 import org.apache.iceberg.types.Type;
 import org.apache.iceberg.types.Types;
+import org.apache.iceberg.util.DateTimeUtil;
 import org.apache.iceberg.util.SerializableFunction;
 
 enum Timestamps implements Transform<Long, Integer> {
@@ -51,27 +49,21 @@ public Integer apply(Long timestampMicros) {
         return null;
       }
 
-      if (timestampMicros >= 0) {
-        OffsetDateTime timestamp =
-            Instant.ofEpochSecond(
-                    Math.floorDiv(timestampMicros, 1_000_000),
-                    Math.floorMod(timestampMicros, 1_000_000) * 1000)
-                .atOffset(ZoneOffset.UTC);
-        return (int) granularity.between(EPOCH, timestamp);
-      } else {
-        // add 1 micro to the value to account for the case where there is exactly 1 unit between
-        // the timestamp and epoch because the result will always be decremented.
-        OffsetDateTime timestamp =
-            Instant.ofEpochSecond(
-                    Math.floorDiv(timestampMicros, 1_000_000),
-                    Math.floorMod(timestampMicros + 1, 1_000_000) * 1000)
-                .atOffset(ZoneOffset.UTC);
-        return (int) granularity.between(EPOCH, timestamp) - 1;
+      switch (granularity) {
+        case YEARS:
+          return DateTimeUtil.microsToYears(timestampMicros);
+        case MONTHS:
+          return DateTimeUtil.microsToMonths(timestampMicros);
+        case DAYS:
+          return DateTimeUtil.microsToDays(timestampMicros);
+        case HOURS:
+          return DateTimeUtil.microsToHours(timestampMicros);
+        default:
+          throw new UnsupportedOperationException("Unsupported time unit: " + granularity);
       }
     }
   }
 
-  private static final OffsetDateTime EPOCH = Instant.ofEpochSecond(0).atOffset(ZoneOffset.UTC);
   private final ChronoUnit granularity;
   private final String name;
   private final SerializableFunction<Long, Integer> apply;

api/src/main/java/org/apache/iceberg/transforms/Transforms.java

@@ -46,7 +46,7 @@ private Transforms() {}
       int parsedWidth = Integer.parseInt(widthMatcher.group(2));
       if (name.equalsIgnoreCase("truncate")) {
         return Truncate.get(parsedWidth);
-      } else if (name.equals("bucket")) {
+      } else if (name.equalsIgnoreCase("bucket")) {
         return Bucket.get(parsedWidth);
       }
     }
@@ -75,7 +75,7 @@ private Transforms() {}
       int parsedWidth = Integer.parseInt(widthMatcher.group(2));
       if (name.equalsIgnoreCase("truncate")) {
         return (Transform<?, ?>) Truncate.get(type, parsedWidth);
-      } else if (name.equals("bucket")) {
+      } else if (name.equalsIgnoreCase("bucket")) {
         return (Transform<?, ?>) Bucket.get(type, parsedWidth);
       }
     }

api/src/main/java/org/apache/iceberg/types/Comparators.java

@@ -44,7 +44,7 @@ private Comparators() {}
           .put(Types.StringType.get(), Comparators.charSequences())
           .put(Types.UUIDType.get(), Comparator.naturalOrder())
           .put(Types.BinaryType.get(), Comparators.unsignedBytes())
-          .build();
+          .buildOrThrow();
 
   public static Comparator<StructLike> forType(Types.StructType struct) {
     return new StructLikeComparator(struct);

api/src/main/java/org/apache/iceberg/types/Types.java

@@ -51,7 +51,7 @@ private Types() {}
           .put(StringType.get().toString(), StringType.get())
           .put(UUIDType.get().toString(), UUIDType.get())
           .put(BinaryType.get().toString(), BinaryType.get())
-          .build();
+          .buildOrThrow();
 
   private static final Pattern FIXED = Pattern.compile("fixed\\[(\\d+)\\]");
   private static final Pattern DECIMAL = Pattern.compile("decimal\\((\\d+),\\s+(\\d+)\\)");

core/src/main/java/org/apache/iceberg/util/DateTimeUtil.java → api/src/main/java/org/apache/iceberg/util/DateTimeUtil.java

@@ -34,6 +34,7 @@ private DateTimeUtil() {}
   public static final OffsetDateTime EPOCH = Instant.ofEpochSecond(0).atOffset(ZoneOffset.UTC);
   public static final LocalDate EPOCH_DAY = EPOCH.toLocalDate();
   public static final long MICROS_PER_MILLIS = 1000L;
+  public static final long MICROS_PER_SECOND = 1_000_000L;
 
   public static LocalDate dateFromDays(int daysFromEpoch) {
     return ChronoUnit.DAYS.addTo(EPOCH_DAY, daysFromEpoch);
@@ -133,4 +134,58 @@ public static long isoTimestampToMicros(String timestampString) {
     return microsFromTimestamp(
         LocalDateTime.parse(timestampString, DateTimeFormatter.ISO_LOCAL_DATE_TIME));
   }
+
+  public static int daysToYears(int days) {
+    return convertDays(days, ChronoUnit.YEARS);
+  }
+
+  public static int daysToMonths(int days) {
+    return convertDays(days, ChronoUnit.MONTHS);
+  }
+
+  private static int convertDays(int days, ChronoUnit granularity) {
+    if (days >= 0) {
+      LocalDate date = EPOCH_DAY.plusDays(days);
+      return (int) granularity.between(EPOCH_DAY, date);
+    } else {
+      // add 1 day to the value to account for the case where there is exactly 1 unit between the
+      // date and epoch because the result will always be decremented.
+      LocalDate date = EPOCH_DAY.plusDays(days + 1);
+      return (int) granularity.between(EPOCH_DAY, date) - 1;
+    }
+  }
+
+  public static int microsToYears(long micros) {
+    return convertMicros(micros, ChronoUnit.YEARS);
+  }
+
+  public static int microsToMonths(long micros) {
+    return convertMicros(micros, ChronoUnit.MONTHS);
+  }
+
+  public static int microsToDays(long micros) {
+    return convertMicros(micros, ChronoUnit.DAYS);
+  }
+
+  public static int microsToHours(long micros) {
+    return convertMicros(micros, ChronoUnit.HOURS);
+  }
+
+  private static int convertMicros(long micros, ChronoUnit granularity) {
+    if (micros >= 0) {
+      long epochSecond = Math.floorDiv(micros, MICROS_PER_SECOND);
+      long nanoAdjustment = Math.floorMod(micros, MICROS_PER_SECOND) * 1000;
+      return (int) granularity.between(EPOCH, toOffsetDateTime(epochSecond, nanoAdjustment));
+    } else {
+      // add 1 micro to the value to account for the case where there is exactly 1 unit between
+      // the timestamp and epoch because the result will always be decremented.
+      long epochSecond = Math.floorDiv(micros, MICROS_PER_SECOND);
+      long nanoAdjustment = Math.floorMod(micros + 1, MICROS_PER_SECOND) * 1000;
+      return (int) granularity.between(EPOCH, toOffsetDateTime(epochSecond, nanoAdjustment)) - 1;
+    }
+  }
+
+  private static OffsetDateTime toOffsetDateTime(long epochSecond, long nanoAdjustment) {
+    return Instant.ofEpochSecond(epochSecond, nanoAdjustment).atOffset(ZoneOffset.UTC);
+  }
 }

api/src/test/java/org/apache/iceberg/expressions/TestExpressionUtil.java

@@ -538,7 +538,7 @@ public void testSanitizeTimestamptzFuture() {
 
   @Test
   public void testSanitizeDateToday() {
-    String today = LocalDate.now().toString();
+    String today = LocalDate.now(ZoneOffset.UTC).toString();
 
     assertEquals(
         Expressions.equal("test", "(date-today)"),
@@ -558,7 +558,7 @@ public void testSanitizeDateToday() {
 
   @Test
   public void testSanitizeDateLastWeek() {
-    String lastWeek = LocalDate.now().minusWeeks(1).toString();
+    String lastWeek = LocalDate.now(ZoneOffset.UTC).minusWeeks(1).toString();
 
     assertEquals(
         Expressions.equal("test", "(date-7-days-ago)"),
@@ -578,7 +578,7 @@ public void testSanitizeDateLastWeek() {
 
   @Test
   public void testSanitizeDateNextWeek() {
-    String nextWeek = LocalDate.now().plusWeeks(1).toString();
+    String nextWeek = LocalDate.now(ZoneOffset.UTC).plusWeeks(1).toString();
 
     assertEquals(
         Expressions.equal("test", "(date-7-days-from-now)"),