From bc38ccbd229169d22d7b8598b9896c20149c2c0d Mon Sep 17 00:00:00 2001 From: Aaron Niskode-Dossett Date: Thu, 29 Oct 2026 21:16:20 -0500 Subject: [PATCH 1/3] Use Java 17 instanceof assignments --- .../dictionarylevel/DictionaryFilter.java | 10 +++--- .../parquet/variant/VariantValueWriter.java | 36 ++++++++----------- 2 files changed, 19 insertions(+), 27 deletions(-) diff --git a/parquet-hadoop/src/main/java/org/apache/parquet/filter2/dictionarylevel/DictionaryFilter.java b/parquet-hadoop/src/main/java/org/apache/parquet/filter2/dictionarylevel/DictionaryFilter.java index 409caeb805..a03de37041 100644 --- a/parquet-hadoop/src/main/java/org/apache/parquet/filter2/dictionarylevel/DictionaryFilter.java +++ b/parquet-hadoop/src/main/java/org/apache/parquet/filter2/dictionarylevel/DictionaryFilter.java @@ -103,14 +103,14 @@ private static boolean isNaNLiteral(ColumnChunkMetaData meta, Object value) { PrimitiveTypeName type = meta.getPrimitiveType().getPrimitiveTypeName(); switch (type) { case FLOAT: - return value instanceof Float && Float.isNaN((Float) value); + return value instanceof Float floatValue && Float.isNaN(floatValue); case DOUBLE: - return value instanceof Double && Double.isNaN((Double) value); + return value instanceof Double doubleValue && Double.isNaN(doubleValue); case FIXED_LEN_BYTE_ARRAY: return isFloat16(meta) - && value instanceof Binary - && ((Binary) value).length() == 2 - && Float16.isNaN(((Binary) value).get2BytesLittleEndian()); + && value instanceof Binary binaryValue + && binaryValue.length() == 2 + && Float16.isNaN(binaryValue.get2BytesLittleEndian()); default: return false; } diff --git a/parquet-variant/src/main/java/org/apache/parquet/variant/VariantValueWriter.java b/parquet-variant/src/main/java/org/apache/parquet/variant/VariantValueWriter.java index 34396e2462..6315048461 100644 --- a/parquet-variant/src/main/java/org/apache/parquet/variant/VariantValueWriter.java +++ b/parquet-variant/src/main/java/org/apache/parquet/variant/VariantValueWriter.java @@ -112,11 +112,9 @@ void write(GroupType schema, Variant value) { // Return true if the logical type is a decimal with the same scale as the provided value, with enough // precision to hold the value. The provided value must be a decimal. private static boolean compatibleDecimalType(Variant value, LogicalTypeAnnotation logicalType) { - if (!(logicalType instanceof LogicalTypeAnnotation.DecimalLogicalTypeAnnotation)) { + if (!(logicalType instanceof LogicalTypeAnnotation.DecimalLogicalTypeAnnotation decimalType)) { return false; } - LogicalTypeAnnotation.DecimalLogicalTypeAnnotation decimalType = - (LogicalTypeAnnotation.DecimalLogicalTypeAnnotation) logicalType; BigDecimal decimal = value.getDecimal(); return decimal.scale() == decimalType.getScale() && decimal.precision() <= decimalType.getPrecision(); @@ -136,30 +134,26 @@ private static boolean isTypeCompatible(Variant.Type variantType, Type typedValu return primitiveTypeName == PrimitiveType.PrimitiveTypeName.BOOLEAN; case BYTE: return primitiveTypeName == PrimitiveType.PrimitiveTypeName.INT32 - && logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType).isSigned() - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType).getBitWidth() == 8; + && logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation intType + && intType.isSigned() + && intType.getBitWidth() == 8; case SHORT: return primitiveTypeName == PrimitiveType.PrimitiveTypeName.INT32 - && logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType).isSigned() - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType).getBitWidth() == 16; + && logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation intType + && intType.isSigned() + && intType.getBitWidth() == 16; case INT: return primitiveTypeName == PrimitiveType.PrimitiveTypeName.INT32 && (logicalType == null - || (logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType).isSigned() - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType) - .getBitWidth() - == 32)); + || (logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation intType + && intType.isSigned() + && intType.getBitWidth() == 32)); case LONG: return primitiveTypeName == PrimitiveType.PrimitiveTypeName.INT64 && (logicalType == null - || (logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType).isSigned() - && ((LogicalTypeAnnotation.IntLogicalTypeAnnotation) logicalType) - .getBitWidth() - == 64)); + || (logicalType instanceof LogicalTypeAnnotation.IntLogicalTypeAnnotation intType + && intType.isSigned() + && intType.getBitWidth() == 64)); case FLOAT: return primitiveTypeName == PrimitiveType.PrimitiveTypeName.FLOAT; case DOUBLE: @@ -184,9 +178,7 @@ private static boolean isTypeCompatible(Variant.Type variantType, Type typedValu case TIMESTAMP_TZ: case TIMESTAMP_NANOS_TZ: if (primitiveTypeName == PrimitiveType.PrimitiveTypeName.INT64 - && logicalType instanceof LogicalTypeAnnotation.TimestampLogicalTypeAnnotation) { - LogicalTypeAnnotation.TimestampLogicalTypeAnnotation annotation = - (LogicalTypeAnnotation.TimestampLogicalTypeAnnotation) logicalType; + && logicalType instanceof LogicalTypeAnnotation.TimestampLogicalTypeAnnotation annotation) { boolean micros = annotation.getUnit() == LogicalTypeAnnotation.TimeUnit.MICROS; boolean nanos = annotation.getUnit() == LogicalTypeAnnotation.TimeUnit.NANOS; boolean adjustedToUTC = annotation.isAdjustedToUTC(); From f0086f53943c4c3afc36ffccea2dea38f5762ba9 Mon Sep 17 00:00:00 2001 From: Aaron Niskode-Dossett Date: Thu, 29 Oct 2026 21:20:33 -0500 Subject: [PATCH 2/3] Use Java 17 instanceof assignments --- .../parquet/column/ColumnDescriptor.java | 3 +-- .../parquet/schema/LogicalTypeAnnotation.java | 21 +++++++------------ .../hadoop/util/wrapped/io/FutureIO.java | 16 +++++++------- 3 files changed, 16 insertions(+), 24 deletions(-) diff --git a/parquet-column/src/main/java/org/apache/parquet/column/ColumnDescriptor.java b/parquet-column/src/main/java/org/apache/parquet/column/ColumnDescriptor.java index fe3c0915f3..db32b1ab29 100644 --- a/parquet-column/src/main/java/org/apache/parquet/column/ColumnDescriptor.java +++ b/parquet-column/src/main/java/org/apache/parquet/column/ColumnDescriptor.java @@ -125,8 +125,7 @@ public int hashCode() { @Override public boolean equals(Object other) { if (other == this) return true; - if (!(other instanceof ColumnDescriptor)) return false; - ColumnDescriptor descriptor = (ColumnDescriptor) other; + if (!(other instanceof ColumnDescriptor descriptor)) return false; return Arrays.equals(path, descriptor.path); } diff --git a/parquet-column/src/main/java/org/apache/parquet/schema/LogicalTypeAnnotation.java b/parquet-column/src/main/java/org/apache/parquet/schema/LogicalTypeAnnotation.java index 625e9fd9d3..b44c937f0a 100644 --- a/parquet-column/src/main/java/org/apache/parquet/schema/LogicalTypeAnnotation.java +++ b/parquet-column/src/main/java/org/apache/parquet/schema/LogicalTypeAnnotation.java @@ -592,10 +592,9 @@ protected String typeParametersAsString() { @Override public boolean equals(Object obj) { - if (!(obj instanceof DecimalLogicalTypeAnnotation)) { + if (!(obj instanceof DecimalLogicalTypeAnnotation other)) { return false; } - DecimalLogicalTypeAnnotation other = (DecimalLogicalTypeAnnotation) obj; return scale == other.scale && precision == other.precision; } @@ -713,10 +712,9 @@ public boolean isAdjustedToUTC() { @Override public boolean equals(Object obj) { - if (!(obj instanceof TimeLogicalTypeAnnotation)) { + if (!(obj instanceof TimeLogicalTypeAnnotation other)) { return false; } - TimeLogicalTypeAnnotation other = (TimeLogicalTypeAnnotation) obj; return isAdjustedToUTC == other.isAdjustedToUTC && unit == other.unit; } @@ -792,10 +790,9 @@ public boolean isAdjustedToUTC() { @Override public boolean equals(Object obj) { - if (!(obj instanceof TimestampLogicalTypeAnnotation)) { + if (!(obj instanceof TimestampLogicalTypeAnnotation other)) { return false; } - TimestampLogicalTypeAnnotation other = (TimestampLogicalTypeAnnotation) obj; return (isAdjustedToUTC == other.isAdjustedToUTC) && (unit == other.unit); } @@ -881,10 +878,9 @@ public boolean isSigned() { @Override public boolean equals(Object obj) { - if (!(obj instanceof IntLogicalTypeAnnotation)) { + if (!(obj instanceof IntLogicalTypeAnnotation other)) { return false; } - IntLogicalTypeAnnotation other = (IntLogicalTypeAnnotation) obj; return (bitWidth == other.bitWidth) && (isSigned == other.isSigned); } @@ -1220,11 +1216,10 @@ protected String typeParametersAsString() { @Override public boolean equals(Object obj) { - if (!(obj instanceof VariantLogicalTypeAnnotation)) { + if (!(obj instanceof VariantLogicalTypeAnnotation other)) { return false; } - VariantLogicalTypeAnnotation other = (VariantLogicalTypeAnnotation) obj; return specVersion == other.specVersion; } } @@ -1266,10 +1261,9 @@ public String getCrs() { @Override public boolean equals(Object obj) { - if (!(obj instanceof GeometryLogicalTypeAnnotation)) { + if (!(obj instanceof GeometryLogicalTypeAnnotation other)) { return false; } - GeometryLogicalTypeAnnotation other = (GeometryLogicalTypeAnnotation) obj; return Objects.equals(crs, other.crs); } @@ -1329,10 +1323,9 @@ public EdgeInterpolationAlgorithm getAlgorithm() { @Override public boolean equals(Object obj) { - if (!(obj instanceof GeographyLogicalTypeAnnotation)) { + if (!(obj instanceof GeographyLogicalTypeAnnotation other)) { return false; } - GeographyLogicalTypeAnnotation other = (GeographyLogicalTypeAnnotation) obj; return Objects.equals(crs, other.crs) && Objects.equals(algorithm, other.algorithm); } diff --git a/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/wrapped/io/FutureIO.java b/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/wrapped/io/FutureIO.java index 23533c75bf..8f2a0e11b8 100644 --- a/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/wrapped/io/FutureIO.java +++ b/parquet-hadoop/src/main/java/org/apache/parquet/hadoop/util/wrapped/io/FutureIO.java @@ -118,17 +118,17 @@ public static T awaitFuture(final Future future) @SuppressWarnings("ChainOfInstanceofChecks") public static IOException unwrapInnerException(final Throwable e) { Throwable cause = e.getCause(); - if (cause instanceof IOException) { - return (IOException) cause; - } else if (cause instanceof UncheckedIOException) { + if (cause instanceof IOException ioException) { + return ioException; + } else if (cause instanceof UncheckedIOException uncheckedIOException) { // this is always an IOException - return ((UncheckedIOException) cause).getCause(); + return uncheckedIOException.getCause(); } else if (cause instanceof CompletionException || cause instanceof ExecutionException) { return unwrapInnerException(cause); - } else if (cause instanceof RuntimeException) { - throw (RuntimeException) cause; - } else if (cause instanceof Error) { - throw (Error) cause; + } else if (cause instanceof RuntimeException runtimeException) { + throw runtimeException; + } else if (cause instanceof Error error) { + throw error; } else if (cause != null) { // other type: wrap with a new IOE return new IOException(cause); From 8132af44eaf192643c25da8eaf4c569e3d9da33b Mon Sep 17 00:00:00 2001 From: Aaron Niskode-Dossett Date: Fri, 30 Oct 2026 08:18:59 -0500 Subject: [PATCH 3/3] Use Java 17 switch idiom --- .../parquet/column/ParquetProperties.java | 43 +-- .../org/apache/parquet/bytes/BytesUtils.java | 21 +- .../column/values/bitpacking/BitPacking.java | 68 ++-- .../converter/ParquetMetadataConverter.java | 361 +++++++----------- 4 files changed, 187 insertions(+), 306 deletions(-) diff --git a/parquet-column/src/main/java/org/apache/parquet/column/ParquetProperties.java b/parquet-column/src/main/java/org/apache/parquet/column/ParquetProperties.java index 8fe45e01ef..0c59cc6744 100644 --- a/parquet-column/src/main/java/org/apache/parquet/column/ParquetProperties.java +++ b/parquet-column/src/main/java/org/apache/parquet/column/ParquetProperties.java @@ -251,17 +251,12 @@ public boolean isByteStreamSplitEnabled() { } public boolean isByteStreamSplitEnabled(ColumnDescriptor column) { - switch (column.getPrimitiveType().getPrimitiveTypeName()) { - case FLOAT: - case DOUBLE: - return byteStreamSplitEnabled.getValue(column) != ByteStreamSplitMode.NONE; - case INT32: - case INT64: - case FIXED_LEN_BYTE_ARRAY: - return byteStreamSplitEnabled.getValue(column) == ByteStreamSplitMode.EXTENDED; - default: - return false; - } + return switch (column.getPrimitiveType().getPrimitiveTypeName()) { + case FLOAT, DOUBLE -> byteStreamSplitEnabled.getValue(column) != ByteStreamSplitMode.NONE; + case INT32, INT64, FIXED_LEN_BYTE_ARRAY -> + byteStreamSplitEnabled.getValue(column) == ByteStreamSplitMode.EXTENDED; + default -> false; + }; } public ByteBufferAllocator getAllocator() { @@ -269,26 +264,20 @@ public ByteBufferAllocator getAllocator() { } public ColumnWriteStore newColumnWriteStore(MessageType schema, PageWriteStore pageStore) { - switch (writerVersion) { - case PARQUET_1_0: - return new ColumnWriteStoreV1(schema, pageStore, this); - case PARQUET_2_0: - return new ColumnWriteStoreV2(schema, pageStore, this); - default: - throw new IllegalArgumentException("unknown version " + writerVersion); - } + return switch (writerVersion) { + case PARQUET_1_0 -> new ColumnWriteStoreV1(schema, pageStore, this); + case PARQUET_2_0 -> new ColumnWriteStoreV2(schema, pageStore, this); + default -> throw new IllegalArgumentException("unknown version " + writerVersion); + }; } public ColumnWriteStore newColumnWriteStore( MessageType schema, PageWriteStore pageStore, BloomFilterWriteStore bloomFilterWriteStore) { - switch (writerVersion) { - case PARQUET_1_0: - return new ColumnWriteStoreV1(schema, pageStore, bloomFilterWriteStore, this); - case PARQUET_2_0: - return new ColumnWriteStoreV2(schema, pageStore, bloomFilterWriteStore, this); - default: - throw new IllegalArgumentException("unknown version " + writerVersion); - } + return switch (writerVersion) { + case PARQUET_1_0 -> new ColumnWriteStoreV1(schema, pageStore, bloomFilterWriteStore, this); + case PARQUET_2_0 -> new ColumnWriteStoreV2(schema, pageStore, bloomFilterWriteStore, this); + default -> throw new IllegalArgumentException("unknown version " + writerVersion); + }; } public int getMinRowCountForPageSizeCheck() { diff --git a/parquet-common/src/main/java/org/apache/parquet/bytes/BytesUtils.java b/parquet-common/src/main/java/org/apache/parquet/bytes/BytesUtils.java index 9d4772717b..1d75de4f3e 100644 --- a/parquet-common/src/main/java/org/apache/parquet/bytes/BytesUtils.java +++ b/parquet-common/src/main/java/org/apache/parquet/bytes/BytesUtils.java @@ -124,21 +124,16 @@ public static int readIntLittleEndianOnThreeBytes(InputStream in) throws IOExcep public static int readIntLittleEndianPaddedOnBitWidth(InputStream in, int bitWidth) throws IOException { int bytesWidth = paddedByteCountFromBits(bitWidth); - switch (bytesWidth) { - case 0: - return 0; - case 1: - return BytesUtils.readIntLittleEndianOnOneByte(in); - case 2: - return BytesUtils.readIntLittleEndianOnTwoBytes(in); - case 3: - return BytesUtils.readIntLittleEndianOnThreeBytes(in); - case 4: - return BytesUtils.readIntLittleEndian(in); - default: + return switch (bytesWidth) { + case 0 -> 0; + case 1 -> BytesUtils.readIntLittleEndianOnOneByte(in); + case 2 -> BytesUtils.readIntLittleEndianOnTwoBytes(in); + case 3 -> BytesUtils.readIntLittleEndianOnThreeBytes(in); + case 4 -> BytesUtils.readIntLittleEndian(in); + default -> throw new IOException( String.format("Encountered bitWidth (%d) that requires more than 4 bytes", bitWidth)); - } + }; } public static void writeIntLittleEndianOnOneByte(OutputStream out, int v) throws IOException { diff --git a/parquet-encoding/src/main/java/org/apache/parquet/column/values/bitpacking/BitPacking.java b/parquet-encoding/src/main/java/org/apache/parquet/column/values/bitpacking/BitPacking.java index 86776dc827..b51c504e13 100755 --- a/parquet-encoding/src/main/java/org/apache/parquet/column/values/bitpacking/BitPacking.java +++ b/parquet-encoding/src/main/java/org/apache/parquet/column/values/bitpacking/BitPacking.java @@ -73,28 +73,18 @@ private BitPacking() {} * @return the correct implementation for the width */ public static BitPackingWriter getBitPackingWriter(int bitLength, OutputStream out) { - switch (bitLength) { - case 0: - return new ZeroBitPackingWriter(); - case 1: - return new OneBitPackingWriter(out); - case 2: - return new TwoBitPackingWriter(out); - case 3: - return new ThreeBitPackingWriter(out); - case 4: - return new FourBitPackingWriter(out); - case 5: - return new FiveBitPackingWriter(out); - case 6: - return new SixBitPackingWriter(out); - case 7: - return new SevenBitPackingWriter(out); - case 8: - return new EightBitPackingWriter(out); - default: - throw new UnsupportedOperationException("only support up to 8 for now"); - } + return switch (bitLength) { + case 0 -> new ZeroBitPackingWriter(); + case 1 -> new OneBitPackingWriter(out); + case 2 -> new TwoBitPackingWriter(out); + case 3 -> new ThreeBitPackingWriter(out); + case 4 -> new FourBitPackingWriter(out); + case 5 -> new FiveBitPackingWriter(out); + case 6 -> new SixBitPackingWriter(out); + case 7 -> new SevenBitPackingWriter(out); + case 8 -> new EightBitPackingWriter(out); + default -> throw new UnsupportedOperationException("only support up to 8 for now"); + }; } /** @@ -104,28 +94,18 @@ public static BitPackingWriter getBitPackingWriter(int bitLength, OutputStream o * @return the correct implementation for the width */ public static BitPackingReader createBitPackingReader(int bitLength, InputStream in, long valueCount) { - switch (bitLength) { - case 0: - return new ZeroBitPackingReader(); - case 1: - return new OneBitPackingReader(in); - case 2: - return new TwoBitPackingReader(in); - case 3: - return new ThreeBitPackingReader(in, valueCount); - case 4: - return new FourBitPackingReader(in); - case 5: - return new FiveBitPackingReader(in, valueCount); - case 6: - return new SixBitPackingReader(in, valueCount); - case 7: - return new SevenBitPackingReader(in, valueCount); - case 8: - return new EightBitPackingReader(in); - default: - throw new UnsupportedOperationException("only support up to 8 for now"); - } + return switch (bitLength) { + case 0 -> new ZeroBitPackingReader(); + case 1 -> new OneBitPackingReader(in); + case 2 -> new TwoBitPackingReader(in); + case 3 -> new ThreeBitPackingReader(in, valueCount); + case 4 -> new FourBitPackingReader(in); + case 5 -> new FiveBitPackingReader(in, valueCount); + case 6 -> new SixBitPackingReader(in, valueCount); + case 7 -> new SevenBitPackingReader(in, valueCount); + case 8 -> new EightBitPackingReader(in); + default -> throw new UnsupportedOperationException("only support up to 8 for now"); + }; } } diff --git a/parquet-hadoop/src/main/java/org/apache/parquet/format/converter/ParquetMetadataConverter.java b/parquet-hadoop/src/main/java/org/apache/parquet/format/converter/ParquetMetadataConverter.java index 37c71d888b..7472b0a4ca 100644 --- a/parquet-hadoop/src/main/java/org/apache/parquet/format/converter/ParquetMetadataConverter.java +++ b/parquet-hadoop/src/main/java/org/apache/parquet/format/converter/ParquetMetadataConverter.java @@ -391,16 +391,12 @@ ConvertedType convertToConvertedType(LogicalTypeAnnotation logicalTypeAnnotation } static org.apache.parquet.format.TimeUnit convertUnit(LogicalTypeAnnotation.TimeUnit unit) { - switch (unit) { - case MICROS: - return org.apache.parquet.format.TimeUnit.MICROS(new MicroSeconds()); - case MILLIS: - return org.apache.parquet.format.TimeUnit.MILLIS(new MilliSeconds()); - case NANOS: - return TimeUnit.NANOS(new NanoSeconds()); - default: - throw new RuntimeException("Unknown time unit " + unit); - } + return switch (unit) { + case MICROS -> org.apache.parquet.format.TimeUnit.MICROS(new MicroSeconds()); + case MILLIS -> org.apache.parquet.format.TimeUnit.MILLIS(new MilliSeconds()); + case NANOS -> TimeUnit.NANOS(new NanoSeconds()); + default -> throw new RuntimeException("Unknown time unit " + unit); + }; } private static class ConvertedTypeConverterVisitor @@ -437,48 +433,36 @@ public Optional visit(LogicalTypeAnnotation.DateLogicalTypeAnnota @Override public Optional visit(LogicalTypeAnnotation.TimeLogicalTypeAnnotation timeLogicalType) { - switch (timeLogicalType.getUnit()) { - case MILLIS: - return of(ConvertedType.TIME_MILLIS); - case MICROS: - return of(ConvertedType.TIME_MICROS); - case NANOS: - return empty(); - default: - throw new RuntimeException("Unknown converted type for " + timeLogicalType.toOriginalType()); - } + return switch (timeLogicalType.getUnit()) { + case MILLIS -> of(ConvertedType.TIME_MILLIS); + case MICROS -> of(ConvertedType.TIME_MICROS); + case NANOS -> empty(); + default -> throw new RuntimeException("Unknown converted type for " + timeLogicalType.toOriginalType()); + }; } @Override public Optional visit( LogicalTypeAnnotation.TimestampLogicalTypeAnnotation timestampLogicalType) { - switch (timestampLogicalType.getUnit()) { - case MICROS: - return of(ConvertedType.TIMESTAMP_MICROS); - case MILLIS: - return of(ConvertedType.TIMESTAMP_MILLIS); - case NANOS: - return empty(); - default: + return switch (timestampLogicalType.getUnit()) { + case MICROS -> of(ConvertedType.TIMESTAMP_MICROS); + case MILLIS -> of(ConvertedType.TIMESTAMP_MILLIS); + case NANOS -> empty(); + default -> throw new RuntimeException("Unknown converted type for " + timestampLogicalType.toOriginalType()); - } + }; } @Override public Optional visit(LogicalTypeAnnotation.IntLogicalTypeAnnotation intLogicalType) { boolean signed = intLogicalType.isSigned(); - switch (intLogicalType.getBitWidth()) { - case 8: - return of(signed ? ConvertedType.INT_8 : ConvertedType.UINT_8); - case 16: - return of(signed ? ConvertedType.INT_16 : ConvertedType.UINT_16); - case 32: - return of(signed ? ConvertedType.INT_32 : ConvertedType.UINT_32); - case 64: - return of(signed ? ConvertedType.INT_64 : ConvertedType.UINT_64); - default: - throw new RuntimeException("Unknown original type " + intLogicalType.toOriginalType()); - } + return switch (intLogicalType.getBitWidth()) { + case 8 -> of(signed ? ConvertedType.INT_8 : ConvertedType.UINT_8); + case 16 -> of(signed ? ConvertedType.INT_16 : ConvertedType.UINT_16); + case 32 -> of(signed ? ConvertedType.INT_32 : ConvertedType.UINT_32); + case 64 -> of(signed ? ConvertedType.INT_64 : ConvertedType.UINT_64); + default -> throw new RuntimeException("Unknown original type " + intLogicalType.toOriginalType()); + }; } @Override @@ -924,16 +908,11 @@ private static byte[] tuncateMax(BinaryTruncator truncator, int truncateLength, } private static boolean isMinMaxStatsSupported(PrimitiveType type) { - switch (type.columnOrder().getColumnOrderName()) { - case TYPE_DEFINED_ORDER: - case IEEE_754_TOTAL_ORDER: - case INT96_TIMESTAMP_ORDER: - return true; - case UNDEFINED: - return false; - default: - throw new IllegalArgumentException("Unknown column order: " + type.columnOrder()); - } + return switch (type.columnOrder().getColumnOrderName()) { + case TYPE_DEFINED_ORDER, IEEE_754_TOTAL_ORDER, INT96_TIMESTAMP_ORDER -> true; + case UNDEFINED -> false; + default -> throw new IllegalArgumentException("Unknown column order: " + type.columnOrder()); + }; } /** @@ -1149,18 +1128,11 @@ private boolean overrideSortOrderToSigned(PrimitiveType type) { * @return the default sort order used when the logical type is not known */ private static SortOrder defaultSortOrder(PrimitiveTypeName primitive) { - switch (primitive) { - case BOOLEAN: - case INT32: - case INT64: - case FLOAT: - case DOUBLE: - return SortOrder.SIGNED; - case BINARY: - case FIXED_LEN_BYTE_ARRAY: - return SortOrder.UNSIGNED; - } - return SortOrder.UNKNOWN; + return switch (primitive) { + case BOOLEAN, INT32, INT64, FLOAT, DOUBLE -> SortOrder.SIGNED; + case BINARY, FIXED_LEN_BYTE_ARRAY -> SortOrder.UNSIGNED; + default -> SortOrder.UNKNOWN; + }; } /** @@ -1280,105 +1252,67 @@ public Optional visit( } public PrimitiveTypeName getPrimitive(Type type) { - switch (type) { - case BYTE_ARRAY: // TODO: rename BINARY and remove this switch - return PrimitiveTypeName.BINARY; - case INT64: - return PrimitiveTypeName.INT64; - case INT32: - return PrimitiveTypeName.INT32; - case BOOLEAN: - return PrimitiveTypeName.BOOLEAN; - case FLOAT: - return PrimitiveTypeName.FLOAT; - case DOUBLE: - return PrimitiveTypeName.DOUBLE; - case INT96: - return PrimitiveTypeName.INT96; - case FIXED_LEN_BYTE_ARRAY: - return PrimitiveTypeName.FIXED_LEN_BYTE_ARRAY; - default: - throw new RuntimeException("Unknown type " + type); - } + return switch (type) { + case BYTE_ARRAY -> PrimitiveTypeName.BINARY; // TODO: rename BINARY and remove this switch + case INT64 -> PrimitiveTypeName.INT64; + case INT32 -> PrimitiveTypeName.INT32; + case BOOLEAN -> PrimitiveTypeName.BOOLEAN; + case FLOAT -> PrimitiveTypeName.FLOAT; + case DOUBLE -> PrimitiveTypeName.DOUBLE; + case INT96 -> PrimitiveTypeName.INT96; + case FIXED_LEN_BYTE_ARRAY -> PrimitiveTypeName.FIXED_LEN_BYTE_ARRAY; + default -> throw new RuntimeException("Unknown type " + type); + }; } // Visible for testing Type getType(PrimitiveTypeName type) { - switch (type) { - case INT64: - return Type.INT64; - case INT32: - return Type.INT32; - case BOOLEAN: - return Type.BOOLEAN; - case BINARY: - return Type.BYTE_ARRAY; - case FLOAT: - return Type.FLOAT; - case DOUBLE: - return Type.DOUBLE; - case INT96: - return Type.INT96; - case FIXED_LEN_BYTE_ARRAY: - return Type.FIXED_LEN_BYTE_ARRAY; - default: - throw new RuntimeException("Unknown primitive type " + type); - } + return switch (type) { + case INT64 -> Type.INT64; + case INT32 -> Type.INT32; + case BOOLEAN -> Type.BOOLEAN; + case BINARY -> Type.BYTE_ARRAY; + case FLOAT -> Type.FLOAT; + case DOUBLE -> Type.DOUBLE; + case INT96 -> Type.INT96; + case FIXED_LEN_BYTE_ARRAY -> Type.FIXED_LEN_BYTE_ARRAY; + default -> throw new RuntimeException("Unknown primitive type " + type); + }; } // Visible for testing LogicalTypeAnnotation getLogicalTypeAnnotation(ConvertedType type, SchemaElement schemaElement) { - switch (type) { - case UTF8: - return LogicalTypeAnnotation.stringType(); - case MAP: - return LogicalTypeAnnotation.mapType(); - case MAP_KEY_VALUE: - return LogicalTypeAnnotation.MapKeyValueTypeAnnotation.getInstance(); - case LIST: - return LogicalTypeAnnotation.listType(); - case ENUM: - return LogicalTypeAnnotation.enumType(); - case DECIMAL: + return switch (type) { + case UTF8 -> LogicalTypeAnnotation.stringType(); + case MAP -> LogicalTypeAnnotation.mapType(); + case MAP_KEY_VALUE -> LogicalTypeAnnotation.MapKeyValueTypeAnnotation.getInstance(); + case LIST -> LogicalTypeAnnotation.listType(); + case ENUM -> LogicalTypeAnnotation.enumType(); + case DECIMAL -> { int scale = (schemaElement == null ? 0 : schemaElement.scale); int precision = (schemaElement == null ? 0 : schemaElement.precision); - return LogicalTypeAnnotation.decimalType(scale, precision); - case DATE: - return LogicalTypeAnnotation.dateType(); - case TIME_MILLIS: - return LogicalTypeAnnotation.timeType(true, LogicalTypeAnnotation.TimeUnit.MILLIS); - case TIME_MICROS: - return LogicalTypeAnnotation.timeType(true, LogicalTypeAnnotation.TimeUnit.MICROS); - case TIMESTAMP_MILLIS: - return LogicalTypeAnnotation.timestampType(true, LogicalTypeAnnotation.TimeUnit.MILLIS); - case TIMESTAMP_MICROS: - return LogicalTypeAnnotation.timestampType(true, LogicalTypeAnnotation.TimeUnit.MICROS); - case INTERVAL: - return LogicalTypeAnnotation.IntervalLogicalTypeAnnotation.getInstance(); - case INT_8: - return LogicalTypeAnnotation.intType(8, true); - case INT_16: - return LogicalTypeAnnotation.intType(16, true); - case INT_32: - return LogicalTypeAnnotation.intType(32, true); - case INT_64: - return LogicalTypeAnnotation.intType(64, true); - case UINT_8: - return LogicalTypeAnnotation.intType(8, false); - case UINT_16: - return LogicalTypeAnnotation.intType(16, false); - case UINT_32: - return LogicalTypeAnnotation.intType(32, false); - case UINT_64: - return LogicalTypeAnnotation.intType(64, false); - case JSON: - return LogicalTypeAnnotation.jsonType(); - case BSON: - return LogicalTypeAnnotation.bsonType(); - default: + yield LogicalTypeAnnotation.decimalType(scale, precision); + } + case DATE -> LogicalTypeAnnotation.dateType(); + case TIME_MILLIS -> LogicalTypeAnnotation.timeType(true, LogicalTypeAnnotation.TimeUnit.MILLIS); + case TIME_MICROS -> LogicalTypeAnnotation.timeType(true, LogicalTypeAnnotation.TimeUnit.MICROS); + case TIMESTAMP_MILLIS -> LogicalTypeAnnotation.timestampType(true, LogicalTypeAnnotation.TimeUnit.MILLIS); + case TIMESTAMP_MICROS -> LogicalTypeAnnotation.timestampType(true, LogicalTypeAnnotation.TimeUnit.MICROS); + case INTERVAL -> LogicalTypeAnnotation.IntervalLogicalTypeAnnotation.getInstance(); + case INT_8 -> LogicalTypeAnnotation.intType(8, true); + case INT_16 -> LogicalTypeAnnotation.intType(16, true); + case INT_32 -> LogicalTypeAnnotation.intType(32, true); + case INT_64 -> LogicalTypeAnnotation.intType(64, true); + case UINT_8 -> LogicalTypeAnnotation.intType(8, false); + case UINT_16 -> LogicalTypeAnnotation.intType(16, false); + case UINT_32 -> LogicalTypeAnnotation.intType(32, false); + case UINT_64 -> LogicalTypeAnnotation.intType(64, false); + case JSON -> LogicalTypeAnnotation.jsonType(); + case BSON -> LogicalTypeAnnotation.bsonType(); + default -> throw new RuntimeException( "Can't convert converted type to logical type, unknown converted type " + type); - } + }; } LogicalTypeAnnotation getLogicalTypeAnnotation(LogicalType type) { @@ -1387,69 +1321,60 @@ LogicalTypeAnnotation getLogicalTypeAnnotation(LogicalType type) { // Ignore unknown logical types to preserve the physical type. return null; } - switch (setField) { - case MAP: - return LogicalTypeAnnotation.mapType(); - case BSON: - return LogicalTypeAnnotation.bsonType(); - case DATE: - return LogicalTypeAnnotation.dateType(); - case ENUM: - return LogicalTypeAnnotation.enumType(); - case JSON: - return LogicalTypeAnnotation.jsonType(); - case LIST: - return LogicalTypeAnnotation.listType(); - case TIME: + return switch (setField) { + case MAP -> LogicalTypeAnnotation.mapType(); + case BSON -> LogicalTypeAnnotation.bsonType(); + case DATE -> LogicalTypeAnnotation.dateType(); + case ENUM -> LogicalTypeAnnotation.enumType(); + case JSON -> LogicalTypeAnnotation.jsonType(); + case LIST -> LogicalTypeAnnotation.listType(); + case TIME -> { TimeType time = type.getTIME(); - return LogicalTypeAnnotation.timeType(time.isAdjustedToUTC, convertTimeUnit(time.unit)); - case STRING: - return LogicalTypeAnnotation.stringType(); - case DECIMAL: + yield LogicalTypeAnnotation.timeType(time.isAdjustedToUTC, convertTimeUnit(time.unit)); + } + case STRING -> LogicalTypeAnnotation.stringType(); + case DECIMAL -> { DecimalType decimal = type.getDECIMAL(); - return LogicalTypeAnnotation.decimalType(decimal.scale, decimal.precision); - case INTEGER: + yield LogicalTypeAnnotation.decimalType(decimal.scale, decimal.precision); + } + case INTEGER -> { IntType integer = type.getINTEGER(); - return LogicalTypeAnnotation.intType(integer.bitWidth, integer.isSigned); - case UNKNOWN: - return LogicalTypeAnnotation.unknownType(); - case TIMESTAMP: + yield LogicalTypeAnnotation.intType(integer.bitWidth, integer.isSigned); + } + case UNKNOWN -> LogicalTypeAnnotation.unknownType(); + case TIMESTAMP -> { TimestampType timestamp = type.getTIMESTAMP(); - return LogicalTypeAnnotation.timestampType(timestamp.isAdjustedToUTC, convertTimeUnit(timestamp.unit)); - case UUID: - return LogicalTypeAnnotation.uuidType(); - case FLOAT16: - return LogicalTypeAnnotation.float16Type(); - case GEOMETRY: + yield LogicalTypeAnnotation.timestampType(timestamp.isAdjustedToUTC, convertTimeUnit(timestamp.unit)); + } + case UUID -> LogicalTypeAnnotation.uuidType(); + case FLOAT16 -> LogicalTypeAnnotation.float16Type(); + case GEOMETRY -> { GeometryType geometry = type.getGEOMETRY(); - return LogicalTypeAnnotation.geometryType(geometry.getCrs()); - case GEOGRAPHY: + yield LogicalTypeAnnotation.geometryType(geometry.getCrs()); + } + case GEOGRAPHY -> { GeographyType geography = type.getGEOGRAPHY(); - return LogicalTypeAnnotation.geographyType( + yield LogicalTypeAnnotation.geographyType( geography.getCrs(), toParquetEdgeInterpolationAlgorithm(geography.getAlgorithm())); - case VARIANT: + } + case VARIANT -> { VariantType variant = type.getVARIANT(); - return LogicalTypeAnnotation.variantType(variant.getSpecification_version()); - case FILE: - // Present in the format but not mapped to a LogicalTypeAnnotation yet. Ignore it to - // preserve the physical type, as an unrecognised logical type would be. - return null; - default: - throw new RuntimeException("Unknown logical type " + type); - } + yield LogicalTypeAnnotation.variantType(variant.getSpecification_version()); + } + // Present in the format but not mapped to a LogicalTypeAnnotation yet. Ignore it to + // preserve the physical type, as an unrecognised logical type would be. + case FILE -> null; + default -> throw new RuntimeException("Unknown logical type " + type); + }; } private LogicalTypeAnnotation.TimeUnit convertTimeUnit(TimeUnit unit) { - switch (unit.getSetField()) { - case MICROS: - return LogicalTypeAnnotation.TimeUnit.MICROS; - case MILLIS: - return LogicalTypeAnnotation.TimeUnit.MILLIS; - case NANOS: - return LogicalTypeAnnotation.TimeUnit.NANOS; - default: - throw new RuntimeException("Unknown time unit " + unit); - } + return switch (unit.getSetField()) { + case MICROS -> LogicalTypeAnnotation.TimeUnit.MICROS; + case MILLIS -> LogicalTypeAnnotation.TimeUnit.MILLIS; + case NANOS -> LogicalTypeAnnotation.TimeUnit.NANOS; + default -> throw new RuntimeException("Unknown time unit " + unit); + }; } private static void addKeyValue(FileMetaData fileMetaData, String key, String value) { @@ -2630,30 +2555,22 @@ public void writeDictionaryPageHeader( private static BoundaryOrder toParquetBoundaryOrder( org.apache.parquet.internal.column.columnindex.BoundaryOrder boundaryOrder) { - switch (boundaryOrder) { - case ASCENDING: - return BoundaryOrder.ASCENDING; - case DESCENDING: - return BoundaryOrder.DESCENDING; - case UNORDERED: - return BoundaryOrder.UNORDERED; - default: - throw new IllegalArgumentException("Unsupported boundary order: " + boundaryOrder); - } + return switch (boundaryOrder) { + case ASCENDING -> BoundaryOrder.ASCENDING; + case DESCENDING -> BoundaryOrder.DESCENDING; + case UNORDERED -> BoundaryOrder.UNORDERED; + default -> throw new IllegalArgumentException("Unsupported boundary order: " + boundaryOrder); + }; } private static org.apache.parquet.internal.column.columnindex.BoundaryOrder fromParquetBoundaryOrder( BoundaryOrder boundaryOrder) { - switch (boundaryOrder) { - case ASCENDING: - return org.apache.parquet.internal.column.columnindex.BoundaryOrder.ASCENDING; - case DESCENDING: - return org.apache.parquet.internal.column.columnindex.BoundaryOrder.DESCENDING; - case UNORDERED: - return org.apache.parquet.internal.column.columnindex.BoundaryOrder.UNORDERED; - default: - throw new IllegalArgumentException("Unsupported boundary order: " + boundaryOrder); - } + return switch (boundaryOrder) { + case ASCENDING -> org.apache.parquet.internal.column.columnindex.BoundaryOrder.ASCENDING; + case DESCENDING -> org.apache.parquet.internal.column.columnindex.BoundaryOrder.DESCENDING; + case UNORDERED -> org.apache.parquet.internal.column.columnindex.BoundaryOrder.UNORDERED; + default -> throw new IllegalArgumentException("Unsupported boundary order: " + boundaryOrder); + }; } public static ColumnIndex toParquetColumnIndex(