rdblue commented on code in PR #16958: URL: https://github.com/apache/iceberg/pull/16958#discussion_r3648460415
########## core/src/test/java/org/apache/iceberg/TestV4ManifestReader.java: ########## @@ -0,0 +1,909 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.iceberg; + +import static org.apache.iceberg.types.Types.NestedField.optional; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.file.Path; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import org.apache.iceberg.expressions.Expressions; +import org.apache.iceberg.inmemory.InMemoryOutputFile; +import org.apache.iceberg.io.FileAppender; +import org.apache.iceberg.io.FileIO; +import org.apache.iceberg.io.InputFile; +import org.apache.iceberg.io.OutputFile; +import org.apache.iceberg.metrics.DefaultMetricsContext; +import org.apache.iceberg.metrics.ScanMetrics; +import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList; +import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap; +import org.apache.iceberg.relocated.com.google.common.collect.Lists; +import org.apache.iceberg.transforms.Transforms; +import org.apache.iceberg.types.Comparators; +import org.apache.iceberg.types.TypeUtil; +import org.apache.iceberg.types.Types; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.FieldSource; + +public class TestV4ManifestReader { + private static final long SNAPSHOT_ID = 42L; + private static final int FORMAT_VERSION_V4 = 4; + private static final long RECORD_COUNT = 100L; + private static final long FILE_SIZE_IN_BYTES = 1024L; + private static final int SORT_ORDER_ID = 1; + private static final String DV_LOCATION = "s3://bucket/dv.puffin"; + private static final long DV_OFFSET = 100L; + private static final long DV_SIZE_IN_BYTES = 50L; + private static final long DV_CARDINALITY = 5L; + + private static final Schema TABLE_SCHEMA = + new Schema( + optional(1, "id", Types.IntegerType.get()), optional(2, "data", Types.StringType.get())); + private static final PartitionSpec SPEC = + PartitionSpec.builderFor(TABLE_SCHEMA).identity("id").build(); + private static final Types.StructType PARTITION_TYPE = SPEC.partitionType(); + private static final Types.StructType EMPTY_PARTITION = Types.StructType.of(); + private static final PartitionData EMPTY_PARTITION_DATA = new PartitionData(EMPTY_PARTITION); + private static final Map<Integer, PartitionSpec> PARTITIONED_SPECS = + ImmutableMap.of(SPEC.specId(), SPEC); + private static final Map<Integer, PartitionSpec> UNPARTITIONED_SPECS = + ImmutableMap.of(PartitionSpec.unpartitioned().specId(), PartitionSpec.unpartitioned()); + + private static final List<FileFormat> FORMATS = + ImmutableList.of(FileFormat.AVRO, FileFormat.PARQUET); + + // row_position is appended after the tracking schema fields by the reader + private static final int MANIFEST_POS_ORDINAL = Tracking.schema().fields().size(); + + @TempDir private Path tempDir; + + private final FileIO fileIO = new TestTables.LocalFileIO(); + + @ParameterizedTest + @FieldSource("FORMATS") + public void testRoundTrip(FileFormat format) throws IOException { + DeletionVector dv = deletionVector(DV_LOCATION, DV_OFFSET, DV_SIZE_IN_BYTES, DV_CARDINALITY); + + TrackedFile file = + new TrackedFileStruct( + addedTracking(), + FileContent.DATA, + FORMAT_VERSION_V4, + "s3://bucket/data/file.parquet", + FileFormat.PARQUET, + RECORD_COUNT, + FILE_SIZE_IN_BYTES, + SPEC.specId(), + partition(7), + null, + SORT_ORDER_ID, + dv, + null, + ByteBuffer.wrap(new byte[] {1, 2, 3}), + ImmutableList.of(50L, 100L), + null); + + InputFile manifest = writeManifest(format, PARTITION_TYPE, ImmutableList.of(file)); + + List<TrackedFile> read = read(manifest, PARTITIONED_SPECS); + assertThat(read).hasSize(1); + TrackedFile actual = read.get(0); + + // the reader fills row_position (manifestPos) and manifestLocation, which the written file + // does not have; mirror them on the expected file before comparing + TrackingStruct expectedTracking = (TrackingStruct) ((TrackedFileStruct) file).tracking(); + expectedTracking.set(MANIFEST_POS_ORDINAL, 0L); + expectedTracking.setManifestLocation(manifest.location()); + + Types.StructType readType = + TypeUtil.replaceFieldTypes( + TrackedFile.schema(PARTITION_TYPE, Types.StructType.of()), + ImmutableMap.of(TrackedFile.TRACKING.fieldId(), TrackingStruct.BASE_TYPE)) + .asStruct(); + assertThat(Comparators.forType(readType).compare((StructLike) file, (StructLike) actual)) + .isEqualTo(0); + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testEqualityDeleteRoundTrip(FileFormat format) throws IOException { + TrackedFile delete = + new TrackedFileStruct( + addedTracking(), + FileContent.EQUALITY_DELETES, + FORMAT_VERSION_V4, + "s3://bucket/eq-delete.parquet", + FileFormat.PARQUET, + RECORD_COUNT, + FILE_SIZE_IN_BYTES, + 0, + EMPTY_PARTITION_DATA, + null, + null, + null, + null, + null, + null, + ImmutableList.of(1, 2)); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, ImmutableList.of(delete)); + + TrackedFile actual = read(manifest, UNPARTITIONED_SPECS).get(0); + assertThat(actual.contentType()).isEqualTo(FileContent.EQUALITY_DELETES); + assertThat(actual.equalityIds()).containsExactly(1, 2); + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testStatusFiltering(FileFormat format) throws IOException { + List<TrackedFile> files = + ImmutableList.of( + fileWithStatus(EntryStatus.ADDED, "s3://bucket/added.parquet"), + fileWithStatus(EntryStatus.EXISTING, "s3://bucket/existing.parquet"), + fileWithStatus(EntryStatus.MODIFIED, "s3://bucket/modified.parquet"), + fileWithStatus(EntryStatus.DELETED, "s3://bucket/deleted.parquet"), + fileWithStatus(EntryStatus.REPLACED, "s3://bucket/replaced.parquet")); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, files); + + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS).build()) { + assertThat(reader) + .extracting(file -> file.tracking().status()) + .containsExactly(EntryStatus.ADDED, EntryStatus.EXISTING, EntryStatus.MODIFIED); + } + + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS).includeAll().build()) { + assertThat(reader) + .extracting(file -> file.tracking().status()) + .containsExactly( + EntryStatus.ADDED, + EntryStatus.EXISTING, + EntryStatus.MODIFIED, + EntryStatus.DELETED, + EntryStatus.REPLACED); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testManifestLocationAndPosition(FileFormat format) throws IOException { + List<TrackedFile> files = + ImmutableList.of( + dataFile("s3://bucket/a.parquet", EMPTY_PARTITION_DATA), + dataFile("s3://bucket/b.parquet", EMPTY_PARTITION_DATA), + dataFile("s3://bucket/c.parquet", EMPTY_PARTITION_DATA)); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, files); + + List<TrackedFile> read = read(manifest, UNPARTITIONED_SPECS); + assertThat(read) + .allSatisfy( + file -> assertThat(file.tracking().manifestLocation()).isEqualTo(manifest.location())); + assertThat(read).extracting(file -> file.tracking().manifestPos()).containsExactly(0L, 1L, 2L); + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testProjectionRestrictsFields(FileFormat format) throws IOException { + TrackedFile file = dataFile("s3://bucket/file.parquet", EMPTY_PARTITION_DATA); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, ImmutableList.of(file)); + + Schema projection = new Schema(TrackedFile.LOCATION); + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS).project(projection).build()) { + TrackedFile actual = Lists.newArrayList(reader).get(0); + assertThat(actual.location()).isEqualTo(file.location()); + // tracking and content_type are always projected, even though the caller omitted them + assertThat(actual.tracking()).isNotNull(); + assertThat(actual.tracking().status()).isEqualTo(EntryStatus.ADDED); + assertThat(actual.contentType()).isEqualTo(FileContent.DATA); + // sort_order_id, file_format, spec_id, and record_count are null because they were not + // projected and no row filter forces them + assertThat(actual.sortOrderId()).isNull(); + assertThat(actual.fileFormat()).isNull(); + assertThat(actual.specId()).isNull(); + assertThat(actual.recordCount()).isEqualTo(-1L); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testRowFilterForcesRecordCount(FileFormat format) throws IOException { + TrackedFile file = dataFile("s3://bucket/file.parquet", EMPTY_PARTITION_DATA); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, ImmutableList.of(file)); + + // record_count is read when evaluating a row filter against file metrics, so it is projected + // even though the caller selected only location + Schema projection = new Schema(TrackedFile.LOCATION); + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .project(projection) + .filter(Expressions.equal("id", 1)) + .build()) { + TrackedFile actual = Lists.newArrayList(reader).get(0); + assertThat(actual.location()).isEqualTo(file.location()); + assertThat(actual.recordCount()).isEqualTo(RECORD_COUNT); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testSelectRestrictsFields(FileFormat format) throws IOException { + TrackedFile file = dataFile("s3://bucket/file.parquet", EMPTY_PARTITION_DATA); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, ImmutableList.of(file)); + + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .select(ImmutableList.of("location")) + .build()) { + TrackedFile actual = Lists.newArrayList(reader).get(0); + assertThat(actual.location()).isEqualTo(file.location()); + // tracking status and content_type are joined in even though not selected + assertThat(actual.tracking()).isNotNull(); + assertThat(actual.tracking().status()).isEqualTo(EntryStatus.ADDED); + assertThat(actual.contentType()).isEqualTo(FileContent.DATA); + // only status is joined from tracking, not the other tracking fields + assertThat(actual.tracking().snapshotId()).isNull(); + // file_format and spec_id are null because they were not selected + assertThat(actual.fileFormat()).isNull(); + assertThat(actual.specId()).isNull(); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testCaseInsensitiveSelect(FileFormat format) throws IOException { + TrackedFile file = dataFile("s3://bucket/file.parquet", EMPTY_PARTITION_DATA); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, ImmutableList.of(file)); + + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .select(ImmutableList.of("LOCATION")) + .caseSensitive(false) + .build()) { + TrackedFile actual = Lists.newArrayList(reader).get(0); + assertThat(actual.location()).isEqualTo(file.location()); + assertThat(actual.fileFormat()).isNull(); + } + } + + @Test + public void testProjectionModesAreMutuallyExclusive() { + InputFile manifest = fileIO.newInputFile(tempDir.resolve("manifest.avro").toString()); + + assertThatThrownBy( + () -> + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .select(ImmutableList.of("location")) + .project(new Schema(TrackedFile.LOCATION))) + .isInstanceOf(IllegalStateException.class) + .hasMessage( + "Cannot select columns using both select(Collection<String>) and project(Schema)"); + + assertThatThrownBy( + () -> + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .project(new Schema(TrackedFile.LOCATION)) + .select(ImmutableList.of("location"))) + .isInstanceOf(IllegalStateException.class) + .hasMessage( + "Cannot select columns using both select(Collection<String>) and project(Schema)"); + + assertThatThrownBy( + () -> + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .forScanPlanning() + .select(ImmutableList.of("location"))) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Cannot use select(Collection<String>) with forScanPlanning()"); + + assertThatThrownBy( + () -> + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .select(ImmutableList.of("location")) + .forScanPlanning()) + .isInstanceOf(IllegalStateException.class) + .hasMessage( + "Cannot use forScanPlanning() with select(Collection<String>) or project(Schema)"); + + assertThatThrownBy( + () -> + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .forScanPlanning() + .project(new Schema(TrackedFile.LOCATION))) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Cannot use project(Schema) with forScanPlanning()"); + + assertThatThrownBy( + () -> + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .project(new Schema(TrackedFile.LOCATION)) + .forScanPlanning()) + .isInstanceOf(IllegalStateException.class) + .hasMessage( + "Cannot use forScanPlanning() with select(Collection<String>) or project(Schema)"); + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testProjectionPreservesNarrowTrackingProjection(FileFormat format) + throws IOException { + InputFile manifest = + writeManifest(format, EMPTY_PARTITION, ImmutableList.of(fileWithFullTracking())); + + Schema projection = + new Schema( + Types.NestedField.required( + TrackedFile.TRACKING.fieldId(), "tracking", Types.StructType.of(Tracking.STATUS))); + + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS).project(projection).build()) { + Tracking actual = Lists.newArrayList(reader).get(0).tracking(); + assertThat(actual.status()).isEqualTo(EntryStatus.ADDED); + // the narrow tracking projection is not widened to the full tracking type + assertThat(actual.snapshotId()).isNull(); + assertThat(actual.dvSnapshotId()).isNull(); + assertThat(actual.deletedPositions()).isNull(); + assertThat(actual.replacedPositions()).isNull(); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testSelectListColumn(FileFormat format) throws IOException { + TrackedFile file = + new TrackedFileStruct( + addedTracking(), + FileContent.DATA, + FORMAT_VERSION_V4, + "s3://bucket/file.parquet", + FileFormat.PARQUET, + RECORD_COUNT, + FILE_SIZE_IN_BYTES, + 0, + EMPTY_PARTITION_DATA, + null, + null, + null, + null, + null, + ImmutableList.of(50L, 100L), + null); + + InputFile manifest = writeManifest(format, EMPTY_PARTITION, ImmutableList.of(file)); + + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS) + .select(ImmutableList.of("split_offsets")) + .build()) { + TrackedFile actual = Lists.newArrayList(reader).get(0); + assertThat(actual.splitOffsets()).containsExactly(50L, 100L); + assertThat(actual.location()).isNull(); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testSelectWithPartitionFilterProjectsFilterFields(FileFormat format) + throws IOException { + TrackedFile keep = dataFile("keep.parquet", partition(1)); + TrackedFile prune = dataFile("prune.parquet", partition(2)); + + InputFile manifest = writeManifest(format, PARTITION_TYPE, ImmutableList.of(keep, prune)); + + // the caller selects only location; the reader must still project spec_id and partition + // for the partition filter or every row would be pruned + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, PARTITIONED_SPECS) + .select(ImmutableList.of("location")) + .filter(Expressions.equal("id", 1)) + .build()) { + assertThat(reader).extracting(TrackedFile::location).containsExactly(keep.location()); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testForScanPlanningOmitsChangeTrackingFields(FileFormat format) throws IOException { + InputFile manifest = + writeManifest(format, EMPTY_PARTITION, ImmutableList.of(fileWithFullTracking())); + + try (V4ManifestReader reader = + V4ManifestReader.builder(manifest, UNPARTITIONED_SPECS).forScanPlanning().build()) { + Tracking actual = Lists.newArrayList(reader).get(0).tracking(); + // scan-relevant tracking fields are projected + assertThat(actual.status()).isEqualTo(EntryStatus.ADDED); + assertThat(actual.snapshotId()).isEqualTo(SNAPSHOT_ID); + assertThat(actual.dataSequenceNumber()).isEqualTo(5L); + assertThat(actual.fileSequenceNumber()).isEqualTo(6L); + assertThat(actual.firstRowId()).isEqualTo(8L); + // change-tracking fields are omitted from the scan projection + assertThat(actual.dvSnapshotId()).isNull(); + assertThat(actual.deletedPositions()).isNull(); + assertThat(actual.replacedPositions()).isNull(); + } + } + + @ParameterizedTest + @FieldSource("FORMATS") + public void testDefaultReadsFullTracking(FileFormat format) throws IOException { + InputFile manifest = + writeManifest(format, EMPTY_PARTITION, ImmutableList.of(fileWithFullTracking())); + + // without a projection, the reader returns the full schema for copying to other manifests, + // including the change-tracking fields + Tracking actual = read(manifest, UNPARTITIONED_SPECS).get(0).tracking(); Review Comment: The use of `read` here does not show the part that this test case is validating, which is a builder that does not have `scanPlanning`, `select`, or `project` called. I think this should show the builder configuration so the test can be understood reading it here. -- 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]
