rdblue commented on code in PR #3397: URL: https://github.com/apache/parquet-java/pull/3397#discussion_r4099583430
########## parquet-column/src/main/java/org/apache/parquet/column/values/alp/AlpValuesReader.java: ########## @@ -0,0 +1,306 @@ +/* + * 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.parquet.column.values.alp; + +import static org.apache.parquet.column.values.alp.AlpConstants.ALP_COMPRESSION_MODE; +import static org.apache.parquet.column.values.alp.AlpConstants.ALP_HEADER_SIZE; +import static org.apache.parquet.column.values.alp.AlpConstants.ALP_INFO_SIZE; +import static org.apache.parquet.column.values.alp.AlpConstants.ALP_INTEGER_ENCODING_FOR; +import static org.apache.parquet.column.values.alp.AlpConstants.MAX_LOG_VECTOR_SIZE; +import static org.apache.parquet.column.values.alp.AlpConstants.MIN_LOG_VECTOR_SIZE; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import org.apache.parquet.bytes.ByteBufferInputStream; +import org.apache.parquet.column.values.ValuesReader; +import org.apache.parquet.io.ParquetDecodingException; + +/** + * Abstract base class for ALP values readers with lazy per-vector decoding. + * + * <p>Reads ALP-encoded values from the interleaved page layout: + * <pre> + * ┌─────────┬──────────────────────┬──────────────┬──────────────┬─────┐ + * │ Header │ Offset Array │ Vector 0 │ Vector 1 │ ... │ + * │ 7 bytes │ 4B × numVectors │ (interleaved)│ (interleaved)│ │ + * └─────────┴──────────────────────┴──────────────┴──────────────┴─────┘ + * </pre> + * + * <p>Each vector is decoded lazily on first access. Skipping values does not + * trigger decoding of intermediate vectors. + */ +abstract class AlpValuesReader extends ValuesReader { + + protected int vectorSize; + protected int totalCount; + protected int numVectors; + protected int pageValueIndex; + protected int currentVectorNumber; + + protected int[] vectorOffsets; + protected ByteBuffer vectorsData; + protected int offsetArraySize; + + // Scratch buffer for exception positions within a vector; shared by both readers (int[] in each). + protected int[] excPositionsBuffer; + + AlpValuesReader() { + this.pageValueIndex = 0; + this.totalCount = 0; + this.currentVectorNumber = -1; + } + + @Override + public void initFromPage(int valuesCount, ByteBufferInputStream stream) + throws ParquetDecodingException, IOException { + ByteBuffer headerBuf = stream.slice(ALP_HEADER_SIZE).order(ByteOrder.LITTLE_ENDIAN); + int compressionMode = headerBuf.get() & 0xFF; + int integerEncoding = headerBuf.get() & 0xFF; + int logVectorSize = headerBuf.get() & 0xFF; + int numElements = headerBuf.getInt(); + + if (compressionMode != ALP_COMPRESSION_MODE) { + throw new ParquetDecodingException("Unsupported ALP compression mode: " + compressionMode); + } + if (integerEncoding != ALP_INTEGER_ENCODING_FOR) { + throw new ParquetDecodingException("Unsupported ALP integer encoding: " + integerEncoding); + } + if (logVectorSize < MIN_LOG_VECTOR_SIZE || logVectorSize > MAX_LOG_VECTOR_SIZE) { + throw new ParquetDecodingException("Invalid ALP log vector size: " + logVectorSize + ", must be between " + + MIN_LOG_VECTOR_SIZE + " and " + MAX_LOG_VECTOR_SIZE); + } + if (numElements < 0) { + throw new ParquetDecodingException("Invalid ALP element count: " + numElements); + } + // ALP's num_elements is the count of non-null values that went through encoding; + // valuesCount is the page row count, which is larger when the column has nulls. + // The two are equal only for required (non-null) columns. + if (numElements > valuesCount) { + throw new ParquetDecodingException( + "ALP header element count " + numElements + " exceeds page valuesCount " + valuesCount); + } + + this.vectorSize = 1 << logVectorSize; + this.totalCount = numElements; + + // Bound the vector count against the bytes actually present before allocating anything. + // numElements is only capped by valuesCount, which a forged page can set as high as + // Integer.MAX_VALUE, so computing this in int would overflow to a negative count, and even + // without overflow a large count would drive a huge int[] and a huge stream.slice allocation. + // Every vector costs a 4-byte offset entry plus at least its ALP and FOR headers, which gives + // a hard ceiling on how many vectors the remaining bytes can possibly describe. + int minVectorBytes = ALP_INFO_SIZE + forInfoSize(); + long bodyBytes = stream.available(); + long numVectorsLong = ((long) numElements + vectorSize - 1) / vectorSize; + long minBodyBytes = numVectorsLong * (Integer.BYTES + minVectorBytes); + if (minBodyBytes > bodyBytes) { + throw new ParquetDecodingException("ALP header element count " + numElements + " requires at least " + + minBodyBytes + " bytes but only " + bodyBytes + " remain in the page"); + } + this.numVectors = (int) numVectorsLong; + this.pageValueIndex = 0; + this.currentVectorNumber = -1; + + this.offsetArraySize = numVectors * Integer.BYTES; + ByteBuffer offsetBuf = stream.slice(offsetArraySize).order(ByteOrder.LITTLE_ENDIAN); + this.vectorOffsets = new int[numVectors]; + for (int v = 0; v < numVectors; v++) { + vectorOffsets[v] = offsetBuf.getInt(); + } + + // Slice remaining bytes into a 0-based view so decodeVector can use + // absolute get methods (vectorsData.get(pos)) directly. + int remainingBytes = (int) stream.available(); + ByteBuffer rawSlice = stream.slice(remainingBytes); + this.vectorsData = rawSlice.slice().order(ByteOrder.LITTLE_ENDIAN); + + validateVectorOffsets(minVectorBytes); + + allocateDecodedBuffer(vectorSize); + this.excPositionsBuffer = new int[vectorSize]; + } + + /** + * Validates the offset array against the page body before any vector is decoded. Offsets are + * relative to the start of the compression body (the offset array itself), so the first vector + * must begin exactly where the offset array ends, offsets must increase by at least one vector's + * fixed headers, and every vector must start early enough to fit those headers. Without this a + * forged offset can point into another vector and silently decode the wrong values. + */ + private void validateVectorOffsets(int minVectorBytes) { + int bodyLimit = offsetArraySize + vectorsData.limit(); + for (int v = 0; v < numVectors; v++) { + int offset = vectorOffsets[v]; + if (v == 0) { + if (offset != offsetArraySize) { + throw new ParquetDecodingException("ALP first vector offset " + offset + + " must equal the offset array size " + offsetArraySize); + } + } else if ((long) offset - vectorOffsets[v - 1] < minVectorBytes) { + throw new ParquetDecodingException("ALP vector offsets must increase by at least " + + minVectorBytes + " bytes, but vector " + v + " starts at " + offset + " after vector " + + (v - 1) + " at " + vectorOffsets[v - 1]); + } + if (offset > bodyLimit - minVectorBytes) { + throw new ParquetDecodingException("ALP vector " + v + " offset " + offset + + " leaves no room for its headers before the end of the page body at " + bodyLimit); + } + } + } + + /** + * The position just past the last byte vector {@code vectorNumber} may read, derived from the + * next vector's offset (or the end of the body for the final vector). + */ + private int getVectorEndPosition(int vectorNumber) { + if (vectorNumber < numVectors - 1) { + return vectorOffsets[vectorNumber + 1] - offsetArraySize; + } + return vectorsData.limit(); + } + + protected int getVectorLength(int vectorNumber) { + if (vectorNumber < numVectors - 1) { Review Comment: I find static helpers can improve readability in cases like this. If you instead used `isLast(vectorIndex)` then it would be easier to understand. `isLast` should get inlined automatically and you can reuse it in several methods. ```java if (isLast(vectorIndex)) { int lastVectorSize = totalCount % valuesPerVector; return lastVectorSize == 0 ? vectorSize : lastVectorSize; } return vectorSize; ``` -- 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]
