From 5e50cb8a89efa6314427ad831fdf6b32e82483fe Mon Sep 17 00:00:00 2001 From: Robert Kruszewski Date: Fri, 29 May 2026 01:41:17 +0100 Subject: [PATCH 1/2] Coverage tests for vortex --- .../iceberg/io/TestFileWriterFactory.java | 24 ++- .../iceberg/io/TestPartitioningWriters.java | 30 +++- .../iceberg/io/TestRollingFileWriters.java | 11 +- .../data/vortex/GenericVortexReader.java | 2 +- .../data/vortex/GenericVortexReaders.java | 11 +- .../data/vortex/GenericVortexWriter.java | 42 +++++- .../iceberg/vortex/VortexFormatModel.java | 2 +- .../vortex/TestGenericReadProjection.java | 139 ++++++++++++++++++ .../iceberg/vortex/TestGenericVortex.java | 7 +- 9 files changed, 251 insertions(+), 17 deletions(-) create mode 100644 vortex/src/test/java/org/apache/iceberg/vortex/TestGenericReadProjection.java diff --git a/data/src/test/java/org/apache/iceberg/io/TestFileWriterFactory.java b/data/src/test/java/org/apache/iceberg/io/TestFileWriterFactory.java index 8354149bf495..01d6bf92c210 100644 --- a/data/src/test/java/org/apache/iceberg/io/TestFileWriterFactory.java +++ b/data/src/test/java/org/apache/iceberg/io/TestFileWriterFactory.java @@ -49,6 +49,7 @@ import org.apache.iceberg.deletes.PositionDelete; import org.apache.iceberg.deletes.PositionDeleteWriter; import org.apache.iceberg.encryption.EncryptedOutputFile; +import org.apache.iceberg.formats.FormatModelRegistry; import org.apache.iceberg.orc.ORC; import org.apache.iceberg.parquet.Parquet; import org.apache.iceberg.relocated.com.google.common.collect.ImmutableList; @@ -73,7 +74,9 @@ protected static List parameters() { new Object[] {2, FileFormat.PARQUET, false}, new Object[] {2, FileFormat.PARQUET, true}, new Object[] {2, FileFormat.ORC, false}, - new Object[] {2, FileFormat.ORC, true}); + new Object[] {2, FileFormat.ORC, true}, + new Object[] {2, FileFormat.VORTEX, false}, + new Object[] {2, FileFormat.VORTEX, true}); } private static final String PARTITION_VALUE = "aaa"; @@ -162,6 +165,9 @@ public void testEqualityDeleteWriter() throws IOException { @TestTemplate public void testEqualityDeleteWriterWithMultipleSpecs() throws IOException { assumeThat(partitioned).isFalse(); + // Mixed-spec scans supply partition values via idToConstant, which the Vortex generic reader + // does not yet inject (no constant readers — see GenericVortexReader TODO). + assumeThat(fileFormat).isNotEqualTo(FileFormat.VORTEX); List equalityFieldIds = ImmutableList.of(table.schema().findField("id").fieldId()); Schema equalityDeleteRowSchema = table.schema().select("id"); @@ -217,6 +223,9 @@ public void testEqualityDeleteWriterWithMultipleSpecs() throws IOException { @TestTemplate public void testPositionDeleteWriter() throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); // write a data file @@ -355,6 +364,9 @@ public void testPositionDeleteWriterWithRow() throws IOException { @TestTemplate public void testPositionDeleteWriterMultipleDataFiles() throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); // write two data files @@ -506,6 +518,16 @@ private List readFile(Schema schema, InputFile inputFile) throws IOExcep return ImmutableList.copyOf(records); } + case VORTEX: + try (CloseableIterable records = + FormatModelRegistry.readBuilder( + FileFormat.VORTEX, Record.class, inputFile) + .project(schema) + .build()) { + + return ImmutableList.copyOf(records); + } + default: throw new UnsupportedOperationException("Unsupported read file format: " + fileFormat); } diff --git a/data/src/test/java/org/apache/iceberg/io/TestPartitioningWriters.java b/data/src/test/java/org/apache/iceberg/io/TestPartitioningWriters.java index e404b7008834..bc6e2d027b4a 100644 --- a/data/src/test/java/org/apache/iceberg/io/TestPartitioningWriters.java +++ b/data/src/test/java/org/apache/iceberg/io/TestPartitioningWriters.java @@ -60,7 +60,8 @@ protected static List parameters() { return Arrays.asList( new Object[] {2, FileFormat.AVRO}, new Object[] {2, FileFormat.PARQUET}, - new Object[] {2, FileFormat.ORC}); + new Object[] {2, FileFormat.ORC}, + new Object[] {2, FileFormat.VORTEX}); } private static final long TARGET_FILE_SIZE = 128L * 1024 * 1024; @@ -175,6 +176,9 @@ public void testClusteredEqualityDeleteWriterNoRecords() throws IOException { @TestTemplate public void testClusteredEqualityDeleteWriterMultipleSpecs() throws IOException { + // Mixed-spec scans supply partition values via idToConstant, which the Vortex generic reader + // does not yet inject (no constant readers — see GenericVortexReader TODO). + assumeThat(fileFormat).isNotEqualTo(FileFormat.VORTEX); List equalityFieldIds = ImmutableList.of(table.schema().findField("id").fieldId()); Schema equalityDeleteRowSchema = table.schema().select("id"); FileWriterFactory writerFactory = @@ -240,6 +244,9 @@ public void testClusteredEqualityDeleteWriterMultipleSpecs() throws IOException @TestTemplate public void testClusteredEqualityDeleteWriterOutOfOrderSpecsAndPartitions() throws IOException { + // Mixed-spec scans supply partition values via idToConstant, which the Vortex generic reader + // does not yet inject (no constant readers — see GenericVortexReader TODO). + assumeThat(fileFormat).isNotEqualTo(FileFormat.VORTEX); List equalityFieldIds = ImmutableList.of(table.schema().findField("id").fieldId()); Schema equalityDeleteRowSchema = table.schema().select("id"); FileWriterFactory writerFactory = @@ -294,6 +301,9 @@ public void testClusteredPositionDeleteWriterNoRecordsFileGranularity() throws I private void checkClusteredPositionDeleteWriterNoRecords(DeleteGranularity deleteGranularity) throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); ClusteredPositionDeleteWriter writer = new ClusteredPositionDeleteWriter<>( @@ -323,6 +333,9 @@ public void testClusteredPositionDeleteWriterMultipleSpecsFileGranularity() thro private void checkClusteredPositionDeleteWriterMultipleSpecs(DeleteGranularity deleteGranularity) throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); // add an unpartitioned data file @@ -406,6 +419,9 @@ public void testClusteredPositionDeleteWriterOutOfOrderSpecsAndPartitionsFileGra private void checkClusteredPositionDeleteWriterOutOfOrderSpecsAndPartitions( DeleteGranularity deleteGranularity) throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); table.updateSpec().addField(Expressions.bucket("data", 16)).commit(); @@ -472,6 +488,9 @@ public void testClusteredPositionDeleteWriterFileGranularity() throws IOExceptio private void checkClusteredPositionDeleteWriterGranularity(DeleteGranularity deleteGranularity) throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); // add the first data file @@ -571,6 +590,9 @@ public void testFanoutPositionOnlyDeleteWriterNoRecordsFileGranularity() throws private void checkFanoutPositionOnlyDeleteWriterNoRecords(DeleteGranularity deleteGranularity) throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); FanoutPositionOnlyDeleteWriter writer = new FanoutPositionOnlyDeleteWriter<>( @@ -601,6 +623,9 @@ public void testFanoutPositionOnlyDeleteWriterOutOfOrderRecordsFileGranularity() private void checkFanoutPositionOnlyDeleteWriterOutOfOrderRecords( DeleteGranularity deleteGranularity) throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); // add an unpartitioned data file @@ -691,6 +716,9 @@ public void testFanoutPositionOnlyDeleteWriterFileGranularity() throws IOExcepti private void checkFanoutPositionOnlyDeleteWriterGranularity(DeleteGranularity deleteGranularity) throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); // add the first data file diff --git a/data/src/test/java/org/apache/iceberg/io/TestRollingFileWriters.java b/data/src/test/java/org/apache/iceberg/io/TestRollingFileWriters.java index 24798489e781..706635d3597b 100644 --- a/data/src/test/java/org/apache/iceberg/io/TestRollingFileWriters.java +++ b/data/src/test/java/org/apache/iceberg/io/TestRollingFileWriters.java @@ -19,6 +19,7 @@ package org.apache.iceberg.io; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assumptions.assumeThat; import java.io.File; import java.io.IOException; @@ -49,7 +50,9 @@ protected static List parameters() { new Object[] {2, FileFormat.PARQUET, false}, new Object[] {2, FileFormat.PARQUET, true}, new Object[] {2, FileFormat.ORC, false}, - new Object[] {2, FileFormat.ORC, true}); + new Object[] {2, FileFormat.ORC, true}, + new Object[] {2, FileFormat.VORTEX, false}, + new Object[] {2, FileFormat.VORTEX, true}); } private static final int FILE_SIZE_CHECK_ROWS_DIVISOR = 1000; @@ -172,6 +175,9 @@ public void testRollingEqualityDeleteWriterSplitDeletes() throws IOException { @TestTemplate public void testRollingPositionDeleteWriterNoRecords() throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); RollingPositionDeleteWriter writer = new RollingPositionDeleteWriter<>( @@ -190,6 +196,9 @@ public void testRollingPositionDeleteWriterNoRecords() throws IOException { @TestTemplate public void testRollingPositionDeleteWriterSplitDeletes() throws IOException { + assumeThat(fileFormat) + .as("Vortex does not support position deletes") + .isNotEqualTo(FileFormat.VORTEX); FileWriterFactory writerFactory = newWriterFactory(table.schema()); RollingPositionDeleteWriter writer = new RollingPositionDeleteWriter<>( diff --git a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReader.java b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReader.java index 73c2d929ee91..b58ad77b2759 100644 --- a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReader.java +++ b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReader.java @@ -99,7 +99,7 @@ public VortexValueReader struct( @Override public VortexValueReader list( Types.ListType iList, Field listField, VortexValueReader element) { - throw new UnsupportedOperationException("LIST TYPES!"); + return GenericVortexReaders.list(element); } @Override diff --git a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReaders.java b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReaders.java index e10374314763..4525f514d7e5 100644 --- a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReaders.java +++ b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexReaders.java @@ -29,6 +29,7 @@ import java.time.ZoneId; import java.util.List; import java.util.UUID; +import java.util.stream.IntStream; import org.apache.arrow.vector.BaseIntVector; import org.apache.arrow.vector.BitVector; import org.apache.arrow.vector.DateDayVector; @@ -44,6 +45,7 @@ import org.apache.arrow.vector.TimeStampVector; import org.apache.arrow.vector.VarBinaryVector; import org.apache.arrow.vector.VarCharVector; +import org.apache.arrow.vector.complex.ListVector; import org.apache.arrow.vector.complex.StructVector; import org.apache.iceberg.data.GenericRecord; import org.apache.iceberg.data.Record; @@ -139,7 +141,6 @@ public Record readNonNull(FieldVector vector, int row) { } } - @SuppressWarnings("UnusedVariable") private static class ListReader implements VortexValueReader> { private final VortexValueReader elementReader; @@ -149,7 +150,13 @@ private ListReader(VortexValueReader elementReader) { @Override public List readNonNull(FieldVector vector, int row) { - throw new UnsupportedOperationException("Reading lists from Vortex not supported yet"); + ListVector listVector = (ListVector) vector; + int start = listVector.getElementStartIndex(row); + int end = listVector.getElementEndIndex(row); + FieldVector elementVector = listVector.getDataVector(); + return IntStream.range(start, end) + .mapToObj(i -> elementReader.read(elementVector, i)) + .toList(); } } diff --git a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java index a73ce14cf3c5..c628071850b7 100644 --- a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java +++ b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java @@ -49,6 +49,7 @@ import org.apache.arrow.vector.VarBinaryVector; import org.apache.arrow.vector.VarCharVector; import org.apache.arrow.vector.VectorSchemaRoot; +import org.apache.arrow.vector.complex.ListVector; import org.apache.iceberg.FieldMetrics; import org.apache.iceberg.Schema; import org.apache.iceberg.data.Record; @@ -131,16 +132,21 @@ private static void writeValue( ((VarCharVector) vector).setSafe(rowIndex, strBytes); break; case BINARY: - case FIXED: - byte[] bytes; + byte[] binaryBytes; if (value instanceof ByteBuffer) { - bytes = ByteBuffers.toByteArray((ByteBuffer) value); + binaryBytes = ByteBuffers.toByteArray((ByteBuffer) value); } else { - bytes = (byte[]) value; + binaryBytes = (byte[]) value; } - ((VarBinaryVector) vector).setSafe(rowIndex, bytes); + ((VarBinaryVector) vector).setSafe(rowIndex, binaryBytes); break; + case FIXED: + // FIXED maps to Arrow FixedSizeBinaryVector, not VarBinaryVector. Until the writer is + // updated to use FixedSizeBinaryVector and validate the byte length, refuse the write + // rather than failing with a cryptic ClassCastException at runtime. + throw new UnsupportedOperationException( + "Writing Iceberg FIXED columns to Vortex is not yet supported"); case DECIMAL: ((DecimalVector) vector).setSafe(rowIndex, (BigDecimal) value); break; @@ -180,6 +186,25 @@ private static void writeValue( ((TimeStampNanoVector) vector).setSafe(rowIndex, localEpochNanos); } + break; + case LIST: + Types.ListType listType = (Types.ListType) type; + org.apache.iceberg.types.Type elementType = listType.elementType(); + ListVector listVector = (ListVector) vector; + listVector.getWriter() + FieldVector elementVector = listVector.getDataVector(); + List elements = (List) value; + int elementStart = listVector.startNewValue(rowIndex); + for (int i = 0; i < elements.size(); i++) { + Object elementValue = elements.get(i); + int elementIdx = elementStart + i; + if (elementValue == null) { + elementVector.setNull(elementIdx); + } else { + writeValue(elementVector, elementType, elementValue, elementIdx); + } + } + listVector.endValue(rowIndex, elements.size()); break; default: throw new UnsupportedOperationException( @@ -229,6 +254,10 @@ private static ColumnMetricsTracker newTracker(Types.NestedField field) { v -> ChronoUnit.NANOS.between(LOCAL_EPOCH, (LocalDateTime) v)); } default: + if (field.type().isNestedType()) { + // Lists, maps, and structs have no natural ordering — track counts only. + return new ColumnMetricsTracker<>(field.fieldId(), null); + } return new ColumnMetricsTracker<>(field.fieldId(), (Comparator) Comparator.naturalOrder()); } } @@ -271,6 +300,9 @@ void incrementValueCount() { @SuppressWarnings("unchecked") void addValue(Object value) { valueCount++; + if (comparator == null) { + return; + } T typedValue = converter != null ? converter.apply(value) : (T) value; if (min == null || comparator.compare(typedValue, min) < 0) { min = typedValue; diff --git a/vortex/src/main/java/org/apache/iceberg/vortex/VortexFormatModel.java b/vortex/src/main/java/org/apache/iceberg/vortex/VortexFormatModel.java index b847980e3ddf..3638367f0456 100644 --- a/vortex/src/main/java/org/apache/iceberg/vortex/VortexFormatModel.java +++ b/vortex/src/main/java/org/apache/iceberg/vortex/VortexFormatModel.java @@ -296,7 +296,7 @@ public ReadBuilder caseSensitive(boolean caseSensitive) { @Override public ReadBuilder filter(Expression filter) { - this.filterPredicate = Optional.of(filter); + this.filterPredicate = Optional.ofNullable(filter); return this; } diff --git a/vortex/src/test/java/org/apache/iceberg/vortex/TestGenericReadProjection.java b/vortex/src/test/java/org/apache/iceberg/vortex/TestGenericReadProjection.java new file mode 100644 index 000000000000..ee707ab1f16a --- /dev/null +++ b/vortex/src/test/java/org/apache/iceberg/vortex/TestGenericReadProjection.java @@ -0,0 +1,139 @@ +/* + * 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.vortex; + +import static org.assertj.core.api.Assumptions.assumeThat; + +import java.io.File; +import java.io.IOException; +import org.apache.iceberg.FileContent; +import org.apache.iceberg.Files; +import org.apache.iceberg.Schema; +import org.apache.iceberg.data.Record; +import org.apache.iceberg.data.TestReadProjection; +import org.apache.iceberg.data.vortex.GenericVortexReader; +import org.apache.iceberg.data.vortex.GenericVortexWriter; +import org.apache.iceberg.encryption.EncryptedFiles; +import org.apache.iceberg.io.CloseableIterable; +import org.apache.iceberg.io.FileAppender; +import org.apache.iceberg.io.OutputFile; +import org.apache.iceberg.relocated.com.google.common.collect.Iterables; +import org.apache.iceberg.types.Type; +import org.apache.iceberg.types.TypeUtil; +import org.apache.iceberg.types.Types.StructType; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; + +public class TestGenericReadProjection extends TestReadProjection { + @Override + protected Record writeAndRead(String desc, Schema writeSchema, Schema readSchema, Record record) + throws IOException { + assumeSupported(writeSchema); + assumeSupported(readSchema); + + File file = new File(tempDir, "junit-" + desc + "-" + System.nanoTime() + ".vortex"); + OutputFile outputFile = Files.localOutput(file); + + try (FileAppender appender = + formatModel() + .writeBuilder(EncryptedFiles.plainAsEncryptedOutput(outputFile)) + .schema(writeSchema) + .content(FileContent.DATA) + .build()) { + appender.add(record); + } + + try (CloseableIterable records = + formatModel().readBuilder(outputFile.toInputFile()).project(readSchema).build()) { + return Iterables.getOnlyElement(records); + } + } + + // GenericVortexReader and VortexSchemaWithTypeVisitor pair expected Iceberg fields with file + // Arrow fields positionally. Any read schema that does not list columns in the same order as the + // file fails. Renamed fields additionally need field-ID-based matching (Arrow schemas do not + // carry Iceberg field ids), and missing-field defaults need null fill-in support in the reader. + // The tests below stay declared so they re-enable automatically once those gaps are filled. + + @Test + @Override + @Disabled("Vortex reader binds expected fields to file fields by position; reordered read fails") + public void testReorderedFullProjection() {} + + @Test + @Override + @Disabled( + "Vortex reader binds expected fields to file fields by position; column-subset read fails") + public void testBasicProjection() {} + + @Test + @Override + @Disabled( + "Vortex reader binds expected fields to file fields by position; column-subset read fails") + public void testSpecialCharacterProjection() {} + + @Test + @Override + @Disabled( + "Vortex projection asks the file for the read schema's column names; renames are not " + + "resolved by field id") + public void testRename() {} + + @Test + @Override + @Disabled( + "Vortex projection asks the file for the read schema's column names; renames are not " + + "resolved by field id") + public void testRenamedAddedField() {} + + @Test + @Override + @Disabled( + "Vortex projection asks the file for the read schema's column names; missing fields are not " + + "filled with nulls/defaults") + public void testReorderedProjection() {} + + @Test + @Override + @Disabled("VortexSchemaWithTypeVisitor walks nested struct children positionally") + public void testNestedStructProjection() {} + + private static void assumeSupported(Schema schema) { + // LIST round-trip works in the generic writer/reader (see TestGenericVortex), but projection + // breaks on lists for the same positional-field-matching reason that disables the other + // projection tests above. Skip until projection is rewritten to match by name/field-id. + assumeThat( + TypeUtil.find( + schema, + type -> + type.typeId() == Type.TypeID.LIST + || type.typeId() == Type.TypeID.MAP + || type.typeId() == Type.TypeID.FIXED)) + .as("Vortex does not yet support lists, maps, or fixed in projection scenarios") + .isNull(); + } + + private static VortexFormatModel> formatModel() { + return VortexFormatModel.create( + Record.class, + StructType.class, + (icebergSchema, fileSchema, engineSchema) -> GenericVortexWriter.buildWriter(icebergSchema), + (VortexFormatModel.ReaderFunction) GenericVortexReader::buildReader); + } +} diff --git a/vortex/src/test/java/org/apache/iceberg/vortex/TestGenericVortex.java b/vortex/src/test/java/org/apache/iceberg/vortex/TestGenericVortex.java index fc7f2ebaa866..3722a1b6d0f8 100644 --- a/vortex/src/test/java/org/apache/iceberg/vortex/TestGenericVortex.java +++ b/vortex/src/test/java/org/apache/iceberg/vortex/TestGenericVortex.java @@ -113,11 +113,8 @@ private static void assumeSupported(Schema schema) { assumeThat( TypeUtil.find( schema, - type -> - type.typeId() == Type.TypeID.LIST - || type.typeId() == Type.TypeID.MAP - || type.typeId() == Type.TypeID.FIXED)) - .as("Vortex does not yet support lists, maps, or variants") + type -> type.typeId() == Type.TypeID.MAP || type.typeId() == Type.TypeID.FIXED)) + .as("Vortex does not yet support maps or fixed") .isNull(); } From 9ea734aa8af9b8f9640c44c606ea8ce403e01dca Mon Sep 17 00:00:00 2001 From: Robert Kruszewski Date: Mon, 1 Jun 2026 00:29:26 +0100 Subject: [PATCH 2/2] fixes --- .../java/org/apache/iceberg/data/vortex/GenericVortexWriter.java | 1 - 1 file changed, 1 deletion(-) diff --git a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java index c628071850b7..677870ad597f 100644 --- a/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java +++ b/vortex/src/main/java/org/apache/iceberg/data/vortex/GenericVortexWriter.java @@ -191,7 +191,6 @@ private static void writeValue( Types.ListType listType = (Types.ListType) type; org.apache.iceberg.types.Type elementType = listType.elementType(); ListVector listVector = (ListVector) vector; - listVector.getWriter() FieldVector elementVector = listVector.getDataVector(); List elements = (List) value; int elementStart = listVector.startNewValue(rowIndex);