Modules

The serial core of the pure-Fortran sort engine: the ordering, and the introsort over it.

The six intrinsic pf_argsort specifics, their key extraction, and the engine dispatch.

Bodies of the schema-building module procedures declared in parquet_core.f90's interface block: parsing a MAML into a parquet_schema (parquet_parse_maml), building a schema from scratch (schema%init/%add_field), and the central parquet_parse_maml_lines parser, plus the private MAML-section helpers (keyarray:/DOI/depends/keywords/col_map/protected_cols) it depends on.

Generic parquet_column_info/parquet_table_metadata plumbing shared by both the write (MAML-build) and read sides: the base add_metadata family, per-field column_info lookups/toggles, and low-level MAML string helpers (parquet_split_key_value/parquet_unquote/parquet_to_lower) reused across submodules.

Everything here backs the parquet_get_metadata generic (declared in parquet_core.f90): reader%metadata is populated once, by parquet_open_reader (parquet_read.f90) copying the Arrow schema's flat key-value metadata, so every call here only scans that in-memory array -- it never touches the file. Messages follow the ": " error stop convention used throughout this module.

MAML-format-specific validation: the declarative schema of every top-level MAML section and its allowed sub-keys plus the validator and its private helpers that check a raw MAML's section/sub-key names against it (presence only, not values); full-schema structural validation (parquet_validate_maml); cross-checking a user MAML against a base schema (parquet_validate_user_maml); loading MAML/qc-maml files from disk; and qc-maml field parsing/validation for read-time quality control. Merges what used to be parquet_metadata_sections.f90 and parquet_metadata_validate.f90.

Writer lifecycle (open/close/new_row_group/finish_row_group) and the type-generic shared helpers every write-specifics child (parquet_write_numeric/ _string/_temporal) reaches by host association: schema/column-info lookups, row-count and row-mask bookkeeping, output-name resolution, qc: integer-count text formatting (shared by numeric and string qc: reports), and the write_maml=.true. sidecar .maml.

Numeric write specifics (int32/int64/float32/float64/logical, scalar and matrix, whole-column and row-group-chunked): bodies of the module procedures declared in parquet_core.f90's interface block, plus the numeric-only private helpers (schema-type widening/narrowing, append, qc: enforcement, qc: numeric-bound satisfaction, qc: real-value text formatting) they depend on.

String write specifics (scalar and matrix, whole-column and row-group-chunked, plus the fixed-width "compact" variants): bodies of the module procedures declared in parquet_core.f90's interface block, plus the string-only private qc: enforcement/bound-satisfaction helpers they depend on.

Temporal (date/time/timestamp) write specifics, scalar and matrix, whole- column and row-group-chunked: bodies of the module procedures declared in parquet_core.f90's interface block, plus the temporal-only private helpers (preamble/unit-resolution/validity/flat-write workers) they depend on.

Reader lifecycle (open/close), filter/qc machinery, metadata population, row-group resolution, and the type-generic shared helpers every read-specifics child (parquet_read_numeric/_string/_temporal) reaches by host association: validity-buffer construction, reader/column/row-group existence checks, fixed-width text packing for the filter/qc C++ API, and the whole-column-read-avoidance row-group helpers.

Filter-expression parsing: turns one parquet_filter%add rule ("(ra > 180 and dec <= 0) or id is_null") into the packed leaf arrays plus the postfix (RPN) node list the C++ evaluator runs (see parquet_reader_set_filter in parquet_wrapper.cpp). Purely syntactic -- no schema access at all, so nothing here can tell whether a column exists or whether a value suits its type; that validation stays C++-side, where the schema is.

Numeric read specifics (int32/int64/float32/float64/logical: column_1d, array_full, array_row_mode[_row_index], array_element_mode, and column_chunk/array_column_chunk, both row-group-index kinds): bodies of the module procedures declared in parquet_core.f90's interface block, plus the numeric-only private per-mode worker helpers they depend on.

Sort-key parsing: turns one parquet_sortkey%add key ("ra asc", "-dec", "main.inner.age") into the column name plus a direction flag the C++ engine takes (see parquet_reader_set_sort in parquet_wrapper.cpp). Purely syntactic -- no schema access at all, so nothing here can tell whether a column exists or whether its type is orderable; that validation stays C++-side, where the schema and the decoded array are.

String read specifics (column_1d, array_full, the fixed-width "compact" column form, array_row_mode[_row_index], array_element_mode, and column_chunk/array_column_chunk incl. the compact chunked form): bodies of the module procedures declared in parquet_core.f90's interface block, plus the string-only private per-mode worker helpers they depend on.

Temporal (date/time/timestamp) read specifics: column_1d, array_full, column_chunk/array_column_chunk (both row-group-index kinds), array_row_mode[_row_index], and array_element_mode: bodies of the module procedures declared in parquet_core.f90's interface block, plus the temporal-only private per-mode worker helpers they depend on.

pf_argsort and pf_sort for the element types that need a parquet column, a packed string store or a temporal element, plus pf_sort for every type and the multi-key pf_sort_keys form.

Turns the element types that need a column, a packed string store or a temporal element into the canonical key form the engine takes, and implements pf_sort_keys.

pf_permute (apply a permutation in place) and pf_is_sorted (test an existing order).

pf_minmax, pf_argminmax and pf_merge.

pf_lower_bound, pf_upper_bound and pf_equal_range -- locating a value in an array that is ALREADY sorted.

pf_partial_sort and pf_partial_argsort -- ordering only the first n elements.

pf_unique_count, pf_unique and pf_rank -- questions about repeated values.

Per-kind value access for parquet_table: the zero-copy pointer path (%col), the widening copy-out (%get) and the copy-back (%set).

Per-kind %add_column for parquet_table: appends a new in-memory column, taking its kind, width and row count from the values it is given.

Copying a parquet_table: %clone (an independent deep copy) and %clone_structure (an empty table with the same columns).

parquet_table_col — a resolved handle on one column of a parquet_table.

Per-kind value access for parquet_table_col, and the shared bodies the table's own %get_element calls so the two forms cannot answer differently.

Lifecycle of a parquet_table: opening one from a file, starting an empty in-memory one, destroying one, the blocked intrinsic assignment, and the slot/row bookkeeping that adding a column goes through.

Read-in (Role-B) MAML support for parquet_table: parsing the extra: remap: block that relabels a file's columns for reading, and building the descriptor slots from it.

Per-kind "read one file column into a parquet_column" for parquet_table.

Mutation that leaves a parquet_table's ROW SET alone: the single-cell validity writers (%set_null, %clear_null, %compact_validity) and the column-structural operations (%drop_column, %rename_column, %copy_column, %cast).

Everything that makes a parquet_table safe to use from more than one thread: the table's own lock, the counters behind the append/read contract, and the shared refusal every structural mutation routes through.

Binding the predefined columns a GENERATED table type declares: %bind_predefined.

Introspection and name resolution for parquet_table: the row/column counts, the per-column queries (%kind, %width, %unit, %residency, %is_null), and the shared lookup and guard helpers every value accessor is built on.

Turning a parquet file's columns into parquet_column stores: deciding each column's kind from the file schema, driving the per-kind readers, and freeing the Arrow buffers as it goes.

The row handle parquet_table_row: making one, resolving a column through it, and the two queries that do not depend on a column's kind. The per-kind %get specifics are generated into parquet_tables_access alongside the table's own accessors.

Mutation that changes a parquet_table's ROW SET: %filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append and %append_null_rows.

Row selection: building a parquet_slice and turning one into the explicit list of rows it picks out. The per-kind copies that consume that list are generated into parquet_tables_access next to the table's own %get.

Turns a parquet_table's key columns into a row permutation, using the library's own Fortran radix engine -- the SAME engine the read-time sort_by= runs on.

Writing a parquet_table back out to a parquet file.