rdblue commented on code in PR #18853:
URL: https://github.com/apache/iceberg/pull/18853#discussion_r4518561524


##########
core/src/main/java/org/apache/iceberg/V4Metadata.java:
##########
@@ -541,4 +548,730 @@ public Long pos() {
       return null;
     }
   }
+
+  /** Base wrapper used to write a {@link TrackedFile} using the v4 tracked 
file schema. */
+  private static void checkNullSequenceNumbers(TrackedFile file, Tracking 
tracking) {
+    // null sequence numbers are inherited from the commit: ADDED entries 
inherit both and
+    // MODIFIED entries inherit only the data sequence number
+    EntryStatus status = tracking.status();
+    Preconditions.checkState(
+        tracking.dataSequenceNumber() != null
+            || status == EntryStatus.ADDED
+            || status == EntryStatus.MODIFIED,
+        "Cannot write null data sequence number for status %s (must be ADDED 
or MODIFIED): %s",
+        status,
+        file.location());
+    Preconditions.checkState(
+        tracking.fileSequenceNumber() != null || status == EntryStatus.ADDED,
+        "Cannot write null file sequence number for status %s (must be ADDED): 
%s",
+        status,
+        file.location());
+  }
+
+  private abstract static class TrackedFileWrapper implements TrackedFile, 
StructLike {
+    private static final int SIZE =
+        TrackedFile.schema(Types.StructType.of(), 
Types.StructType.of()).columns().size();
+
+    private final Map<Integer, PartitionSpec> specsById;
+    private final Map<Integer, StructProjection> partitionProjections;
+    private final ContentStatsWrapper contentStats;
+
+    private TrackedFile wrapped = null;
+    private Integer specId = null;
+    private TrackingWrapper tracking = null;
+    private ManifestInfoWrapper manifestInfo = null;
+
+    private TrackedFileWrapper(
+        Map<Integer, PartitionSpec> specsById, Types.StructType 
contentStatsType) {
+      this.specsById = specsById;
+      this.partitionProjections = partitionProjections(specsById);
+      this.contentStats = new ContentStatsWrapper(contentStatsType);
+    }
+
+    protected void wrapInternal(
+        TrackedFile file, TrackingWrapper newTracking, ManifestInfoWrapper 
newManifestInfo) {
+      Integer fileSpecId = file.specId();
+      PartitionSpec spec = fileSpecId != null ? specsById.get(fileSpecId) : 
null;
+      Preconditions.checkArgument(
+          fileSpecId == null || spec != null,
+          "Cannot find partition spec for spec ID: %s",
+          fileSpecId);
+
+      this.wrapped = file;
+      // v4 metadata stores a null spec ID and partition for unpartitioned 
files
+      this.specId = spec != null && !spec.fields().isEmpty() ? fileSpecId : 
null;
+      this.tracking = newTracking;
+      this.manifestInfo = newManifestInfo;
+    }
+
+    @Override
+    public int size() {
+      return SIZE;
+    }
+
+    @Override
+    public <T> void set(int pos, T value) {
+      throw new UnsupportedOperationException("Cannot modify a read-only 
tracked file");
+    }
+
+    @Override
+    public <T> T get(int pos, Class<T> javaClass) {
+      return javaClass.cast(get(pos));
+    }
+
+    private Object get(int pos) {
+      return switch (pos) {
+        case 0 -> tracking;
+        case 1 -> wrapped.contentType().id();
+        case 2 -> wrapped.location();
+        case 3 -> wrapped.fileFormat().toString();
+        case 4 -> wrapped.recordCount();
+        case 5 -> wrapped.fileSizeInBytes();
+        case 6 -> specId;
+        case 7 -> unionPartition();
+        case 8 -> wrapped.contentStats() != null ? 
contentStats.wrap(wrapped.contentStats()) : null;
+        case 9 -> wrapped.sortOrderId();
+        case 10 -> wrapped.deletionVector();

Review Comment:
   `TrackedFile.deletionVector()` returns an interface, `DeletionVector`. There 
is no type guarantee that the implementation is `DeletionVectorStruct`, it just 
happens to be in non-test code right now. And there are tests for 
`TrackedFileStruct` that use mocks instead of `DeletionVectorStruct`.
   
   I think this choice depends on whether `TrackedFile` will ever be public and 
if we are okay with the risk that some implementation implements `StructLike` 
and changes the order of fields.
   
   I don't see a compelling reason not to also wrap these. These wrappers are 
hardly ever touched and are small. I prefer to have no risk by adding these.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to