All Classes and Interfaces
Class
Description
Factory for creating
AvroRowReader instances from a
ParquetFileReader.Builds an
AvroRowReader with optional projection, filter, and
head/tail row limit.Reads Parquet rows as Avro
GenericRecord instances.JFR event emitted when the consumer thread blocks waiting for a batch
to be assembled by the assembly thread.
One aligned slice of a file's columns.
Column chunk metadata.
How a column's values are encoded, set file-wide or per leaf column through
WriterConfig.Builder.encoding(ColumnEncoding).Column index for a column chunk, providing per-page min/max statistics for page-level filtering.
Ordering of min/max values across pages.
Metadata for a column chunk.
The ordering used for a leaf column's
min/max statistics, decoded from the
FileMetaData.column_orders union.Specifies which columns to read from a Parquet file.
Batch-oriented column reader for reading a single column across all row groups.
Holds multiple
ColumnReader instances backed by a shared
RowGroupIterator for batch-oriented projection reads.Represents a primitive column in a Parquet schema.
Writes a Parquet file one aligned batch of columns at a time.
Compression codecs supported by Parquet.
Legacy converted types in Parquet schema (used by PyArrow for LIST/MAP annotation).
Encoding types for Parquet data.
Marks a public API as experimental.
Common interface for name-based access to fields whose values are primitives,
Variants, or absent.
Path from the root schema to a leaf column, represented as a list of field names.
JFR event emitted when Hardwood memory-maps a region of a Parquet file.
Top-level file metadata for a Parquet file.
JFR event emitted when a Parquet file is opened and its metadata is read.
Root schema container representing the complete Parquet schema.
Builder for constructing a
FileSchema programmatically.Declares the element of a
LIST, or the value of a MAP: a primitive, a nested
struct, a nested LIST, or a nested MAP.Declares the fields of a
struct group.A predicate for filtering row groups based on column statistics.
Predicate for DATE columns.
Predicate for DECIMAL columns.
Predicate for TIMESTAMP columns.
Predicate for spatial bounding box.
Predicate that matches rows where the column value is not null.
Predicate that matches rows where the column value is null.
Predicate for decimal columns stored as
FIXED_LEN_BYTE_ARRAY, which require signed
(two's complement) comparison.Predicate for TIME columns.
Entry point for reading Parquet files with a shared thread pool.
Context object that manages shared resources for Parquet file reading.
Abstraction for reading Parquet file data.
Classifies a
ColumnReader layer between root and leaf.Appends the entries of one
LIST instance.Logical types that provide semantic meaning to physical types.
BSON document stored as a byte array.
Calendar date (days since Unix epoch).
Decimal with fixed scale and precision.
Geodesic formulations to model and compute the shortest path on Earth.
Enum stored as a UTF-8 string.
IEEE 754 half-precision (binary16) floating point, stored as a 2-byte
FIXED_LEN_BYTE_ARRAY in little-endian byte order.Geography type with configurable CRS
Geometry type with configurable CRS
Interval stored as a 12-byte fixed-length byte array (months, days, millis).
Integer type with a specific bit width and signedness.
JSON document stored as a UTF-8 string.
List (repeated element) logical type.
Map (key-value pairs) logical type.
Column whose every value is null.
UTF-8 encoded string.
Timestamp with configurable precision and UTC adjustment.
Time of day with configurable precision and UTC adjustment.
Resolution of time and timestamp logical types.
UUID stored as a 16-byte fixed-length byte array.
Variant (self-describing, semi-structured) logical type per the Parquet
Variant spec.
Appends the entries of one
MAP instance.Offset index for a column chunk, providing page locations for direct lookup.
Abstraction for writing Parquet file data.
JFR event emitted when a single Parquet data page is decoded.
The number of pages a writer produced for one combination of page type and encoding within a
column chunk.
JFR event emitted when pages are filtered by Column Index predicate push-down.
Location of a data page within a column chunk.
The kind of page stored in a column chunk.
Reader for one or more Parquet files.
Builds a single-column
ColumnReader with an optional filter.Builds a
ColumnReaders collection for batch-oriented access to a
projection of columns.Builds a
RowReader with optional projection, filter, and head/tail
row limit.Writes a Parquet file through a columnar or a row-oriented API:
ParquetFileWriter.columnWriter() takes an
aligned slice of typed arrays, ParquetFileWriter.rowWriter() takes one record at a time, and one file is
written through one of the two, not both.Physical types supported by Parquet format.
Specialized list interface for DOUBLE values.
Value type for the Parquet
INTERVAL logical type.Specialized list interface for INT32 values.
Type-safe list interface for reading Parquet list values.
Specialized list interface for INT64 values.
Type-safe interface for accessing Parquet MAP values.
A single key-value entry in a map.
Type-safe struct interface for reading nested Parquet data.
Variant value — the top-level accessor for a Parquet column annotated with
the
VARIANT logical type.Indexed view of a Variant
ARRAY value.Name-based view of a Variant
OBJECT value.What
RowWriter does with a value carrying more precision than the column it is written
to can hold — an Instant with microseconds into a TIMESTAMP(MILLIS) column,
a BigDecimal with three decimals into a DECIMAL(_, 2) column.JFR event emitted when the prefetch queue cannot supply a decoded page in time.
How an
S3InputFile caches fetched byte ranges.Read-time behaviour knobs for
ParquetFileReader.Builder for
ReaderConfig.JFR event emitted when records are filtered by record-level predicate evaluation.
Field repetition types in Parquet schema.
Row group metadata.
JFR event emitted when row groups are selected by a byte-range row-group predicate
(split-aware reading).
JFR event emitted when row groups are filtered by a predicate push-down filter.
A predicate over row groups, used to select which row groups a reader scans.
Conjunction of row-group predicates — a row group passes if and only if every child passes.
Keep row groups whose midpoint falls in
[startInclusive, endExclusive).JFR event emitted when all pages in a row group column chunk have been scanned.
Provides row-oriented iteration over a Parquet file.
Writes a Parquet file record by record, over the same columnar core
ColumnWriter
exposes through ColumnWriter.writeBatch(Consumer).Long-term or temporary AWS credentials.
Supplies
S3Credentials for signing S3 requests.InputFile backed by an object in Amazon S3 (or an S3-compatible service).A configured connection to an S3-compatible object store.
Builder for
S3Source.Schema element in Parquet file metadata.
Thrown when a file cannot be read under the schema the read was planned against.
Tree-based representation of Parquet schema for nested data support.
Group node representing a struct, list, map, or variant.
Primitive leaf node representing an actual data column.
Bridges the AWS SDK credential chain to Hardwood's types.
Size statistics for a column chunk: the unencoded size of its
BYTE_ARRAY data
and its repetition- and definition-level histograms.Column chunk statistics for min/max values, null count, and distinct count.
Parquet-struct access interface.
Sets the fields of one struct — a record being written, or a struct nested inside one.
Per-item nullability over a run of items, shared by the reader and the writer: the
reader returns it (a column-reader leaf or
STRUCT / REPEATED layer scope), and the
writer accepts it as a column's null mask.Logical type of a Variant value, as carried in the Variant binary encoding's
value header.
Thrown when a Variant accessor is called on a value whose tagged type
does not match what the accessor expects — for example, calling
PqVariant.asInt() on a Variant holding a STRING.Tuning knobs for
ParquetFileWriter.Builder for
WriterConfig.